The State of Agentic Engineering, August 2026

Agentic engineering is the discipline of directing fallible coding agents while keeping correctness, security and taste, and the August 2026 evidence says the agent-written share of code keeps rising: over 80% of merged code at Anthropic, 42% of committed code AI-generated or assisted in Sonar’s survey of over 1,100 developers, a 51.9% average across DX’s Q2 panel. The open question is which autonomy level a team operates at.

A CTO asks what share of the codebase agents write. The lead says 40%. The developer running the agents knows half of those lines are tests it wrote for its own change. Three people, three rungs of one ladder, and nobody can name it.

What you’ll walk away with from the August 2026 evidence

• A sourced evidence table: every number with publisher, date and unit
• Shapiro’s six-rung ladder, plus a five-step self-placement test
• The six factory stations, one documented feature each in Claude Code, Codex, Cursor
• The counter-evidence at full strength: METR, Faros, DORA, SlopCodeBench
• Three prompts: audit a level, design a stop condition, write a contract

Why 100% of code will be written by agents

The trajectory is the argument, and no single figure settles it.

Measure	Then	Now	Source
Anthropic merged lines from Claude	“low single digits”, Feb 2025	“more than 80%”	Anthropic, “as of May 2026”
AI-authored share, 400+ companies	27.4%, Q1 2026	51.9% average	DX, 17 Jun 2026
Code committed, reported AI-generated or assisted	not measured	42%	Sonar, 8 Jan 2026
Stripe PRs/week, no human-written code	“over a thousand”	“over 1,300”	Stripe, 19 Feb 2026
Anthropic code merged per engineer, per day	2024 baseline	8x	Anthropic, Q2 2026

At the individual end it reaches 100% and stays. Boris Cherny told Fortune on 29 January 2026: “For me personally, it has been 100% for two+ months now, I don’t even make small edits by hand.” OpenAI’s “Roon”, same piece: “100%, I don’t write code anymore.”

Dario Amodei predicted this at the Council on Foreign Relations on 10 March 2025: AI writing “90 percent of the code” within three to six months, “essentially all of the code” within twelve. Score it honestly. Eighteen months on it holds inside Anthropic, whose spokesperson gave Fortune a range of “between 70% and 90%”, and fails for the industry, whose best series is DX’s 51.9%. Fast Company reports Sundar Pichai putting Google’s new code at 75% in April 2026, but no Google primary states it, so that is press reporting.

What the “percentage of code” numbers actually measure

Every one of those percentages counts lines, and lines are the cheapest thing an agent makes. Ryan Greenblatt of Redwood Research put the objection precisely on 22 October 2025: “The productivity boost at a given fraction of code generated isn’t that high because AI allows people to cheaply generate lots of very low value code.”

Anthropic draws the same line: leadership have estimated 90% or more “including scripts and experimental code”, while the published figure measures “the share of lines merged to production that can be attributed to Claude.” Two scopes, one headline.

Volume carries the same warning. DX found median pull request size “growing from 44 lines to 72 lines per pull request between July 2025 and June 2026”. A rising AI share and a near-doubled diff are one event described twice, and the second names who pays.

What is agentic engineering?

Andrej Karpathy named the discipline in his Sequoia Ascent summary of 30 April 2026:

“I call it agentic engineering because it is an engineering discipline. You have agents, which are spiky entities. They are fallible and stochastic, but extremely powerful. How do you coordinate them to go faster without sacrificing your quality bar?

Vibe coding raises the floor. Agentic engineering is about extrapolating the ceiling.”

He is explicit about the constraint: “You are not allowed to introduce vulnerabilities because of vibe coding. You are still responsible for your software, just as before.” Vibe coding raises the floor for everyone; agentic engineering is what happens to the quality bar when the people who can build software stop typing. The definition opening this page compresses that passage; it is not a quotation.

He names what changed underneath: “The unit of programming changed from typing lines of code to delegating larger ‘macro actions’.” His view of the agents is unflattering: “Right now the agents are like interns. You still have to be in charge of aesthetics, judgment, taste, and oversight.” A line he quotes approvingly, without naming its author, states the cost: “You can outsource your thinking, but you can’t outsource your understanding.”

Which level of the autonomy ladder is your workflow at?

Dan Shapiro published the model on 23 January 2026 as “The Five Levels: from Spicy Autocomplete to the Dark Factory”, after the NHTSA automation scale. It is zero-indexed, so six rungs sit under a title saying five; Simon Willison’s 28 January write-up identifies the Level 5 team as StrongDM’s AI division.

Level	Shapiro’s name	Writes	Reads	What it feels like
L0	Spicy autocomplete	Human	Human	“not a character hits the disk without your approval”
L1	The coding intern	Human	Human	“you offload specific, discrete tasks to your AI intern”
L2	The junior developer	Both	Human	“feels like you are done. But you are not done”
L3	The developer	AI	Reviewer	“Your life is diffs.”
L4	The engineering team	AI	Tests	“leave for 12 hours, and check to see if the tests pass”
L5	The dark software factory	AI	Nobody	“It’s a black box that turns specs into software.”

Guides by rung. L1 and L2: quick starts for Claude Code, Codex, Cursor. L3: agent fleets, agent view. L4: goal, loop, hooks. L5: software factories.

Shapiro calls Level 2 “where 90% of ‘AI-native’ developers are living right now”, says “almost everyone tops out here” of Level 3, places himself at Level 4, and puts “a handful of people” at Level 5, where “humans are neither needed nor welcome.”

Run it against the repository, not your impression. The first step you cannot answer with evidence is the ceiling.

1. L0 to L1. Does code reach disk that you did not type?
2. L1 to L2. Do you hand over whole tasks with acceptance criteria, or only completions inside a function you are writing?
3. L2 to L3. Does the agent run unattended long enough that you meet its work as a diff? That is a job change, not a speed change.
4. L3 to L4. Is there a stop condition a machine can evaluate, as commands that exit 0? Level 4 is defined by leaving.
5. L4 to L5. Does anything merge that no human read, and can you name the oracle that made it safe?

What does a Level 5 software factory look like in production?

Stripe’s is the most detailed published account. Its Minions are one-shot, end-to-end agents built on “a fork of Block’s coding agent goose”, drawing on a Toolshed of “nearly 500 MCP tools”, and by 19 February 2026 “over 1,300 Stripe pull requests… merged each week are completely minion-produced, human-reviewed, but containing no human-written code.” Three decisions are worth copying before the vocabulary:

• The loop has a hard bound. Stripe allows “at most two rounds of CI”, then “we send the branch back to its human operator for manual scrutiny.”
• The workflow is code. “Blueprints are workflows defined in code that direct a minion run,” ending as “a state machine that intermixes deterministic code nodes and free-flowing agent nodes.”
• The oracle predates the agents. The minions run against “Stripe’s enormous preexisting battery of tests — over three million of them.”

Microsoft’s rollout study is the population-scale measure. Murphy-Hill, Butler and Savelieva studied its early-2026 rollout of Claude Code and GitHub Copilot CLI across “tens of thousands of engineers”, where adopters “merged roughly 24% more pull requests than they would have otherwise”, with the caveat: “a merged PR is not the same as the value it delivers.”

Yegge’s Gas Town names the roles once agents multiply: “Cook a formula, sling it to a polecat, the witness watches, refinery merges.” DoltHub’s Tim Sehn measured a day: “This whole sixty minute experience cost me about $100 in Claude tokens.” A week cost $3,000.

BCG Platinion’s March 2026 framework sorts it into five pillars: intent-driven operating model, codified knowledge, workforce upskilling, architecting the factory, governance. Take the structure, leave its multipliers: no population, no method. Its durable sentence: “The defining shift is not the absence of humans; it is the relocation of human effort.” Alexander Opalic, from a developer’s chair: “developers stop writing code by hand… while developers design and improve the factory.”

The six stations of a software factory

Alexey Grigorev’s July 2026 taxonomy names four stages alongside prompt engineering: context engineering (what the agent knows before it starts), loop engineering (when it stops working) and graph engineering (who does what once there is more than one agent). Add what may run and what ships, and there are six stations; every cell below was fetched from the vendor’s documentation on 28 August 2026.

Station	Decides	Claude Code	Codex	Cursor
Intent	What it knows first	CLAUDE.md	AGENTS.md	Rules
Harness	What runs per edit	Hooks	Hooks	Hooks
Loop	When it stops	/goal	/goal	/goal
Graph	Who does what	Subagents	Subagents	Subagents
Verification	What proves it	/code-review	/review	Bugbot
Release	How it ships	Actions	Codex Action	Actions

Three details separate the columns. Claude Code caps concurrent subagents at 20 per session by default. Cursor shipped /goal on 19 August 2026 and, the same day, subagents running on their own virtual machines with “an isolated copy of the project with clean context”. /loop is a built-in skill in Claude Code and, since Cursor 3.5 on 20 May 2026, a bundled skill in Cursor as well: “With /loop, Cursor can run a prompt repeatedly on a local schedule, until a certain outcome is achieved, or until you stop it.” Codex has no /loop and covers cadence with /goal and Automations.

Verification decides whether the rest is safe, as Naresh B A writes on dev.to: “A model can argue that its work is complete. A deterministic validator can prove that a required field is missing.” Peter Steinberger, quoted by Grigorev: “You shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.” A station-by-station matrix with every documented feature per tool is the Level 5 page of the ladder, published next; the ladder hub links what is live so far.

What does the evidence against autonomy say?

METR has never measured a speedup. Its 2025 randomised trial of 16 experienced open-source developers across 246 issues found “the use of AI causes tasks to take 19% longer, with a confidence interval between +2% and +39%”, while those developers still believed afterwards they had been sped up by 20%. The February 2026 update estimates “a speedup of -18% with a confidence interval between -38% and +9%” for the original cohort and “-4%, with a confidence interval between -15% and +9%” for new recruits. Both cross zero, and METR disowns the instrument: the new data “gives us an unreliable signal of the current productivity effect of AI tools.” No positive point estimate exists in either post; citing METR for a speedup inverts the sign.

Faros measured the whiplash. Two years of telemetry, 22,000 developers, 4,000+ teams, April 2026. Throughput rose: epics/developer +66.2%, tasks +33.7%, merge rate +16.2%. Quality fell in the same window: bugs per developer +54%, incidents per pull request +242.7%, churn +861%, pull requests merging unreviewed +31.3%. Two review metrics move separately and must be named separately: median time in review rose 441.5%, time to first review 156.6%.

DORA named the mechanism earlier. Its 2025 report found “a positive relationship between AI adoption on both software delivery throughput and product performance” and also that “AI adoption does continue to have a negative relationship with software delivery stability.” The explanation: “Without robust control systems, like strong automated testing, mature version control practices, and fast feedback loops, an increase in change volume leads to instability.”

SlopCodeBench measured the decay. Across 36 problems, 196 checkpoints and 15 agents extending their prior solutions, “no agent fully solves any problem end-to-end, and the best agent passes 14.8% of checkpoints”. Dex Horthy’s AI Engineer World’s Fair talk, “Harness Engineering is not Enough: Why Software Factories Fail”, argues the matching case; both are covered in software factories.

How the ladder answers the counter-evidence

None of that argues for staying at Level 2; it argues for how a team climbs. Autonomy is earned per loop against a verification oracle, never declared for a codebase, and METR measured unbounded delegation with no oracle in the loop. Faros measured generation scaling while verification did not, which is the Level 3 ceiling in telemetry: review bandwidth, not model capability, stops most teams. Climbing means adding a proof, not removing a reader. Stripe is the fair test: it scaled on three million tests, and kept a human at the end of round two.

What stays human in agentic engineering?

Six responsibilities survive every rung below the dark factory.

1. Taste. Karpathy: “you are in charge of taste, engineering, design, and whether the system makes sense.”
2. Architecture. “You still have to understand the fundamentals,” because “you cannot be a good director if you do not understand.” DORA: “Teams working in loosely coupled architectures with fast feedback loops see gains.”
3. Product direction. Karpathy: “I am becoming the bottleneck of even knowing what we are trying to build, why it is worth doing, and how to direct my agents.” Shapiro’s Level 4 human writes the spec.
4. Eval and stop-condition design. Shapiro: “leave for 12 hours, and check to see if the tests pass”. Stripe: two CI rounds against three million tests, then a human.
5. Permissions. What an agent may run unsupervised is a design decision. Codex documents an approval policy for “when Codex must ask you before it executes an action”; Claude Code gates auto mode behind a classifier.
6. The call not to automate. Linear: “an agent cannot be held accountable”, so “issues can only be assigned to humans, and only delegated to agents.”

The list describes Level 4, where the evidence sits, not Level 5, which Shapiro defines as its absence: “humans are neither needed nor welcome” covers a handful of tiny teams, not a published route. More in the human in the loop.

Copy-paste prompts for placing your workflow on the ladder

Run the first against a repository you ship from.

Audit this repo for its autonomy level

Read the repository's CI config, hooks/rules files (CLAUDE.md, AGENTS.md, .cursor/rules, .claude/settings.json), test scripts and the last 30 merged PRs. For each of Dan Shapiro's levels 1-5, state the concrete evidence for and against this repo operating there. Name the single verification gap that stops it from moving one level up, and write the smallest change (a hook, a test target, a stop condition) that closes it. Do not edit files.

Design the stop condition for a /goal run

I am about to start a goal-directed run for: <one-sentence objective>. Write the stop condition as commands that exit 0 (tests, typecheck, lint, a grep for the old API), list what the agent may not touch, define the checkpoint log format per round, and state the budget after which the run stops and reports instead of continuing. Reject any condition the agent could satisfy by weakening a test.

Write the verification contract for a factory station

Station: <intent|harness|loop|graph|verification|release>. Write the contract as: inputs the station accepts, deterministic validators that must pass before hand-off (name the command), the failure route (which station receives a FAIL and what it gets back), the maximum retries, and the human escalation trigger. Output as a markdown table plus the validator commands.

Where the numbers break down

Five ways this evidence gets misused, with the recovery.

• Reading “percentage of lines” as “percentage of work”. Anthropic’s footnote and Redwood’s critique both refuse that step. Pair every share figure with a work figure the same team controls: review time, incidents per pull request.
• Quoting half of Faros. The +66.2% epics and the +242.7% incidents came from one telemetry set. Quote throughput and quality together or neither, keeping the review metrics distinct.
• Declaring a level for a whole company. A migration loop with a deterministic validator can run at Level 4 while the feature work beside it sits at Level 2. Assign a level per loop, with its oracle named.
• Citing a vendor’s internal share as an industry rate. Anthropic, Stripe, Google and Cherny all report on themselves. For an industry number, use DX’s 51.9% or Sonar’s 42%.
• Publishing feature claims that have expired. Cursor had no /goal until 19 August 2026 and now calls it “a long-lived objective to work towards until it’s fully complete”; Codex documents /goal and not /loop. Re-fetch the vendor page the day you publish.

Where to go next on the ladder

The autonomy ladder

Level 3 in practice: agent fleets

Level 4 in practice: the /goal command

The human in the loop

Software factories

Developer scorecard

CTO scorecard

Sources

1. Shapiro, “The Five Levels”, 23 Jan 2026. https://www.danshapiro.com/blog/2026/01/the-five-levels-from-spicy-autocomplete-to-the-software-factory/
2. Simon Willison, same title, 28 Jan 2026. https://simonwillison.net/2026/Jan/28/the-five-levels/
3. Karpathy, “Sequoia Ascent 2026”, 30 Apr 2026. https://karpathy.bearblog.dev/sequoia-ascent-2026/
4. Anthropic, “When AI builds itself”, undated (“as of May 2026”). https://www.anthropic.com/institute/recursive-self-improvement
5. Fortune, “Top engineers at Anthropic, OpenAI say AI now writes 100% of their code”, 29 Jan 2026, and “The head of Claude Code hasn’t ‘written a line of code by hand’ in 8 months”, 11 Jun 2026. https://fortune.com/2026/01/29/100-percent-of-code-at-anthropic-and-openai-is-now-ai-written-boris-cherny-roon/ and https://fortune.com/2026/06/11/anthropic-claude-boris-cherny-doesnt-write-code-by-hand-anymore/
6. DX, “AI-authored code has nearly doubled”, 17 Jun 2026. https://newsletter.getdx.com/p/ai-authored-code-has-nearly-doubled
7. Sonar, “State of Code Developer Survey”, 8 Jan 2026. https://www.sonarsource.com/blog/state-of-code-developer-survey-report-the-current-reality-of-ai-coding/
8. Murphy-Hill, Butler and Savelieva, “Adoption and Impact of Command-Line AI Coding Agents: A Study of Microsoft’s Early 2026 Rollout of Claude Code and GitHub Copilot CLI”, arXiv:2607.01418, 1 Jul 2026. https://arxiv.org/abs/2607.01418
9. Stripe, “Minions”, 9 and 19 Feb 2026. https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents and https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents-part-2
10. Ryan Greenblatt, Redwood Research, “Is 90% of code at Anthropic being written by AIs?”, 22 Oct 2025. https://blog.redwoodresearch.org/p/is-90-of-code-at-anthropic-being
11. METR, “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity”, 10 Jul 2025, and “We are Changing our Developer Productivity Experiment Design”, 24 Feb 2026. https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/ and https://metr.org/blog/2026-02-24-uplift-update/
12. Faros AI, “The Acceleration Whiplash”, Apr 2026. https://www.faros.ai/blog/ai-acceleration-whiplash-takeaways
13. Google Cloud, “2025 DORA Report”, 23 Sep 2025. https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report
14. Orlanski et al., “SlopCodeBench”, 25 Mar 2026. https://arxiv.org/abs/2603.24755
15. BCG Platinion, “The Agentic Software Factory”, 26 Mar 2026. https://www.bcgplatinion.com/insights/the-agentic-software-factory
16. Grigorev, “AI-Native Development”, 22 Jul 2026. https://aishippingblog.com/p/ai-native-development-specifications
17. Naresh B A, “Graph Engineering for AI Coding Agents: Beyond Prompt Loops”, 30 Jul 2025. https://dev.to/naresh_007/graph-engineering-for-ai-coding-agents-beyond-prompt-loops-48h4
18. Linear, “Agent Interaction SDK”, 1 Aug 2025. https://linear.app/now/our-approach-to-building-the-agent-interaction-sdk
19. Yegge, “Gas Town”, 1 Jan 2026. https://yegge.ai/gastown
20. DoltHub (Tim Sehn), “A Day in Gas Town”, 15 Jan 2026, and “A Week in Gas Town”, 24 Mar 2026. https://www.dolthub.com/blog/2026-01-15-a-day-in-gas-town/ and https://www.dolthub.com/blog/2026-03-24-a-week-in-gas-town/
21. Opalic, “The Software Factory”, 22 Mar 2026. https://alexop.dev/posts/the-software-factory/
22. Council on Foreign Relations, “CEO Speaker Series With Dario Amodei of Anthropic”, 10 Mar 2025. https://www.cfr.org/event/ceo-speaker-series-dario-amodei-anthropic
23. Fast Company (secondary), “Google CEO says 75% of the company’s code is AI-generated”, 24 Apr 2026. https://www.fastcompany.com/91531519/google-ceo-says-75-of-the-companys-code-is-ai-generated
24. Dex Horthy (secondary talk), “Harness Engineering is not Enough: Why Software Factories Fail”, AI Engineer World’s Fair, Jul 2026. https://www.youtube.com/watch?v=Ib5GBkD555M