Jason Dicken

How I work

AI accelerates the work. I own the result.

Claude Code, Codex and coordinated agents write most of my code. That's a legitimate way to build software when someone is responsible for the requirements, the decisions and the validation. On my projects, that someone is me.

The process

Five stages, and who does what in each

Discover

Understand the business challenge, the operational workflow, the people who'll use it and what they need. Most of the value of a system is decided here, before any code exists.

Me Interviews, observation, the operator's view, written requirements.

Architect

Plan the features, data structures, integrations, automation and user experience, and write down the decisions that must not drift, like "only one module may contact a customer."

Me Data model, integration plan, approval rules, decision log.AI Drafts options and spots gaps for me to decide on.

Develop

Claude Code, Codex and coordinated agents implement the software against the written requirements, one scoped task at a time, with a handoff note at the end of each.

AI Most of the implementation.Me Task scoping, agent coordination, code review, sending back what's wrong.

Test & validate

Run the real workflows, find the bugs, verify each integration against the live service, and refine. For AI features, write a test set and measure. A demo that works once isn't evidence.

Me Workflow testing, integration checks, test sets, reading every failure.AI Test suites and harnesses, written to my spec.

Deploy & improve

Release it, run it, watch what users actually do, fix what breaks and keep improving. Two of my systems have run real businesses day to day, so production problems land on me.

Me Deployment, operation, triage, the decision on what ships next.

Beyond the prompt

What successful AI-assisted development actually takes

Getting an agent to generate code is easy. Getting software that's right, and stays right, takes the skills below. None of them is a prompt.

Understanding business requirements

Knowing the domain well enough to spot when a correct-looking feature is wrong for the people using it.

Decomposing complex problems

Turning a business need into data models, rules and tasks small enough for an agent to build and a person to check.

Managing development agents

Scoped tasks, written handoffs, decision logs, and one writer at a time so parallel agents don't collide.

Evaluating outputs

Reading what was built against what was asked. Plausible code that passes a glance is where the expensive bugs live.

Debugging

Tracing a production failure to its cause, such as a job that ran five hours early or an endpoint that 500s with nothing in the log.

Testing and delivery

Test sets for AI behavior, workflow testing for everything else, then deploying and running it reliably.

In practice

Four habits that keep agent-built software honest

I specify, review and own; agents write most of the code

I own requirements, architecture, the agent and system prompts, review, testing, deployment and operation. On the evaluation project that also meant the behavior rules in every prompt version, the held-out questions, and reading every failure myself.

Decisions get written down

Every project keeps a handoff document and a dated decision log, so an agent picking up the work reads the same constraints I would otherwise repeat. From Galley's log: vendors are shoppers, not warehouses, so no line prices anywhere and spend is the typed receipt total. That's the part a model can't infer from the codebase.

One writer at a time

Two agents and a human in one repository will collide. The evals repo carries a baton: a tracked file naming the current holder, with a pre-commit hook that rejects commits from anyone else. Handoff notes are mandatory and written for the next agent.

Prompts drift, so they get audited

A prompt is code, but nothing tests it unless you write the test on purpose. My CRM orchestrator still described "a team of sixteen specialist agents" months after the fleet had grown past that. It was true when written, wrong for months, and invisible until someone read it against the code.

Looking for someone who builds this way?

I'm open to remote roles at teams that embrace AI-assisted development, and to contract and freelance projects.