100% Agent-Written: Six Months on a Greenfield Rebuild

---

Since March, my team has been building Solstice, a greenfield platform started from a blank page. In four months we wrote less code than we rewrote the way we produce it: a brief per service, agents that each hold their own lane, a verification gate that returns its verdict before a human reads the diff. That method is what I came to write down — how we put it in place, and what it produced.

Six months ago, I was making predictions from inside that team, with almost nothing external to back them. Now the studies are out, and they back the calls.

The staircase of six months

The paradigm didn't land in one jump. It climbed step by step: a new frontier model every few weeks, each a little more autonomous than the last. And underneath, the sales pitch shifted from raw capability to reliability.

Left to right, the honest chronology of the half-year:

• January. METR updates its Time Horizon research: the length of task an agent finishes one time out of two now doubles roughly every four months, against seven before. Forget the exact hour count — it's the shape that matters, and the shape points up, fast.
• February. Opus 4.6 ships on the 5th. Three weeks later, OpenAI stops publishing SWE-bench Verified scores: the benchmark "no longer measures frontier coding capabilities", and on audit most of a sample of failed tasks had broken tests. The benchmark everyone quoted just got buried by one of the people quoting it.
• April. Two releases in one week: Opus 4.7 on the 16th, GPT-5.5 on the 23rd — six weeks after GPT-5.4, and OpenAI says so proudly. And Opus 4.7's sales pitch isn't power. It's rigor: the model designs its own verification steps before declaring a task done. Self-checking has become a feature you pay for.
• May. Opus 4.8 on the 28th. Anthropic claims it lets four times fewer flaws slip through its own generated code than 4.7 — a vendor number, sure, but the choice of number says everything: nobody sells generation anymore, they sell control. Alongside it, Claude Code's "dynamic workflows": a replayable script that spreads work across up to a thousand agents per run, about sixteen at a time, without flooding the model's context. My persona-panel method, basically, turned into a product. Same month, the MCP protocol goes stateless — a fleet of agents is now a load-balancer problem, not a demo.
• June. Fable 5 on the 9th, Sonnet 5 on the 30th — the cadence is not slowing down. Meanwhile, the code-review side finally gets its numbers. I'm coming to those.
• July. GPT-5.6 on the 9th, and the biggest real-company study of the half-year: a handsome throughput figure, with a warning label glued to it. Then, on the 16th — a day after I froze these counters — Moonshot ships Kimi K3: 2.8 trillion parameters, a million-token context window, open weights, and a Swarm Max variant built expressly to run agents in parallel. On its own benchmarks it sits level with the proprietary frontier; take the scores with the usual salt, but the direction is the story — frontier capability is going open-weight, and it's being shaped for fleets.

So much for the steps. Now look at the dashed line under the staircase — the gain actually measured on the kind of code most of us maintain. It barely moves. This entire article lives in the distance between the two.

The field: Solstice, four months on the clock

This series has been quoting "my team" for six months without ever opening the books. Let's fix that too. Since March, my day job has a codename: Solstice* — a greenfield platform, first commit on March 10, that merges two long-lived healthcare product suites into a single new TypeScript codebase. Four months later: some thirty backend microservices, a handful of micro-frontends, around 600,000 lines across roughly 5,000 files. Greenfield with a caveat worth naming — the code is new, the domain is not. Regulated healthcare, patient data, and two legacy suites' worth of implicit contracts to honor.

The project's origin story is worth telling, because it is the half-year's best example of the equation changing. Patient administration and the patient journey ran on two historical foundations — one in a proprietary fourth-generation language from the nineties, the other in a desktop-era stack: technologies where every regulatory change fights the code, and where hiring has become a lost battle. The refactor-versus-rewrite dilemma had been sitting on the table for years, and it always tipped the same way: a rewrite was too expensive, too risky, a double run to fund. Agentic AI flipped the arbitrage in early 2026 — velocity multiplied, a screen prototyped in hours instead of weeks and validated with the domain experts before a line of production code, compliance codified into blocking CI guardrails: patient-identity vigilance, accessibility, auditability. The cost and the risk of the rewrite collapsed together. Solstice is not a project that uses agents. It is a project that would not exist without them.

The chosen foundation says the same thing: React micro-frontends behind a design system, Fastify/TypeScript microservices, PostgreSQL everywhere, FHIR R4 as the pivot data model, Docker, OpenTelemetry, GitHub Actions CI/CD. Nothing exotic — deliberately. A stack the models know by heart is a stack the agents run on at full speed.

"Choosing a technology is now a hiring decision for your agents as much as for your humans."

Here are the counters, frozen on July 15:

• ~4,500 commits in four months — about 35 a day. Close to 1,000 pull requests, 120-plus tagged releases, over 500 deployments. The May peak — nearly 1,800 commits — is not an anomaly; it's the month the frontend rewrite ran as a pipeline.
• A full rewrite, executed mid-flight. One architecture decision record decided the frontend would leave Vue for React. Four months later: over 300 .tsx files, zero .vue left. That kind of migration used to be a year-long project with its own steering committee. Here it was an agent sweep across hundreds of files, fenced in by tests, merged by humans.
• The autonomy infrastructure. Some fifty architecture decision records, forty-odd CLAUDE.md briefs — one per service and micro-frontend — close to forty skills, some 250 docs. Nearly one line of Markdown for every five lines of code. That's the context we inject into agents so they can work a lane without us. We stopped documenting for humans only. We document for fleets.
• The tax, made executable. Over 600 test files, a couple dozen end-to-end specs on the critical journeys, and a verification gate that returns a PASS/FAIL verdict before any PR exists. The verification tax this series keeps naming is no longer a blog-post concept — it's a binary in the CI.

And the fact that matters most, stated without hedging: one hundred percent of this code is agent-written. Not "assisted", not "autocompleted" — written. No human on this project types production code anymore — a claim the workflow enforces rather than takes on trust: every change enters the repository as an agent-opened pull request. The commit signatures still carry human names, because a signature no longer says who wrote the change; it says who specified it, who orchestrated the fleet, and who verified the result.

"In 2026, a commit signature is a chain of accountability, not a byline."

Diagnosis versus arithmetic, as always: these are throughput numbers, not value — the metric Microsoft warns gets inflated — and they are greenfield numbers, the terrain where Stanford's research already grants agents their 30 to 40%. I claim velocity on a young codebase, nothing more. The interesting part isn't the raw count. It's what it took to get there.

Four months to redefine how we work

Because none of that velocity came from a model getting smarter on its own. A team of twenty-odd people doesn't get there by buying licenses. We rewrote the method piece by piece, while shipping. Here is what actually changed for us between March and July.

Need first, prototype in hours. The old method specified for weeks before anyone coded. The new one inverts it: field immersion, journeys co-designed with the domain experts, then a working prototype produced in hours by the agents — and put in front of users before anything gets industrialized. We no longer argue over mockups. We decide on something clickable.

Everything decided gets written down, because everything written becomes context. Some fifty architecture decision records in four months, a brief per service, a domain glossary, close to forty skills for the repeated gestures. Documentation changed nature: it is no longer a deliverable that ages, it is fuel for the fleets. A poorly written decision is a fleet coding beside the point. Nearly one line of Markdown for five lines of code — the best investment of the project.

The machine says no before a human reads. The verification gate returns PASS or FAIL before any PR exists; human review only starts once the machine has said yes. And the architecture itself serves the method: microservices and micro-frontends are bounded lanes an agent can hold alone, without stepping on anyone else's work.

The tooling maintains itself. Self-healing CI, E2E specs generated and then kept alive on the critical journeys, briefs updated by the very agents that consume them. Tooling time used to be a tax. It became compound interest.

And the human ritual that carries it all: practice-sharing. Nearly every week, the team sits down to share what it has learned about working with agents — about fifteen written reports in four months. What works becomes a skill. What binds the architecture becomes a decision record. It is the fastest learning loop I have seen in my career, and it owes nothing to the models.

And the velocity has a deadline attached, not just a counter: a first preadmission MVP deployed in October 2026, the full workflow early 2027, complete coverage of the legacy scope in 2028. Two years to replace two historical foundations. Before agents, nobody would have signed that plan — which is exactly why the rewrite had never been launched.

The scorecard

Four calls, six months of data. Here's the graded homework.

The call (Mar–May)	Grade	Why
The SDLC is dead	Holds, amended	The ceremony died; a verification gate was born. Process didn't shrink — its center of gravity moved from writing to reviewing.
AI is an amplifier	Confirmed	Throughput up top, quality costs compounding below. MIT found 95% of GenAI pilots delivered no measurable P&L impact — a contested figure; keep the direction, not the digit. The tool amplifies the system around it — exactly the claim, and the reading my DORA piece laid out.
There is a verification tax	Confirmed, quantified	Review time and queue latency up sharply (Faros, LinearB); full delegation still the exception — 0–20% of tasks depending on the study; self-checking now literally sold as a model feature.
The coder becomes an engineer	Confirmed	The frontier work of the half-year is orchestration — writing the harness, wiring the tools, grading the agents. Not typing syntax.

The ceiling nobody sells you

If the climb is taking its time, it's not because the models lack intelligence. It's arithmetic. An agent that is 95% reliable at each step finishes a 20-step task a little better than one time in three. A 50-step task? Seven times in a hundred. Errors multiply into each other, long-horizon autonomy collapses far below the demo reel, and the only thing standing between that collapse and your production branch is called verification. The "context rot" research shows the same thing on the memory side: past a few hundred thousand tokens, the models degrade quietly.

And then a cost showed up that none of my March bets had named: security. Prompt injection is now discussed as a permanent property of agents, not a bug awaiting a patch. Severe CVEs hit the exact tools we use every day. Anthropic even disclosed that a state-linked group had hijacked Claude Code instances to run near-autonomous espionage. The SDLC's ceremony is dead, all right — what's being born in its place is a discipline: provenance, sandboxing, agent verification. That's not a rebuttal of the series. It's the gate the old process should have been all along.

What we hand the agents in July

The practical question everyone asks me: concretely, what does an agent do alone in July 2026 that it couldn't in January? Answer from inside Solstice, lane by lane.

In January, an agent completed a function and wrote a test if you asked politely. An agent PR was a demo you showed around, not a flow you lived with.

In April and May, with self-checking and then sub-agent fleets, the unit of delegation grew from the function to the sweep: our React rewrite ran that way — a pipeline of agents over hundreds of files, each batch fenced by the existing tests, a human at the merge. May's ~1,800 commits are that unit of work, made visible.

In July, here is what leaves on its own, on our repository, without a human writing a line:

1. The bounded-scope PR, end to end. Ticket → branch → code → tests → verification verdict → PR opened. The human only shows up at review. The non-negotiable condition: the lane has its CLAUDE.md, its skills, and the gate says PASS.
2. CI that heals itself. Container-name collisions, drifting deploy stacks: the agents now fix their own plumbing. Unthinkable in January — nobody would have let an agent near the pipeline.
3. End-to-end specs on the critical journeys. Front-to-back, generated and then maintained. A couple dozen today — and probably many more within weeks or months.
4. The documentation the code follows. It's the reverse, really: the docs come first. They come out of the workshops and the domain experts — captured from the transcripts, then turned into briefs, ADRs, a per-service CLAUDE.md — and that is what frames the code the agents write next. Documentation stopped being a trace left behind; it's the source everything starts from.

And what still does not leave alone, even in July: architecture — the fifty-odd ADRs are human decisions, above all the ones that fence what agents may touch. Masking the patient identifier on our screens went through an ADR envelope before a single agent-written line came near it. The bar the merge must clear, always — the click behind it is already automating. And the scoping itself: a human draws the lanes; an agent never grants itself one.

"Autonomy is not declared at the model. It is equipped, lane by lane — a brief, a set of skills, a gate that can say no."

That's my read of the half-year from ground level: each step of the staircase doesn't make the agent smarter so much as it widens what we dare hand it. A function in January, a sweep in May, a flow in July — the speed at which that unit widens is the real measure of autonomy. Not the benchmarks.

The ladder someone finally numbered

Halfway through writing this, Boris Cherny — who built Claude Code — published a ladder that puts numbers on the thing I keep calling "the widening unit of delegation". Five rungs, counted in agents per engineer: gated (0), assisted (one agent, a supervised pair), parallel (about ten, an orchestrator hopping between worktrees), supervised autonomy (about a hundred, a manager of managers), AI-native (a thousand-plus, steering by intent alone). It's the cleanest map I've read of the climb — and, being a vendor's, every rung comes with a product bolted to it. Keep the ladder. Ignore the catalogue.

Because the part worth keeping is the thesis, and it's the one this series has circled for six months: tokens don't move you up. In Cherny's own words, reaching the next rung means you "find and break down the next set of bottlenecks, and build up the next set of guardrails". That's the verification tax rewritten as a career ladder — every rung bought with a guardrail, not a bigger budget. He even hands over the value test I keep groping for: a usage dashboard measures activity, not return; the honest question is whether you'd have spent the engineering hours anyway, and what they would have cost in manual eng-hours. That's a ruler I can finally hold up to Solstice.

So I'll answer his closing question — where's your team? Rung two, honestly: the orchestrator, five to ten agents at once, each on its own lane, a human reviewing final diffs instead of keystrokes. On the bounded lanes where the verification gate has earned trust, we lean into rung three — work that kicks itself off, maintenance that used to wait for a free afternoon now running in the background, which is exactly where Cherny says the real payoff starts: the team stops firefighting and builds things that weren't in range before. We are nowhere near the thousand-agent top rung, and I distrust anyone who says they are; that's where the ladder stops being a maturity model and turns into a roadmap slide.

The line from his piece I'd underline is the humblest one: "there's no one right path through the steps". The trap he names — scaling agent count before the loop has earned trust — is the precise failure this series keeps warning about, now written from the vendor's side of the table. Same gate, same tax; we just approach it from opposite ends.

What still belongs to humans

As in every piece in this series, the honest list. Six months of progress took none of this off our plates.

Deciding what "safe to merge" means. That's the tax, and it didn't get cheaper — it got bigger, and it moved to the front of the pipeline. On our repository, the verification gate now says "no" before a human even reads the diff. The merge click itself is the next thing to go: as the automated controls and guardrails pile up, PRs will soon merge on their own once the gate is green. What stays human isn't the click — it's setting the bar the gate enforces. That judgment is the job now.

Keeping the people. Klarna — the fintech that had loudly swapped much of its support staff for AI — spent the year quietly rebuilding the human capacity it cut, after quality dropped. The financial argument hasn't changed: the value moved toward the humans who can specify, orchestrate and verify fleets of agents. Fire them and you delete your own return, right where the tax bites hardest. On my team, over these six months, headcount grew again. Nobody was replaced by a machine.

What to do Monday morning

If you lead a team and want something concrete out of this checkpoint:

1. Budget the review gate, not just the licenses. If your agents ship more PRs, someone reviews more PRs. Staff and measure that capacity before you scale generation, or the queue becomes your real bottleneck.
2. Document for the agents, not just the humans. A brief per service, a skill per repeated gesture, a glossary for the domain. Least glamorous investment of the half-year, best return: on our repository that's nearly one line of Markdown for five lines of code — and it is what makes delegation possible at all.
3. Measure your own net gain on real tickets. Not greenfield demos — the legacy work you actually maintain, net of rework and review. That number is yours, and it's the only one that doesn't belong to a vendor.
4. Keep batches small. The compounding-error math is unforgiving: short agent runs with human checkpoints beat one heroic 50-step delegation, every time. Design for verification, not for autonomy theater.
5. Treat agent security as production security. Prompt injection, tool permissions, provenance. If an agent can run a command, assume a hostile input can too. Sandbox accordingly.
6. Retire your dead benchmarks. If OpenAI dropped SWE-bench Verified, your internal "the model scores X" slide is probably stale too. Trust the trend and your own repository — nothing on a leaderboard.

Where this leaves the series

Six months ago I was predicting from inside one team. Today the models check their own work, the fleets are infrastructure, and my own repository shows what four months of development can do on a young codebase when the method keeps up. All four of my calls came out stronger. The agents gained a longer horizon, not a shorter leash. The reach is real. Reliability at that reach is being built — release by release on the vendors' side, gate by gate on ours — and for now, that work is ours.

The next checkpoint writes itself: the day the unit of delegation widens again — from the flow to something I hesitate to name yet — I'll reopen this report card. Until then: build the rails, keep the gate, and count your own numbers.

Read the rest of the series: The SDLC Is Dead — why the process was always waste. Coding Was Never the Job — what the engineer becomes when the syntax disappears. AI Became a Team Reflex — what an AI-native team looks like on a Tuesday. DORA Just Confirmed What My Team Already Lived — the report that put external data behind what we were already living. One More Prompt — the personal bill this professional verdict comes with. The Backlog Was Never the Job — what this shift does to the product role. Doctrine Compounds. Models Don't. — why swapping eight models in these six months cost nothing. The Tests Passed. Nothing Happened. — the defect that has no symptom, and what catches it instead of reading.

---

Sources

• METR — Measuring AI Ability to Complete Long Tasks (Time Horizon 1.1): the ~4-month doubling of the 50%-reliability task horizon.
• METR — Impact of Early-2025 AI on Experienced Open-Source Developer Productivity: the randomized trial that measured a 19% slowdown alongside a 20% felt speedup.
• OpenAI — Why we no longer evaluate SWE-bench Verified: the benchmark retirement, contamination and broken tests.
• Stanford — Software Engineering Productivity research (Denisov-Blanch): the greenfield-vs-brownfield gradient, cited by DORA.
• DORA — The ROI of AI-assisted Software Development (2026): the amplifier framing, the instability tax, the ≤10% brownfield figure.
• Faros AI — The Acceleration Whiplash (2026): the delivery-telemetry deltas (review time, incidents, bugs) — not DORA's numbers.
• LinearB — 2026 Software Engineering Benchmarks: AI-PR acceptance 32.7% vs 84.4%, and the 5.3× agentic-PR queue latency.
• Murphy-Hill et al. — Adoption and Impact of Command-Line AI Coding Agents (Microsoft, 2026): the ~24% more merged PRs, and the "a merged PR is not the value" caveat.
• Model Context Protocol — 2026 release: the stateless core that turned agent fleets into infrastructure.
• Claude Code — Dynamic Workflows: deterministic fan-out across up to 1,000 agents per run (~16 concurrent).
• Boris Cherny — Steps of AI Adoption (July 16, 2026): the five-rung ladder — gated, assisted, parallel, supervised autonomy, AI-native — counted in agents per engineer (~1 to ~1,000+), and the thesis that you climb by breaking the next bottleneck and building the next guardrail, not by spending tokens. A vendor's framing, product catalogue attached — keep the ladder, discount the SKUs.
• Solstice* — internal repository telemetry (commits, PRs, deployments, tests, ADRs), snapshot of July 15, 2026, and the internal product rationale (rewrite arbitration, 2026→2028 roadmap). No links: it's a private codebase, and "Solstice" is a fictitious codename — the real project, its products and its legacy technologies are anonymized. Throughput numbers, not value — read them with the same skepticism as any vendor's.