Anthropic recently published When AI builds itself, a data-backed account of how much of the company’s own development is now handled by its models. The striking finding isn’t that Claude now authors most of the code Anthropic merges. It’s what the authors identify as the next constraint once they do: when systems generate faster than people can check, the limiting factor stops being creation and becomes verification.

Drawn from inside one of the most advanced AI labs in the world, that finding describes a problem most regulated enterprises adopting AI-generated logic are about to face.

What the research found

As of May 2026, more than 80% of the code Anthropic merges is written by Claude – up from low single digits before Claude Code launched in early 2025. Engineers have shifted from authoring code to directing and reviewing it. Anthropic frames this as early progress toward recursive self-improvement: AI systems increasingly capable of building the next generation of AI.

But the report’s sharpest insight is about bottlenecks. The authors note that review becomes the bottleneck once humans can’t keep pace with generation. Anthropic says it has already hit exactly this wall internally. The remaining human advantage, for now, is judgment: deciding what to build, what to trust, and when an answer is wrong.

The problem is far worse outside the lab

Anthropic’s reviewers are world-class engineers reviewing code. In principle, they can still read it. In an enterprise, the people accountable for a decision – the underwriter, the pricing lead, the compliance officer – often cannot read code at all.

When AI produces the implementation of a pricing rule, an eligibility check, or a risk threshold, the expert can judge the output but not the logic beneath it. And you cannot review what you cannot understand. So they are asked to trust the model and sign. Hand someone ten thousand lines of generated code and that signature isn’t oversight — it’s a signature on a black box. Under regimes like the EU AI Act, that signature will increasingly need evidence: who approved the rule, what was tested, what changed, and what actually ran.

Reviewing Code Faster Is the Wrong Fix

The instinct is to make code review faster: better diff tools, AI reviewing AI, more automated checks. Those tools help engineers. They do not solve the enterprise problem.

Because even when AI generates the implementation, the person accountable for the business decision still cannot see the logic. The underwriter, pricing lead, or compliance officer still has to send intent through someone else: a business analyst, an architect, a developer, a test team, or now a prompt that produces code they cannot inspect. Every handoff adds translation. Every translation loses intent. AI makes this worse if the output is still code. It accelerates the last step of the old workflow, but leaves the intent holder outside the loop.

Leapter changes the loop itself.

Instead of turning business intent into code the rule owner cannot inspect, Leapter turns it into a Blueprint: the versioned, executable decision graph itself, not a visual summary of hidden code. Every condition, threshold, branch, and intent note is legible in one inspectable artifact. AI drafts it, but the domain expert can read it, test it, edit it, and approve it directly.

For example, a credit-risk owner can inspect the debt-to-income threshold, exception paths, test cases, approval record, and exact branch that fired before approving the version that runs.

That is the shift: not faster code review, but direct review and iteration by the person who owns the rule.

The workflow is Describe → Generate → Validate → Run. The expert describes the logic in plain language. AI drafts the Blueprint. The expert inspects it from the inside, validates it against real cases, edits it, and signs off.

Once approved, the Blueprint executes deterministically, with no LLM in the decision path. Same input, same output, every time.

In spirit, this is literate programming for the AI era: human intent, executable rules, tests, and change context in one inspectable artifact. The rule owner can understand what runs, and the model can use the attached intent when it drafts, explains, or changes the logic later.

Verification stops being a code-reading bottleneck. Not because review got faster, but because the person who owns the rule can finally review the thing that runs.

“Leapter’s genius is in its ‘glass box’ approach – the auditability and human-in-the-loop governance CIOs and CISOs need to deploy AI-driven development at scale. It’s the missing link for enterprise-grade AI adoption.”

– Phil Le-Brun, AWS Executive in Residence; former International CIO, McDonald’s

Why this is the moment

Two curves are converging. Generation is commoditizing toward zero, while the cost of trusting un-inspectable output is climbing. As autonomous agents take on consequential decisions, enterprises need a deterministic, inspectable policy layer between probabilistic reasoning and real-world action. The value is migrating from producing logic to verifying it.

Anthropic named the bottleneck. The answer isn’t to review faster – it’s to make the thing under review legible to the human who’s accountable for it. That artifact already exists. We call it the Blueprint.

If your AI roadmap asks business owners to approve logic they cannot inspect, start with one rule. We’ll turn it into an executable Blueprint and show you exactly what gets reviewed, approved, and run.

Explore Leapter with an Expert

Leapter gives humans and AI a shared visual language so the rules that run the business are no longer hidden in code, but written for both to read, refine, and trust.