Anthropic confirmed this week that 80%+ of their code is now written by AI.

The wrong lesson is spreading faster than the right one.

The wrong lesson: AI is ready for autonomous operation. If it can write most of Anthropic's code, surely it's ready to run your finance operations, your customer success, your strategic planning.

The right lesson: Code happens to be the one professional domain where AI agents can almost fully compensate for everything they're bad at. That's a very specific property. It doesn't transfer.

I wrote about why coding agents are a best-case scenario back in March. This post is the extension of that argument — the framework for deciding where the next wave of AI agents will and won't work, now that we have actual production data to reason from.

The Model-Centric Exception

Most AI agent designs are model-centric. The model is the intelligence. You give it tools, a goal, and a context window. You let it figure out how to get there. The agent is the model, plus some scaffolding.

This works in code. Spectacularly.

And the dominant response in the industry has been to assume the model is what made it work — and therefore to apply the same model-centric architecture to every domain that has ever involved knowledge work.

That's the mistake. What made it work isn't the model's intelligence. It's what the domain provides the model in return.

What Code Gives the Model That Nothing Else Does

Coding agents work because software is, almost uniquely, a verifiable output domain.

The model proposes a change. The domain instantly tells you if the proposal was correct.

Does it compile? Yes or no. Binary signal. Zero ambiguity.

Do the tests pass? Yes or no. Binary signal. Zero ambiguity.

Does the linter flag anything? The specific lines, the specific violations. Zero interpretation required.

This is the closed feedback loop. The model makes a move. Reality evaluates it. The model adjusts. Repeat until done.

No other professional domain has this naturally. Finance AI doesn't get a "compile" step. Customer success AI doesn't run a test suite. Strategy AI doesn't have a linter. The model makes a move, and then... you wait. For results that arrive weeks later, confounded by a dozen other variables, evaluated by humans with differing opinions about what "correct" even means.

Verifiable output changes what a model-centric agent can actually do. It can iterate. It can self-correct. It can work autonomously without accumulating errors it can't detect.

Take verifiable output away, and you're asking the model to operate blind. It still has intelligence. It just has no feedback mechanism. And a closed loop broken at the feedback stage isn't a loop — it's a one-shot bet.

The 80% Stat Doesn't Mean What People Think It Means

When Anthropic says 80%+ of their code is AI-written, the instinct is to think about the AI.

Think about the humans instead.

80% of code being AI-written means 80% of code is getting reviewed by humans. That's the new bottleneck. Not generation — review. And code review is a genuinely hard cognitive task that scales poorly. Engineers can write fast or review carefully. They cannot do both at full speed simultaneously.

This is what the 80% number actually tells you: the bottleneck shifted, but it didn't disappear. It moved from writing to reviewing. Every team that's adopted AI coding tools at scale and hasn't updated their review practices is now running with a hidden constraint where throughput is high and quality leverage is low.

The question worth asking isn't "can AI write our code?" It's "have we adapted our review process to AI-authored code?" The answer, at most of the companies I talk to, is no.

The Verifiable Output Test

Here's the filter I use when evaluating whether a model-centric agent design makes sense for a domain:

Can the domain tell the model, unambiguously, whether its last output was correct?

Not "approximately correct." Not "correct according to this human's opinion." Unambiguously correct. Binary signal. Immediate feedback.

Domain	Verifiable?	Why
Software compilation	✓	Binary. Instant.
Unit tests	✓	Binary. Instant.
Type checking	✓	Binary. Deterministic.
SQL query correctness	✓	Return set either matches expectations or doesn't.
Data pipeline validation	Partial	Schema checks pass/fail; business-logic correctness requires human judgment.
Contract review	✗	"Correct" depends on negotiation objectives, risk tolerance, relationship context.
Customer support quality	✗	"Correct" depends on customer sentiment, long-term retention, brand voice.
Financial forecasting	✗	Ground truth arrives quarters later, confounded by market conditions.
Strategy documents	✗	No binary signal at all. Just opinions and eventual outcomes.

Where a domain lands on this spectrum tells you more about agent architecture than any model benchmark.

The domains with verifiable output don't just tolerate autonomous operation — they enable iteration. The model can work in a loop because each iteration has a ground truth check built in. Domains without verifiable output require something else: human review checkpoints, structured workflows, guardrails that force the model to surface its uncertainty before downstream work accumulates.

Where the Next Verifiable Domains Are

A few places I'm watching:

Infrastructure and DevOps. The outputs are machines. Machines either boot or they don't. Services either respond or they don't. Infrastructure as code already has test frameworks. This is adjacent to software and inherits most of the same properties.

Data quality. Schema validation, referential integrity, business rule conformance — these can all be expressed as assertions. The gap is that "correct data" means different things at different layers, and higher-level correctness isn't always binary. But the low-level stuff is aggressively verifiable.

Formal specifications. Legal contracts with machine-readable constraint sets. Financial agreements with explicit terms. Compliance rules expressed as executable policy. The work to make this verifiable is frontend work (getting humans to express their requirements formally), but once done, the downstream agent work benefits enormously.

Scientific experimentation. Runs, or it doesn't. Reproduces, or it doesn't. Metrics move in the expected direction, or they don't. Not perfect — confounders exist, interpretations vary — but the structure is fundamentally more verifiable than most knowledge work.

What to Do With This

If you're a CTO who just read that 80% stat and started mapping it to your roadmap:

Audit your own domains for verifiable output before assuming the model generalizes.

The code that's 80% AI-written at Anthropic passes a compiler. It passes tests. It gets reviewed against clear correctness criteria. That's what makes the 80% number possible, not the model's raw capability.

If your domain doesn't have that, you need systems-level architecture: deterministic pipelines, explicit validation steps, human checkpoints at ambiguity boundaries. The model becomes one component, not the whole agent.

The teams that are building the best AI systems right now aren't using model-centric architecture everywhere. They're using it where the domain cooperates, and using structured pipelines where it doesn't. They're honest about which is which.

That judgment — where to run the model hot, where to box it in — is the new technical leadership skill. It's not about AI capability. It's about domain analysis.

The Real Lesson From Coding Agents

Coding agents didn't succeed because AI is ready for autonomous operation. They succeeded because software engineers spent decades building a domain with tight feedback loops, unambiguous correctness checks, and structured decomposition.

They made the domain agent-compatible. The model arrived and found it ready.

The question isn't "what else can AI do?"

It's "what else can we make verifiable?"

That's where I'd be spending the architecture budget right now.