What the head of Claude Code thinks is next for software engineering

AI coding assistants have moved from novelty to default. In many teams, most new code is now written by models, not humans. That shift is already changing how engineering works day to day—and it’s about to go much further.

In this fireside-style conversation, the head of Claude Code walks through how Anthropic builds with its own tools, why ROI matters more than raw token costs, and what concepts like loops, workflows, and co-work mean for the future of software engineering.

From human-written code to 100% AI-written code

At Anthropic, the shift to AI-written code is not theoretical. Since late 2023, Claude Code has written essentially 100% of the head of Claude Code’s own contributions. Across Anthropic as a whole, an estimated 80–90% of all code is now generated by Claude Code, and for many teams that number has already reached 100%.

That doesn’t mean engineers stopped shipping. Quite the opposite: Anthropic reports an 8x increase in code produced per engineer since the beginning of the year. The bottleneck is no longer typing code—it’s everything around it: ideas, coordination, review, security, and deployment.

One surprising side effect of this shift: a lot of coding now happens on phones. With capable agents doing the heavy lifting, the traditional IDE is less central. The head of Claude Code even uninstalled their IDE once Claude became good enough at writing and editing code directly.

Why companies should think in ROI, not token budgets

Many organizations are starting to put hard budgets on AI usage—such as a fixed monthly token spend per engineer. At the same time, frontier models like Fable and Opus 4.8 are more capable but also more expensive.

The key argument from Anthropic’s side: cost-only thinking is the wrong frame. You’re not just spending tokens; you’re investing to get a return. The real question is ROI: how much more value does your team create because of these tools?

Anthropic sees the most successful companies follow a two-stage pattern:

1. Start broad, then optimize

Instead of locking AI tools to just engineers, they give tokens to everyone—PMs, designers, data scientists, marketers, even finance. They encourage experimentation and make it safe to try ideas without fear of being punished for token usage.

Many of the best process improvements and product ideas come from unexpected places, like an accountant or a marketer who spots a broken workflow and uses an agent to fix it.

2. Once use cases are proven, optimize on the backend

After a use case takes off, that’s when companies start tuning for efficiency. Anthropic suggests doing this on the backend rather than by limiting users. Techniques include:

• Per-seat cost controls and departmental budgets
• Using advisor models to decide when to call more expensive models
• Switching default models company-wide (e.g., Sonnet or Opus by default, Fable only when needed)
• Adjusting effort levels to control how much test-time compute a task uses

But even with these tools, Anthropic’s advice is clear: you can probably cut costs by 50%, but you might increase returns by 1,000% or more. Focus most of your energy on the upside, not just on shaving pennies off token bills.

What happens after 100% of your code is AI-written?

Once nearly all code is written by an agent, traditional productivity metrics break down. Measuring “percent of code written by AI” stops being useful when the answer is 100%.

Anthropic suggests a new way to think about impact:

• Get to 100% AI-written code for most routine work.
• Track acceleration in code per engineer over time—how much more can each person ship?
• Find and unblock the new bottlenecks: idea generation, product sense, coordination, deployment, security, and go-to-market.

As coding becomes cheap and fast, the real constraints shift upstream and downstream. You need more and better ideas, and you need to move them safely into production and out to users.

That’s where roles like PMs, user researchers, and marketing become even more critical—and where new AI tools beyond code assistants start to matter.

Loops: agents prompting agents

One of the most important new concepts Anthropic is betting on is loops. If agents writing code were the last big step, loops are the next one: agents that repeatedly run tasks, call other agents, and keep improving systems without constant human prompting.

For engineers, you can think of it like this:

• Writing source code by hand is like basic statements.
• Using a single agent to write code is like calling a function.
• Loops are like higher-order functions—agents orchestrating other agents over time.

Concrete examples of loops in action:

• Automated code review loops: instead of manually asking an agent to review each PR, you run an agent in a loop that continuously reviews all new pull requests.
• Continuous feedback loops: an agent checks social feedback (e.g., Threads, X, forums) every few minutes, summarizes issues, and opens PRs with fixes.
• Maintenance loops: an agent periodically scans a large codebase to improve architecture, remove dead code, reduce test flakiness, and unify duplicate abstractions—then opens PRs for you to review.

Today, the head of Claude Code estimates that about 30% of their daily coding is done via loops. On some days, with effort, they can reach close to 100%, though the ecosystem is still early. Expect that number to rise as tools mature.

If you want a practical taste of this style of work, you can look at guides like fully automating social media with Claude Code, which shows how to turn repeated workflows into self-running systems.

Dynamic workflows and test-time compute

Loops are one piece of a broader shift: using far more test-time compute to get better results. In simple terms, test-time compute is how many tokens a model uses while solving a task.

Anthropic highlights four main scaling factors that drive model capability:

• Training data
• Model size
• Training compute
• Test-time compute (how many tokens the model generates while working)

Two key ways Claude exposes test-time compute to users:

• Effort settings: from low to max, these settings control how much thinking (tokens) the model does before answering. More effort usually means better results.
• Dynamic workflows: a new feature where Claude writes and runs a small program inside a virtual machine to orchestrate dozens, hundreds, or thousands of sub-agents to solve a complex task.

One real example: the head of Claude Code asked Claude to “look at our CI timings and optimize CI to make it much faster.” Using a dynamic workflow, Claude:

• Analyzed real CI timing data
• Ran for a few hours and used a few million tokens
• Opened four pull requests that cut CI time by about 50%

This is work that would traditionally take days or weeks of profiling and tuning. Now, it’s a single high-level prompt plus review of the resulting PRs.

Co-work: Claude Code for non-engineers

Claude Code is aimed at engineers, but Anthropic also ships co-work, which is essentially Claude Code for non-engineers. It runs inside the Claude desktop app (Mac and Windows) and uses the same Claude agent SDK under the hood.

Co-work adds extra guardrails and a full virtual machine environment so non-technical users can safely let an agent operate tools on their behalf. It also integrates with the operating system and browser to prevent dangerous actions and defend against prompt injection.

Some real-world co-work use cases:

• Automated standups and project tracking: co-work opens a spreadsheet in the browser, messages each engineer in Slack to ask for status updates (often talking to their Claude agents), and fills in the project tracking sheet automatically.
• Fully automated travel booking: a scheduled co-work task scans email and calendar for upcoming trips outside a home city, then books flights and hotels according to stored preferences. The agent uses the corporate travel site, fills forms, and sends confirmations—after a final human check.

For teams looking to bring AI agents to marketing, ops, or other business functions, co-work can be a powerful bridge. For example, you can pair it with ideas from building an AI marketing team with Claude Code to create end-to-end automated workflows.

Using Fable vs. Opus vs. Sonnet for coding

Anthropic’s Fable model briefly became available to the public before being pulled back due to what the company describes as a misunderstanding. Internally, though, Anthropic has been using it extensively.

How does Fable compare?

• The jump from Opus 4.5 to Fable feels at least as big as the jump from earlier models to Opus 4.5, which was when many engineers first switched to 100% AI-written code.
• Fable shows much better nuance and reasoning, especially for tasks like debugging, data analysis, and complex problem solving.
• In practice, Anthropic engineers report “running out of hard problems” to give it—most tasks are solved in one or a few attempts.

Fable is more expensive and somewhat slower than other models, but Anthropic’s own engineers still use it for everything. The reasoning is the same ROI argument: the opportunity to increase returns far outweighs the savings from using a cheaper model, especially at this early stage.

For organizations, a hybrid strategy makes sense: use Sonnet or Opus as defaults, and call Fable when needed via advisor models or routing logic. But for individuals exploring what’s possible, using the best model available is often the fastest way to discover new workflows.

Rethinking code review and security in an AI-first world

Once code generation is no longer the bottleneck, the next constraints become code review and security. Anthropic’s answer has been to build products that they use internally and then ship them to customers.

Claude Code Review

Claude Code Review is designed to be a full replacement for traditional human-first code review for many classes of bugs. It’s intentionally more expensive than typical AI review tools because it uses many more tokens per PR to deeply analyze changes.

By the time a human engineer sees a pull request, Claude has already:

• Scanned for and fixed most bugs (Anthropic reports 98–99% coverage on many bug classes)
• Left comments and suggestions where needed

The human reviewer’s job shifts from “find bugs” to higher-level questions: is this the right change? Does it align with product goals? Is the design sound?

Claude Security

On the security side, Anthropic runs a weekly automated scan across all codebases using Claude Security. The agent finds vulnerabilities and opens PRs with fixes, again with minimal human prompting.

With Opus 4.8 and newer models, Claude Security has reached the point where it sometimes catches issues that even professional penetration testers miss. It’s not perfect, but it’s good enough that it meaningfully raises the security baseline.

These tools illustrate a broader pattern: each time a bottleneck emerges—coding, review, security—Anthropic builds an agent-based system to attack it.

Where engineers should focus as agents take over coding

If agents can write, review, and secure most code, what’s left for engineers?

According to the head of Claude Code, there’s still a long list of high-value work that humans do better today:

• Product sense and idea generation: deciding what to build, why it matters, and how it should feel.
• Talking to customers and understanding real-world problems.
• Systems thinking: aligning work across teams, understanding trade-offs, and designing roadmaps.
• Distributed systems design: reasoning about services, data flows, load, and failure modes—an area where even Fable still has room to improve.

In the near term, engineers are also the ones who:

• Break down work into prompts and loops
• Supervise agents and review their output
• Decide which workflows to automate and how aggressively

Over time, models will get better at many of these tasks. But for now, the highest leverage work is designing and supervising the systems that do the coding—not typing the code itself.

Preventing engineers from going on autopilot

One concern with powerful agents is that engineers might become lazy and blindly accept whatever the model outputs. Anthropic tackles this from two angles: better automation and better learning tools.

1. Let Claude handle more, but safely

Early versions of Claude Code showed every command the agent wanted to run and asked the user to approve or deny. In practice, people developed “prompt fatigue” and just hit yes repeatedly—hurting security instead of helping it.

The solution is auto mode:

• Permission prompts are routed to a model that decides yes/no based on context.
• Claude models are heavily hardened against prompt injection, with success rates around 1% even after 100 attack attempts, according to Anthropic’s system cards.
• A separate prompt injection classifier adds another layer of defense.

This setup makes it possible to run long-lived agents—hours or days—without constant human clicking, while still maintaining strong safety guarantees.

2. Use output styles to keep humans learning

To keep engineers engaged and growing, Claude Code supports output styles that change how it explains its work.

• Exploratory output style: recommended for new engineers. Claude explains how the architecture works, why it’s making certain changes, and how specific languages or frameworks behave.
• Learning output style: aimed at non-coders. Instead of directly editing files, Claude walks the user through each step—what file to open, what to change, what command to run—teaching fundamentals along the way.

These modes turn Claude from a black-box code generator into a mentor that helps people understand and eventually design better systems themselves.

The next year of Claude Code: more capable, more aligned, more everywhere

Anthropic doesn’t plan on rigid one-year roadmaps; the space is moving too fast. Instead, they iterate on weekly and monthly cycles. But the direction for Claude Code is stable:

• Be the most capable agent for long-running, complex work.
• Work wherever teams already work—editors, terminals, browsers, chat tools—rather than forcing a new full-stack environment.
• Expose new model capabilities (like better long-horizon reasoning and alignment) in ways that feel natural and powerful to users.

As models get better at long-running tasks, security, and alignment with user intent, more of the software lifecycle will be handled by agents. Engineers, PMs, and other builders will spend less time fighting tools and more time deciding what to build and why.

We’re already in a world where many teams have 100% AI-written code. The next phase is figuring out how to turn that raw power into better products, faster learning, and more ambitious ideas.