← Home
An agentic SDLC

An agentic SDLC

I build my own apps with Claude Code agents doing most of the implementation. One agent writing code is easy to set up. Several of them shipping reviewed, tested changes to several apps every day, on one build machine, without me testing anything by hand, took a process. I designed it, I run it, and I change it when it fails.

The loop

Work is a roadmap card with a list of “Done when” boxes. A long-lived lead session picks a card, writes a brief and hands it to a worker in its own git worktree. The worker builds, runs the tests, takes screenshots in the simulator and reads them, then writes a hand-back file with the evidence for each box. A separate reviewer returns pass or changes. After a pass and green CI the lead merges, records the status on a dashboard, and writes one line in a retro log. Lessons from that log become rules in the files the agents read.

A question for me parks one card, not the queue. Small reversible choices are made by the lead after about fifteen minutes and listed for me to accept or reverse. I keep what can’t be undone, anything outward-facing, taste, scope and pricing, and the rules themselves.

Design decisions

  • The reviewer is independent by construction. It is never the model that wrote the code, it gets a fresh context every round, and it is given the card, the diff and the screenshots but not the implementer’s explanation. A reviewer that shares the author’s context tends to accept the author’s reasoning.
  • Proof is a required field. A “Done when” box without evidence sends the card back. Each new test has to be shown failing on the old code, because a test that passes before the fix proves nothing.
  • The build machine is the scarce resource, not the models. One machine hosts the simulators and the CI runner. It crashed twice in one day under parallel simulator jobs, so there is one lane: a single simulator job at a time, behind a gate script that reads the machine’s state before anything boots. A push counts as the lane, because it starts CI on the same machine.
  • Guardrails are code where they can be. A hook asks or denies on the commands that are hard to take back, such as a push to an app’s main branch, and lets a merge through only when a review pass is recorded on the pull request.
  • Rules can be renegotiated, with data. The rule that stops a run to protect the machine was wrong three times, stopping healthy runs. Each version was replaced using readings from the runs it had wasted.

Numbers

The first four and a half days of the lead loop, November 12 to 16, 2026, across two apps:

FigureValue
Pull requests merged30, carrying 46 roadmap cards
Review rounds per pull requestmedian 2, mean 2.8, most 6
First review asked for changes24 of 30
Reviewer runs87: 60 asked for changes, 27 passed

There is no baseline, no count of defects that got past review, and no cost figure. The rate of requested changes reflects a strict protocol as well as real defects.

What review caught

  • A regenerated data file had lost part of 216 source links because the generator fell back silently when its cache was missing. The worker’s tests passed.
  • A sync merge rule had two holes its tests could not see, because every test started from a settled state.
  • A CSS filter written as a denylist kept losing to the next trick over six review rounds, until it became an allowlist.
  • A pixel test “proved” a fix by reading through translucent glass.

What I got wrong

After two weeks I went back through one app’s 102 pull requests. Five mistakes had kept recurring after a rule against each was written, because the rules sat in a log that no worker reads. A lesson changes nothing until it is in the file the worker or the reviewer loads, as a required field or a check. That is now done at every merge.

The lead also made the errors it exists to prevent: it once nearly merged commits no reviewer had read. The fix was a rule that lead acceptance is not a review.

Limits

The apps are unreleased, so none of this has met production. Review is expensive: some small cards took four to six rounds. PR CI runs the fast tier only, and the nightly full run finds what was missed a day later. The reviewer and the implementer are models from the same vendor, so shared blind spots are possible and untested.

The files

The working files are public and kept in step with the live setup: the agent definitions, the guard hook, the machine scripts, a real card from brief to review, and the full retro log. They are at github.com/thejlyons/agentic-sdlc.