The software industry has heard plenty about how artificial intelligence will transform software development. Analysts have analyzed it. Consultants have built practices around it. Vendors have attached AI to just about every product description they could find.

It is a little different when the message comes from one of the companies building the AI responsible for the disruption.

Anthropic recently published “The AI-Native SDLC Playbook,” a detailed proposal for transforming the software development lifecycle one stage at a time. Written by Louis Claxton and drawing on practices from Anthropic’s Applied AI team and its customers, the playbook makes a deceptively simple assertion: Code is no longer necessarily the bottleneck.

This is not literally Claude writing its own review of the software industry. Still, it is about as close to hearing it from the horse’s mouth as we are likely to get. The company whose AI helped accelerate software development is now telling us that the processes surrounding software development cannot keep up.

The horse has looked back at the carriage and announced that it is moving too slowly.

The Bottleneck Did Not Disappear

For decades, the software development lifecycle was organized around the assumption that writing and implementing code consumed a large share of the time, effort and expense. Requirements processes, architecture reviews, estimation rituals, QA gates and change approvals developed around projects that might take weeks, months or quarters to complete.

Agentic coding changes that production rate. An AI agent can explore a repository, create an implementation plan, modify multiple files, generate tests and prepare a pull request in a fraction of the time previously required.

That does not mean the entire organization suddenly moves at the same speed.

Product requirements still have to be clarified. Architectural decisions still have to be made. Generated code must still be reviewed, tested and secured. Production changes must still be approved. Applications must still be observed, maintained and repaired.

If coding accelerates while those surrounding processes remain unchanged, the bottleneck simply moves. Review queues grow. Security teams receive more code than they can evaluate. Testing infrastructure becomes overloaded. Change approvals begin holding up increasingly large volumes of completed work.

The organization may produce more code without delivering more dependable software.

This is consistent with DORA’s research into AI-assisted software development. DORA found that AI adoption can improve productivity and delivery throughput, but it can also have a negative relationship with software-delivery stability. AI acts as an amplifier. Organizations with strong platforms, automated testing and rapid feedback loops can translate coding speed into better delivery performance. Organizations with weak foundations may amplify their existing dysfunction.

Code has not stopped being difficult, and Anthropic’s assertion will not apply equally to every organization or application. But for teams adopting advanced coding agents, code is no longer the only limiting factor. Increasingly, it may not even be the most important one.

What an AI-Native SDLC Looks Like

Anthropic is proposing something more consequential than adding an AI assistant to each developer’s existing toolchain.

The traditional SDLC is generally described as a sequence of six stages: Plan, Design, Build, Test, Deploy and Maintain. Work passes between those stages through tickets, documents, meetings, reviews and sign-offs.

Anthropic turns that sequence into a continuous loop. Each stage produces an artifact that the next human or agent can read and act upon:

Intent → Specification → Plan → Code and tests → Review and deployment evidence → Incident record → New intent

The artifacts provide continuity across the lifecycle. They also establish an audit trail showing what someone requested, what the agent proposed, which policies were applied, what evidence was produced and who approved the result.

Humans remain accountable, but their role changes. They spend less time manually carrying information from one stage to another and more time evaluating intent, risk, exceptions and consequential decisions.

Here is how Anthropic envisions the six stages working.

Plan: Capture Intent at the Source

The process begins with an intent.md file. A business user, product owner or engineer describes a problem to Claude in ordinary language. Through that conversation, Claude helps capture the desired outcome, affected users and systems, constraints and unresolved questions.

A human reviews and corrects the result before it enters the development process.

The important concept is not the filename or even the particular model creating it. The idea is to capture intent once, close to its original source, in a format that both humans and machines can understand.

That can reduce the distortion that occurs when an idea travels through workshops, backlog entries, user stories, refinement sessions and multiple organizational handoffs before reaching the people who will implement it.

Design: Apply Policy Before Building

Once approved, the intent becomes a requirements and design specification. Organizational knowledge about security, compliance, architecture, branding and user experience is encoded as reusable instructions or skills that the agent applies while creating the specification.

This changes where governance enters the process. Instead of discovering a security requirement or architectural conflict during a review weeks later, the agent applies the relevant policy while the system is being designed and flags anything it cannot reconcile.

A human product owner still decides whether the specification solves the intended problem. AI does more of the synthesis, but it does not assume accountability for the decision.

Build: Approve the Plan Before Generating the Code

The coding agent reads the approved intent and specification, examines the repository and creates an implementation plan. That plan identifies the files that will change, the implementation sequence, potential risks and the tests required to prove the work.

An engineer reviews and approves the plan before the agent begins modifying the code.

This is an important point. AI does not make planning less important. It makes planning more important because the cost of generating a large amount of code has fallen so dramatically. It is cheaper to correct an unsound approach in a plan than to discover it inside an extensive completed change.

Anthropic also recommends maintaining a repository-level CLAUDE.md file containing build commands, architecture conventions and recurring corrections. Information that once lived in a wiki or an experienced engineer’s head becomes machine-readable institutional memory that the agent receives whenever it works in the repository.

Test: Require Evidence, Not Confidence

Anthropic’s testing model is built around continuous, verifiable evidence.

For a bug fix, the agent should first create a test that reproduces the failure. The test should fail for the expected reason before the fix begins, and the agent should not be allowed to weaken or delete the test merely to produce a green result.

For interface work, an agent can compare screenshots against an approved design and iterate until the implementation matches. Changes to models, prompts or agent configurations can trigger evaluation suites to ensure that the system continues producing acceptable results.

The principle is straightforward: Do not trust code simply because a powerful model generated it. Require proof through tests, build results, evaluation scores, visual comparisons and security findings.

Deploy: Make Governance Executable

Agents can review pull requests, compare the completed implementation with the approved plan, inspect changes for vulnerabilities and verify compliance with organizational policy.

Anthropic proposes using automated hooks that can allow an action, block it or pause it until a named person grants approval. Routine, low-risk changes can move quickly. Production deployments, infrastructure modifications and regulated applications can retain explicit human authorization.

Governance moves closer to the work. It becomes part of the execution environment instead of a policy document developers are expected to remember or a committee that reviews a change after most of the work is complete.

Maintain: Close the Production Loop

Once an application reaches production, agents can monitor it, investigate alerts and assist with incident response. When a production condition breaches an established control band, the diagnosis can become a new intent.md and reenter the planning process.

Maintenance is no longer the final box in a linear diagram. Production continuously generates evidence, learning and new intent for the development system.

That closed loop may be the most consequential part of Anthropic’s proposal. It connects what an organization wanted to build with what it designed, what the agent changed, how the change was validated and what actually happened in production.

Written in Claude’s Language, but Bigger Than Claude

The playbook is unmistakably Claude-centric. It includes Claude Code, CLAUDE.md, Claude skills, Claude Security, hooks and other elements of Anthropic’s platform.

What else would we expect Anthropic to publish?

That should not obscure the larger contribution. The architecture itself is not exclusive to Claude. Another agent can produce an implementation plan. A different repository instruction format can provide organizational context. Existing CI/CD platforms can enforce policies and approvals. Independent security tools can examine generated code. Jira, GitHub, ServiceNow or another platform can remain the official system of record.

An organization might deliberately use several models across the lifecycle. One agent could create a specification, another could generate the code and a third could review it. Deterministic tools could enforce testing, security and deployment requirements. Using independently developed agents for generation and review might also reduce the risks associated with asking a model to grade its own work.

Anthropic wrote the playbook in Claude’s language, but the game it describes belongs to the entire software industry.

Most Organizations Are Not There Yet

Our Software Lifecycle Engineering Decision Maker research illustrates how far the industry remains from Anthropic’s vision.

AI use is already substantial during the earlier stages of development. Among respondents, 40.17% reported using AI for code generation, 37.66% for code review, 28.01% for testing and 26.58% for architecture and design.

Adoption falls sharply as software moves closer to production. Only 13.23% use AI in CI/CD, 12.40% use it for security scanning and just 6.20% use it for deployment decisions. Only 5.84% reported autonomous end-to-end software development.

At the same time, 42.43% identified inadequate governance as an AI adoption blocker, while 75.2% said their organizations had experienced at least one software incident during the preceding 12 months.

The pattern is hard to miss. Most organizations are applying AI where code is created, but far fewer are extending it into the systems responsible for safely delivering and operating that code.

They are accelerating one part of the factory without rebuilding the assembly line around it.

Anthropic’s playbook provides a potential bridge between today’s AI-assisted development and a genuinely AI-native lifecycle. It also makes clear that installing a coding assistant is the beginning of the transformation, not the end.

AI Does Not Replace DevOps

Much of Anthropic’s prescription should sound familiar to anyone who has spent time around DevOps.

Reduce handoffs. Automate repeatable work. Shift testing and security earlier. Keep changes traceable. Create rapid feedback loops. Treat infrastructure and policy as code. Connect development with production operations. Learn continuously from incidents.

AI does not invalidate DevOps. It makes the unfinished work of DevOps more urgent.

Organizations that still depend on manual change boards, brittle tests, tribal knowledge and disconnected systems will not receive the full benefit of faster code generation. They may instead produce larger review queues, more under-tested code and additional production instability.

The AI-native SDLC may be less a replacement for DevOps than the force that finally requires organizations to finish the DevOps transformation they have discussed for years.

It also elevates platform engineering. Individual developers cannot independently create the controls, context and evidence required for agentic development. Platform teams must provide approved models, standardized environments, identity controls, repository instructions, testing frameworks, policy enforcement, observability, audit records and escalation paths.

The internal developer platform becomes the control plane for both human and agentic development. It determines what agents may access, what they may change, what evidence they must produce and when a human must intervene.

That raises a strategic question Anthropic’s playbook cannot answer by itself: Who will ultimately control the AI-native SDLC? Will it be the model providers, the established DevOps platforms, internal platform-engineering teams or some combination of all three?

There are other questions to resolve. Can an agent reliably review work generated by the same model? Who maintains the institutional knowledge provided to agents? What happens when policies conflict? Can repository artifacts satisfy every regulatory requirement? How much human approval can remain before human attention becomes the bottleneck again?

These are not reasons to dismiss Anthropic’s proposal. They are the next set of problems the industry must solve.

Credit Where It Is Due

Anthropic deserves kudos for publishing this playbook.

The company helped create the technology forcing the SDLC to evolve. It has now provided a thoughtful explanation of the consequences and a practical starting point for addressing them. That advances the conversation beyond code completion, developer productivity and arguments about which model performs best on a benchmark.

Anthropic has not delivered the final blueprint for the AI-native SDLC. No single vendor can. Organizations will use different models, agents, platforms, systems of record and governance mechanisms.

But the larger message is right. The next challenge is not merely teaching AI to produce still more code. It is rebuilding the software delivery system so that planning, testing, security, governance, deployment and operations can keep up.

The horse has told us that the carriage is moving too slowly. Now the software industry must decide how to rebuild it.