The bottleneck moved, so I moved
For most of my career, the unit of work was the keystroke. You thought, you typed, you tested, you shipped. AI pair tools chipped at that from 2022 onward, but the job stayed the same shape: an engineer with a very fast autocomplete.
Somewhere over the last year and a half, the shape changed. The agents got good enough to take a ticket from description to pull request on their own. Anthropic’s 2026 Agentic Coding Trends report describes the same thing I was living: being a software engineer increasingly means orchestrating agents that write code — evaluating their output, giving direction — rather than typing the code yourself. The industry phrase is agentic engineering. My phrase is simpler: I stopped being the typist and became the line manager.
But here’s the part that took me longest to accept: when agents write the code, writing code stops being the constraint. Deciding what to build, reviewing what was built, and verifying it actually works become the constraint. Any hour I spend has to go where the bottleneck now is.
That realisation produced the two systems I now run every working day: AI Light Factory on the build side, and Three-Pass Review on the review side. Both are open source. What follows is how they fit together into one working day.
PRD in, merged code out
Here is the end-to-end shape. Solid boxes are me. Dashed boxes are agents. Every ◆ is a gate where I approve before anything moves on — and the last step, the merge, is one no agent can perform, enforced by hooks and shims rather than by a sentence in a prompt.
Mornings are for decisions. Agents get the afternoon.
In practice the line gives my day a rhythm. Decisions, plans and tickets happen while I’m sharpest. Then the dev loop runs unattended while I do the work only I can do — architecture conversations, mentoring, the odd production question. Late in the day I come back, read what needs me, and merge.
The “glance at the board” part matters. While the loop runs, this is the only screen I read, ordered by what needs me:
2026-10-09-m2-billing-exports Thu 09 Oct 16:12 ----------------------------------------------------------------------------------------------- FLAG TICKET PR / SHA SEAT STATE NEXT ----------------------------------------------------------------------------------------------- PARK T2.3 #71 Rounding rules #74 c20d1e1 - Critical survives needs you LANE T2.5 #73 CSV writer - Reviewer review round 1 judge findings LANE T2.6 #75 Column registry - Developer-2 building review SWEEP T2.2 #70 Export job #76 9ae02b4 Guardian 1 bot thread verify push DONE T2.1 #69 Export schema #68 41b7fa0 - draft, swept you read it ----------------------------------------------------------------------------------------------- 2 advancing · 1 sweeping · 1 needs you · 1 done lanes 2/2 · $9.80
One lane parked because a Critical finding survived two review rounds — that’s the rule: two review rounds, then a human. Everything else kept moving without me.
AI Light Factory: the agents draft, I merge
The name comes from Addy Osmani’s distinction in Software Factories, Light and Dark. A dark factory ships code no human has read. A light factory keeps a human in the loop, and gives a loop only as much autonomy as you can cheaply and reliably verify. I take the light side literally: my judgement moves to where it pays off, and everything in between runs unattended.
The factory is five stages, and I built it after a year of running agent lines on production codebases and watching exactly where they go wrong:
| Stage | Who | What I decide |
|---|---|---|
| 1 · Decide | Architect agent, running Matt Pocock’s grill-with-docs, grills me one question at a time and writes the ADRs |
Do the decisions hold? |
| 2–3 · Plan | Planner writes the plan with Addy Osmani’s agent-skills, then publishes tickets with blocking edges via to-tickets |
Right plan? Right tickets? |
| 4 · Dev loop | Developer builds, a Reviewer from another vendor reviews, Guardian sweeps threads | Nothing. It runs unattended |
| 5 · Verify | Verifier drives the running app in every feature-flag state | Merge. Always mine |
Three defaults in there came straight from pain:
A reviewer from the same vendor shares the builder’s blind spots
When the model that wrote the code also reviews it, its misses are silent — both passes share the same gaps. So in my setup Claude Code fills the Developer, Guardian and Verifier seats, and OpenAI’s Codex fills the Reviewer seat: Claude writes the code, Codex reads it. Different vendor, fresh context, by design. If you put the same vendor in both seats, every PR says so.
Unlimited parallelism is a trap
Run wide open, a fleet of agents burns a week of model budget in days and opens more PRs than any human can review. Two lanes is the ceiling, and it isn’t a starting point to tune upward.
Guardrails are code, not prompts
The line never marks a PR ready, never approves, never merges. That isn’t a sentence in a prompt a model might skip — it’s a guard hook and a pair of git/gh shims that refuse those commands for every worker, whatever agent sits in the seat.
The seats, by name
For the curious, this is the actual stack I run the line with:
| Tool | Where it sits in my workflow |
|---|---|
| Claude Code | The Developer, Guardian and Verifier seats — it writes the code, sweeps the threads, drives the app in every flag state |
| OpenAI Codex | The Reviewer seat. Codex reviews every line Claude writes, with fresh context and none of the builder’s blind spots |
| GitHub Copilot | Pass 1 of review — line comments on every push, before anyone spends attention |
| Orca | My agentic-workflow workspace — where the line’s seats run, and where I watch them work |
| gstack | Stacked pull requests. An unmerged dependency is a base branch, not a blocker, so a milestone keeps moving while drafts wait for me |
| Skill packs | Matt Pocock’s grill-with-docs and to-tickets, and Addy Osmani’s agent-skills — published SKILL.md files, used as they are |
Orca is where I watch the line run. Every seat on the factory is a named agent in the sidebar, and on a good afternoon all of them are busy at once:
Seats · 5 running
Three-Pass Review: AI reads every line, people own the risk
Once agents write most of a pull request, review becomes the slow part. Teams answer that one of two ways — rubber-stamp the change, or read every line as if a person had written it — and neither holds up. AI can read every line of every push, cheaply, without getting tired. What it can’t do is own the decision. So my process gives the reading to AI and keeps the decision with people, and scales the effort to the risk: a copy fix and a payments migration should not get the same review.
Pass 3 is my favourite part, because it fixes the real problem with AI review: even a good one hands the human a pile of comments. On a big, risky change, what a reviewer needs first is the shape of it. So the deep pass opens with a reviewer brief, built to be read in five minutes before anyone opens the code: what the change does, a change map computed from the diff with no model at all, the blast radius, whether a plain revert undoes it, where to look first. Under the hood, three independent AI checks — correctness, security and data safety, architecture — read one frozen input in parallel and never see each other’s output, so when two of them flag the same lines on their own, that agreement is a signal rather than an echo.
Then the code owner and a second reviewer take over. The draft says what the AI saw. The approval has to say what the person verified.
What changed under the hood this year
None of this would have been practical in 2023. A few shifts in the tooling made it ordinary:
- Agents became teammates with CLIs, not autocomplete. Claude Code, Codex and their peers run whole tickets in a terminal seat — plan, edit, test, open the PR. The craft moved from prompting to seat design: what each agent may touch, and what it must leave behind.
- Skills became a portable format. The open Agent Skills spec means a review discipline or a planning method is a
SKILL.mdfile any agent can follow. My factory runs on published packs from Matt Pocock and Addy Osmani, used as they are — I only built what didn’t exist: the loop, the gates, the guardrails. - MCP became the wiring. The Model Context Protocol gives agents the same typed access to tools and data, whoever made the agent. It’s how my side projects expose Strava data or Philippine payroll math to any client, and it’s why a cross-vendor Reviewer seat is a config line rather than a science project.
- Multi-agent coordination went mainstream. The pattern Anthropic’s 2026 trends report calls out — single agents becoming coordinated teams, with humans scaling oversight through AI-automated review — is exactly the orchestrator-and-seats shape of the dev loop, and exactly why review had to become a system of its own.
- Hooks made guardrails enforceable. Agent runtimes now expose pre-tool-use hooks and sandboxed execution, so “never merge” can be a refusal at the command layer instead of a plea in a prompt. That one capability is the difference between a light factory and a hopeful one.
The number that keeps me honest, though, is also from that report: engineers lean on AI for most of their work, yet say they can fully delegate only a small slice of it. That gap — between “AI did most of it” and “nobody checked it” — is where my whole workflow lives.
The parts I refuse to delegate
After a year of running this on real codebases, the rules I keep are less about capability and more about accountability:
- Never guess for the human. The line may stop and wait for me, but it never fills a gap in my decisions with its own guess — a guess that reads as a decision gets built, reviewed and merged exactly as written.
- Questions belong on the ticket. A question about what the work should be is a planning defect, not a runtime event.
- Two review rounds, then a human. If two rounds haven’t converged, a third won’t either.
- Check the effect, not the message. After any step that changes the world, I look at the result itself —
gh pr view, not “PR created!”. - Merging is the measurement. A draft only counts as a success once a human has merged it. The AI never approves, and I own every line that ships, whoever typed it.
Being a software engineer in the AI era isn’t typing faster. It’s deciding better, reading sharper, and owning the risk — with a line of agents doing the drafting in between.
Both systems are open source, and both install into an ordinary GitHub repo: ai-light-factory and three-pass-review. If you’re running agents on a codebase people depend on, I’d love to hear where your line stops and you begin.