AI writes 90–95% of our code. 100% of it is produced inside tasks people define, rules people write, and gates people set.
AI'S SHARE OF THE STAGEPEOPLE'S SHARE AND JUDGMENTSTAGE GATEHARNESS · KNOWLEDGE · RSI
OWNER DECIDES
ARCHITECT CHOOSES
OWNER DEFINES DONE
ENGINEER STEPS IN
ENGINEER SETS THE BAR
REVIEWER READS EVIDENCE
OWNER SIGNS, OWNS RISK
STEWARD CURATES
WORTH DOING people
SPEC REVIEW people
TASK CONTRACT automated
BRANCH GUARD automated
CI GREEN automated
AGENT REVIEW agent + people
MERGE AUTH automated + people
KNOWLEDGE PROTOCOL automated
Product writes the requirement↓Design draws it↓Front-end builds screens↓Back-end builds services↓QA regresses by hand↓Ops ships
Five handoffs. A feature waits in every queue. Knowledge lives in people's heads.
→Testers' judgment moved into the gates→Front-end + back-end merged into one owner→Handoff documents became the knowledge base→Assignment became a board people and agents pick from
OWNER one person, one task↓AGENTAGENTAGENT↓8 GATES↓MERGED
One owner, three branches in parallel. Agents execute inside the gates. Knowledge lives in the repo.
OwnerArchitectEngineerReviewerStewardMentor
AI shares are team estimates per stage · Frontier examples: public engineering write-ups, 2026 · Click any stage, gate, the core or a heading for details; click anywhere else to close.
STAGE 01 · AI ≈30% OF THE WORK · PEOPLE ≈70%
Define — decide what is worth doing
PEOPLE
The owner decides what to build and for whom, and kills low-value directions early — with evidence, not opinion. Cheap prototypes make assumptions testable before anyone commits.
AI
Researches the problem space, drafts candidate directions, builds throwaway prototypes.
GATE → WORTH DOING · PEOPLE
Problem framed, user named, success defined, an owner assigned.
FROM THE FRONTIER
Stripe: a two-day AI prototype moved an SDK feature into the next major release — evidence arrived before commitment.
STAGE 02 · AI ≈60% OF THE WORK · PEOPLE ≈40%
Design — choose “enough”
PEOPLE
A senior engineer frames the need as a known pattern, sets the boundaries, and steers the model away from over-engineering for hypothetical concerns. Taste and judgment are the scarce input here — and one good decomposition now drives dozens of agent runs.
AI
Proposes two or more structurally different designs with their trade-offs, drafts the spec, checks it against constraints.
GATE → SPEC REVIEW · PEOPLE
Boundaries, trade-offs and acceptance criteria are challenged before any code exists.
FROM THE FRONTIER
Anthropic’s Scion team: experienced engineers had to steer Claude away from over-engineering parts of the system for hypothetical concerns.
STAGE 03 · AI ≈65% OF THE WORK · PEOPLE ≈35%
Plan — define done
PEOPLE
The owner writes the task contract: goal, context, policy, skills, success metrics, guardrails. Bounded, with dependencies and acceptance criteria that someone can check without reading the chat.
AI
Decomposes the spec into tasks, drafts the contracts, and picks tasks off the board alongside people.
GATE → TASK CONTRACT · AUTOMATED
Goal, context, policy, skills, success metrics and guardrails are all present.
FROM THE FRONTIER
OpenAI’s Symphony: work moved from chat sessions to a task board — bounded, verifiable tasks that agents pick up by dependency.
STAGE 04 · AI ≈98% OF THE WORK · PEOPLE ≈2%
Build — nobody types the code
PEOPLE
People step in only for exceptions: an agent that loops or drifts, a task that is no longer worth finishing. One person runs three branches in parallel. 98% is not an AI number — it is what the preparation makes possible.
AI
Implements end to end from the contract — code, tests, migrations — on its own branch, then opens a draft PR with what changed, how it was verified, and the risks.
GATE → BRANCH GUARD · AUTOMATED
No direct pushes to main; branch names and draft PRs follow protocol.
FROM THE FRONTIER
Stripe’s Minions: 1,300+ merged PRs a week written end to end by agents and reviewed by people (self-reported, February 2026).
STAGE 05 · AI ≈90% OF THE WORK · PEOPLE ≈10%
Verify — set the evidence bar
PEOPLE
The engineer decides what proof is enough for this change — and what no test can prove. The bar rises with the blast radius.
AI
Generates and runs tests, executes CI, records run evidence — screenshots, logs, reports — against the success metrics.
GATE → CI GREEN · AUTOMATED
Tests, lint and security checks pass on the exact commit under review.
FROM THE FRONTIER
Cognition: agents attach screenshots, videos and reports so people verify behavior, not just a diff.
STAGE 06 · AI ≈85% OF THE WORK · PEOPLE ≈15%
Review — read the evidence
PEOPLE
The reviewer asks two things — is this the right problem, and does it fit the system — and makes sure colleagues understand what changed. A green PR is not the same as understanding the product.
AI
An independent reviewer agent, in a fresh context, returns passed or failed for the fixed commit. After three rounds it hands over to a person.
GATE → AGENT REVIEW · AGENT + PEOPLE
An independent reviewer agent, in a fresh context, returns passed or failed for one fixed commit. Three rounds at most, then a person.
FROM THE FRONTIER
Linear: reviewers look at the preview first, then the implementation — review is where the team still thinks together.
STAGE 07 · AI ≈35% OF THE WORK · PEOPLE ≈65%
Release — sign, and hold the risk
PEOPLE
The owner authorizes the merge, watches production and owns the rollback. Releases go out one at a time. Accountability never moved: it is 100% with a person at every stage.
AI
Verifies the merge conditions, ships through the pipeline, diagnoses incidents — but cannot deploy a fix on its own.
GATE → MERGE AUTH · AUTOMATED + PEOPLE
CI green, review passed, nothing changed since — plus a person’s signature.
FROM THE FRONTIER
Intercom: agents may approve small PRs, but the person who ships still watches production and owns the rollback.
STAGE 08 · AI ≈70% OF THE WORK · PEOPLE ≈30%
Learn & teach — make the next task easier
PEOPLE
Someone turns repeated corrections into rules, deletes stale ones, and writes decisions where the next task will find them. And someone grows judgment in new people: “done” is not the same as “learned” — a newcomer must still explain why this design, what changed in the system, and where to look when it breaks.
AI
Updates docs for fact-changing PRs, proposes rules from recurring failures, mines run traces for lessons.
GATE → KNOWLEDGE PROTOCOL · AUTOMATED
A PR that changes a fact updates the documentation in the same PR. Corrections are written back as rules.
FROM THE FRONTIER
Anthropic’s randomized experiment with 52 engineers: AI help got the task done but lowered mastery of a new skill — so we set learning goals next to delivery goals.
STAGE GATE · AFTER DEFINE · PEOPLE
Worth Doing
WHAT IT CHECKS
Problem framed, user named, success defined, an owner assigned.
WHO HOLDS IT
The owner, with product. A human judgment — no tool can make it.
IF IT FAILS
The idea stays a prototype. Nothing enters the loop without all four.
STAGE GATE · AFTER DESIGN · PEOPLE
Spec Review
WHAT IT CHECKS
Boundaries, trade-offs and acceptance criteria are challenged before any code exists.
WHO HOLDS IT
Senior engineers. Review moved left — this is where fixing a mistake is cheapest.
IF IT FAILS
Back to Design. We have paused for days to get this right.
STAGE GATE · AFTER PLAN · AUTOMATED
Task Contract
WHAT IT CHECKS
Goal, context, policy, skills, success metrics and guardrails are all present.
WHO HOLDS IT
The task template. People wrote the template; the template enforces it.
IF IT FAILS
The task does not start.
STAGE GATE · AFTER BUILD · AUTOMATED
Branch Guard
WHAT IT CHECKS
No direct pushes to main; branch names and draft PRs follow protocol.
WHO HOLDS IT
Git hooks in the harness.
IF IT FAILS
The push is rejected.
STAGE GATE · AFTER VERIFY · AUTOMATED
Ci Green
WHAT IT CHECKS
Tests, lint and security checks pass on the exact commit under review.
WHO HOLDS IT
CI. Our CMMI 5 process rules run here as code.
IF IT FAILS
Red means stop. No review until green — not “ask nicely”.
STAGE GATE · AFTER REVIEW · AGENT + PEOPLE
Agent Review
WHAT IT CHECKS
An independent reviewer agent, in a fresh context, returns passed or failed for one fixed commit. Three rounds at most, then a person.
WHO HOLDS IT
The review agent, then the human reviewer. An agent’s approval never counts as a person’s.
IF IT FAILS
Back to Build. Change the patch and review starts over.
STAGE GATE · AFTER RELEASE · AUTOMATED + PEOPLE
Merge Auth
WHAT IT CHECKS
CI green, review passed, nothing changed since — plus a person’s signature.
WHO HOLDS IT
Branch protection, and the owner who signs.
IF IT FAILS
Any one missing: the merge is blocked.
STAGE GATE · AFTER LEARN & TEACH · AUTOMATED
Knowledge Protocol
WHAT IT CHECKS
A PR that changes a fact updates the documentation in the same PR. Corrections are written back as rules.
WHO HOLDS IT
The PR template, and whoever stewards the knowledge base.
IF IT FAILS
It does not merge.
THE HARNESS · WHAT EVERY TASK PICKS UP
Goal
PREPARED BY PEOPLE, READ BY AGENTS
What this task must achieve, in one sentence the owner can verify.
THE HARNESS · WHAT EVERY TASK PICKS UP
Context
PREPARED BY PEOPLE, READ BY AGENTS
The facts an agent needs — relevant docs, past decisions, examples — served from the knowledge base, not re-explained in chat.
THE HARNESS · WHAT EVERY TASK PICKS UP
Policy
PREPARED BY PEOPLE, READ BY AGENTS
The rules that always apply: coding standards, security, what agents may not touch.
THE HARNESS · WHAT EVERY TASK PICKS UP
Skills
PREPARED BY PEOPLE, READ BY AGENTS
Reusable procedures — how we run migrations, write tests, deploy — maintained by the team and shared across projects.
THE HARNESS · WHAT EVERY TASK PICKS UP
Metrics
PREPARED BY PEOPLE, READ BY AGENTS
Success metrics: what evidence counts as done. Written before the work starts, so acceptance is a check, not a debate.
THE HARNESS · WHAT EVERY TASK PICKS UP
Guardrails
PREPARED BY PEOPLE, READ BY AGENTS
Hard limits: no direct push to main, no secrets, budgets, stop conditions. The reins that let the whip be used.
THE CORE · AI ENGINEERING HARNESS
The team’s experience lives here — not in people’s heads.
EVERY TASK PICKS UP
Goal · Context · Policy · Skills · Success Metrics · Guardrails — prepared by people, read by agents. This is what makes 98% possible at Build.
KNOWLEDGE BASE
Project memory — decisions, rules and lessons in cards, PRs and docs. Organization memory — a shared knowledge base, components and stack that every project reuses. One project’s lesson is the next project’s starting point.
RSI · RECURSIVE SELF-IMPROVEMENT
Corrections become rules; rules are deleted when models outgrow them; the next task starts from a better place. Because the experience lives in the repo, the loop can be copied by another team.
FROM THE FRONTIER
Stripe’s Kai: a platform runs the agents, domain teams own the skills that define “done right”. Tessl: the rules live in a repo anyone can read and change.
THEN · HOW SOFTWARE GOT BUILT
A relay: six jobs, five handoffs.
Product wrote the requirement, design drew it, front-end and back-end built it, QA regressed it by hand, ops shipped it. Each handoff was a queue, and each queue was where a feature waited.
WHAT HELD IT TOGETHER
People. Handoff documents, meetings, and the memory of whoever had been there longest. When they left, the knowledge left with them.
THE BOTTLENECK
Writing the code — so the whole organization was shaped around getting more of it written.
NOW · THE NEW UNIT OF WORK
One task, one owner, several agents.
THE OWNER
A full-stack engineer who carries one task from intent to merge: defines done, prepares the contract, lets agents run, reads the evidence, signs. Typically three branches in parallel.
THE AGENTS
Execute inside the contract — code, tests, draft PRs, independent review — on their own branches. Running more of them is not the goal; the owner’s attention is the scarce resource.
THE GATES
Eight checkpoints, two held by people and six by the harness, so speed cannot turn into an accident.
WHAT CHANGED IN THE ORG
We have almost no pure front-end or test roles left. Not because they were cut: the testers’ judgment moved into the gates, and the front-end/back-end split moved into the task. People stopped being defined by a job and started being defined by what they own.
PEOPLE · WHO HOLDS WHAT
Six hats, not six job titles.
Owner — decides what is worth doing, defines done, signs and holds the risk. Architect — frames the problem, chooses “enough”, reviews specs; the judgment that gets multiplied. Engineer — steps in on exceptions, sets the evidence bar. Reviewer — reads the evidence; keeps the team’s shared understanding of the system. Steward — curates the harness and the knowledge base: rules, skills, evaluations, stale-rule removal. Mentor — grows judgment in new people; separates “done” from “learned”.
HOW THEY ARE WORN
One person wears several in a day; in a small team the same senior is architect, reviewer and mentor. As the organization grows, a hat can become a team. The hats make responsibility explicit without turning people back into job titles.
WHERE WE ARE · EVIDENCE FROM OUR OWN REPO
This loop runs in our team today.
90–95%of our code is AI-written; at Build, with the contract prepared, ≈98%
50 / 50PRs merged last week, every one with an independent agent-review verdict
34 → 33PRs failed first review; 33 of them passed after revision — the gates work
1,418comments and reviews in which nobody had to ask “what changed, what was tested”
INDUSTRY REFERENCE
Anthropic: 80%+ of merged code written by Claude · Uber: 70%+ of PRs attributed to agents · Airbnb: near 60%. Definitions differ; not directly comparable. A study of 802 developers and 196K PRs: AI-written PRs merge at the same rate as human ones, with slightly fewer rollbacks.
Repo figures from our engineering training material (2026-10) — verify before presenting.
HOW IT STAYS SAFE AT SPEED
The whip and the reins.
THE WHIP
Goal, context, policy, skills, success metrics and guardrails prepared up front — so the agents can run at full speed without asking. 98% at Build is the result of this preparation, not a property of the model.
THE REINS
Eight stage gates. The first two are human reviews moved left — worth doing, spec review — where a mistake is cheapest to fix. The other six run as code: hooks, CI, a reviewer agent in a fresh context, branch protection, the knowledge protocol. Our CMMI 5 process rules did not go away; they became automated.
THE PRINCIPLE
We do not bet on AI never being wrong. We build a track where being wrong cannot become an accident.
WHAT’S NEXT
People move to the two ends — and to the middle.
MORE AUTOMATION
Review and knowledge updates keep automating: repeated fixes become lint rules, a PR’s dozen human touches collapse into three decisions.
WHERE PEOPLE GO
The front end of the loop — deciding what is worth doing and what “done” means. The back end — signing for outcomes and holding the risk. And the middle — curating the knowledge base and growing judgment in new people, the two jobs that used to count as chores and now shape every future run.
THE ASK
Not more headcount for typing code. Investment in the harness, time protected for learning and knowledge curation, and managers who run attention — deciding what to start, what to stop, and who is learning. Off the saddle, not out of the race.
