Ryan Gilpatric

AI agents write the code. I decide what ships.

The work

Corsetta’s owner brief on an iPad: what needs the owner this morning, from fittings to confirm to pickups waiting, over the boutique’s numbers for the week and the month.
Sample data

Corsetta

An offline-first bridal-shop app currently in pilot, built around appointments, alterations, payments and pickup.

The case study

OpeX Liquidity in a desktop window, showing one stock, UiPath: its daily prices since March drawn over the options contracts open at each strike price, calls in orange and puts in blue, the largest listed down the right with their expiries.

OpeX Liquidity

Open interest is usually shown as a snapshot. OpeX Liquidity shows it as a history: every strike in a stock’s option chain, day by day, drawn around the price. You can watch walls of positioning form, grow and fade, and every contract stays in the history even after it expires. Time stays honest too. Nothing appears before the day it was known, so any past session replays exactly as it stood then.

The case study

Writing

  1. When Execution Gets Cheap, Direction Gets Exposed
  2. When the Answer Sounds Finished
  3. How I Build with AI Agents

How I work

  1. Start with the person using the product
  2. Turn the outcome into a bounded assignment
  3. Give implementation a clear owner
  4. Review from a separate context
  5. Prove the complete change
  6. Release into the real system

The whole method

The staircase, lit alabaster in a well of honed charcoal, seen from the one viewpoint where its four flights close into a loop that climbs forever.

Let’s build
something together.

Write me a note

Ryan Gilpatric

How I Build with AI Agents

Where my workflow for building with AI agents came from: one long session that failed, the two lanes that replaced it, and three failures that review caught.

One long session

AI coding agents built this website, under a process I arrived at by failing in one particular way. The process as I run it today is set out in How I work. This essay is about where it came from.

The failure was one long session. I asked a single conversation to be strategist, product manager, architect, implementer, reviewer and release manager at once. As the context grew, constraints I had set early on blurred, the scope widened, quality dropped, and assumptions made at the start were quietly reinterpreted. The model was capable enough. What failed was the process I had put around it.

Two lanes

The fix was to separate orchestration from implementation. I split the work into two lanes, each in its own session, and moved the work between them by hand. The control lane decided what to build, in what order, and whether the result was good enough to accept. The execution lane received one tightly scoped specification, did that piece of work, and returned the result. The execution lane never chose what came next, and the control lane never wrote code.

Slice specifications

Each piece of work, which I call a slice, started as a written specification. Before an execution session touched code, the spec stated what the slice would deliver, what it must not do, which files were in scope, what context was deliberately withheld to keep the session focused, the exact commands that would validate the work, and what counted as done. Writing the spec usually took longer than the execution. That was time well spent, because a well-scoped slice came back clean and a vague one came back as plausible code that missed the intent.

The first version of this site took roughly 15 slices. The first set up the project: Next.js 15, TypeScript, Tailwind and a CI pipeline. Each one after that built a single unit, such as the design tokens, the layout shell, the schema for project pages, the test infrastructure or the animations. No slice did two things, and each had to pass an explicit acceptance check before the next began.

What review caught

After each slice I reviewed what came back, looking for problems before confirming success. Three results from the site build show why.

One execution session reported that linting had passed. It had run the linter before the build output existed. When I ran it again, hundreds of errors appeared, from compiled files that the ESLint configuration did not exclude. A second session built a Contact component and a Footer that carried different email addresses and different LinkedIn URLs, because it had no memory of what an earlier session had used. A third filled the copy with em dashes, a mark that readers increasingly associate with AI-generated text.

Each of these was caught from outside the session that did the work, and that is the case for keeping review separate: a session that has made a mistake checks its work with the same context that produced the mistake. The second failure also shows what the split costs. One long session would have remembered the email address. Separate sessions share only what has been written down.

Files as memory

The most important rule in the workflow follows from that: durable state lives in files in the repository, and session history is disposable. Every session started from the same four documents: an operating model, a living build plan, a decision log and an architecture overview. The repository is private, so I can describe those files here but not link to them. When a control session grew heavy, I restarted it from the files. When an execution session was still failing after two corrections, I ended it and started a new one.

The workflow had costs. Execution sessions still made inconsistent choices from one slice to the next, because they shared no memory beyond those files. The overhead was real as well: writing a detailed spec, carrying it to another session, bringing the result back, reviewing it and logging the decision. For a ten-line fix that felt heavy, and I was often tempted to skip it. When I did, the fix was fine at the time and occasionally caused a consistency problem later.

What it changed

What the process changed for me was how much I could build. The code was sometimes better than I would have written alone and sometimes worse. But the first version of this site went from an empty directory to a deployed, tested and documented site in a single working session. Implementation speed had stopped being the constraint, and the quality of the specifications and the rigor of the verification had taken its place.

I think that holds beyond one website. The scarce skills in building software with agents are knowing what to build, how to break it into pieces, and how to verify that what was built is correct. The first two are product and systems thinking. The third also takes engineering knowledge. Rerunning the linter showed the errors, but it took knowing how a build works to see why the first pass had meant nothing. The people who build the most with agents will be the ones who get very good at the control lane.

The workflow has grown since the site was built. A control agent now scopes each change, an implementation agent works in an isolated checkout and returns a pull request, and a separate agent reviews the code against the agreed behavior before I decide whether it ships. The rules underneath are the ones described here. If any of this is useful to you, take what works and make it yours.