Two things happened this month that tell the same story from different angles. Anthropic published a large-scale analysis of millions of real agent interactions. And Chris Lattner — the creator of LLVM, Clang, Swift, and Mojo — published a deep technical review of Anthropic's Claude C Compiler. Together, they paint a clear picture of where software engineering is heading.
Software Engineering Is the Beachhead
Anthropic's data is unambiguous. Software engineering accounts for nearly 50% of all agentic tool calls on their public API. Business intelligence, customer service, sales, and finance each trail in the single digits.
This isn't a surprise if you've been paying attention, but having it confirmed at scale matters. Software engineering is where AI agents are delivering real, measurable value today. Everything else is still experimental.
The autonomy numbers are equally telling. Claude Code's longest autonomous work sessions — the 99.9th percentile — nearly doubled between October 2025 and January 2026, jumping from under 25 minutes to over 45 minutes. Experienced users (750+ sessions) auto-approve over 40% of their sessions, compared to roughly 20% for newer users.
(For context: in my own workflow, I routinely structure work so that once I hand off to agents, they're coding autonomously for three to five hours straight. I've taught this process to several teams now and the results are consistently strong. I walked a sharp group through it just last week — they picked it up quickly and saw the promise immediately. The 99.9th percentile is 45 minutes. The ceiling is much higher than that.)
And here's the finding that should get every engineering leader's attention: Anthropic identified what they call a "deployment overhang." The models can handle far more autonomy than users currently grant them. Even experienced users don't intervene in over 90% of work steps. The agents stop themselves to ask clarifying questions more than twice as often as humans interrupt them.
The constraint is human trust and workflow integration.
AI Just Built a C Compiler
While Anthropic was publishing usage data, Chris Lattner was dissecting something more concrete: a C compiler that Claude built largely autonomously.
Lattner doesn't hand out praise casually. He's spent his career building the compiler infrastructure that most of the industry runs on. His assessment: the Claude C Compiler is "real progress, a milestone for the industry." It's neither a trivial toy nor production quality — he calls it a "competent textbook implementation," the kind of system a strong undergraduate team might build early in a project before years of refinement.
Pay attention to the scope here. A C compiler is a coordinated system — a lexer, parser, type checker, code generator, and optimizer that all need to maintain architectural coherence across subsystems. The first commit effectively one-shots the basic architecture. Subsequent commits refine toward correctness. That's system-level engineering, autonomously.
This mirrors one of two open questions I keep coming back to: How do we build larger and larger systems at scale with these tools? The CCC pattern is instructive — you build the basic architecture first and build into it, rather than incrementally bolting features on from the side. That's a fundamentally different way of working, and most engineering organizations aren't structured for it yet.
Where It Breaks Down
Lattner's sharpest observation is about how CCC achieves its results. It optimizes toward passing tests rather than building general abstractions. It follows classic LLVM-like design patterns — because that's what the training data contains. It's shaped by decades of compiler engineering history, for better and worse.
In other words: the quality of AI-generated systems is a direct function of the quality of the specifications, test suites, and architectural documentation it's given.
Architecture documentation has become infrastructure. AI amplifies well-structured knowledge while punishing undocumented systems. If your architecture is well-specified, AI can execute against it at remarkable speed. If it isn't, AI will produce generic solutions shaped by whatever averaged patterns it learned from the internet.
The Implication for Engineering Organizations
These two data points converge on the same conclusion:
When AI automates implementation, design and stewardship become the premium skill.
Anthropic's data shows agents working autonomously for extended sessions with minimal human intervention. Lattner's review shows them participating in system-level engineering — full compilers, coordinated subsystems, architectural coherence.
But the deployment overhang is real. Most organizations aren't set up to take advantage of this. They're still treating AI agents like autocomplete — approving individual actions instead of specifying outcomes and letting agents execute.
The organizations that will pull ahead are the ones that invest in the specification layer: architecture documentation, domain models, test suites, and the operational workflows that let agents work autonomously within well-defined boundaries.
The most valuable engineers will be the ones who write the specifications that AI systems execute against.