intent.md Reshapes the SDLC: Anthropic Releases the AI-Native Development Playbook

The Core Logic Behind AI Restructuring the Software Development Lifecycle

Anthropid's Boris Cherny (creator of Claude Code) and his team have published The AI-Native SDLC Playbook, revealing a key insight: writing code is no longer the bottleneck — process design is.

The traditional Software Development Lifecycle (SDLC) consists of six phases: planning, design, build, test, deploy, and maintain. The build phase has historically taken the longest. But the introduction of AI Agents has doubled build efficiency, and the real breakthrough lies in using Agents to optimize all the other phases.

intent.md: The Critical File Bridging Human Intent and Machine Execution

A Revolutionary Shift in the Planning Phase

Traditional planning relies on requirements meetings, PRD documents, and repeated back-and-forth. In the AI-native workflow, Anthropic proposes generating an intent.md file through an Agent-led interview process:

1. The Agent conducts a structured interview with the user, asking questions until it fully understands the requirement or bug scenario
2. The user dumps domain knowledge and contextual information
3. The Agent generates a human-readable, machine-executable intent.md file

This process can leverage tools like Cursor's requirements discovery, Matt Pocock's grill me, or custom-built discovery skills. The key is letting the Agent surface implicit requirements through structured questioning.

Who Can Create an Intent File

The creator of an intent.md is called an "originator" — and this role isn't limited to technical staff:

• Customers submitting bug reports
• Product managers proposing feature ideas
• Developers logging improvement notes

All intent files are stored in the project's intent/ folder and reviewed and prioritized by the product owner. Some teams use Agents to automatically classify and rank them, tagging items by frontend/backend, task size, urgency, and more.

The Artifact Chain: The Complete Path from intent to spec to plan

Anthropid introduces the concept of an "artifact chain" — starting from intent.md, the system sequentially generates spec.md, plan.md, and other documents, building a complete and traceable development context.

Auto-Generating Technical Specification Documents

Once an intent is signed off, a Hook automatically triggers the spec generation workflow. Anthropic's prompt template:

Read the attached intent.md and generate a requirements and design specification. Apply available skills for planning, adhere to brand guidelines, and fully document the specification in spec.md.

Spec generation can use Cursor/Claude Code's native plan mode, or you can create custom skills tailored to your team's standards. The key is ensuring the generation process follows your organization's style guides and best practices.

A Self-Contained, Comprehensive Plan Document

Once development begins, engineers feed the intent and spec into an Agent to generate a plan.md file. A high-quality plan.md should include:

• A list of files to be modified
• A work order or task checklist
• Risks and constraints
• Success criteria and validation checkpoints

The core principle: plan.md should be self-contained and complete — an engineer should be able to implement the change based on it alone, without reading the intent or spec. This is because different Agents and sub-Agents handle different phases and require full context documents rather than relying on conversation history.

The Build Phase: Parallelization and Autonomous Execution in Practice

Auto Mode and Permission Controls

Anthropid recommends enabling Auto mode during the build phase to maximize speed, but only after establishing a solid permissions policy:

• Lock down the set of tools the Agent can access
• Restrict which web resources and package managers can be referenced
• Configure fine-grained permissions in Cursor/Claude

Once the environment is sufficiently safe, Agents can operate with greater autonomy and less human intervention.

Git Worktrees for Parallel Development

The team recommends using Git worktree functionality, which allows multiple Agents to work on different branches simultaneously. Good Agent frameworks automatically decompose a plan into independent tasks and execute parallelizable subtasks concurrently.

Hooks for Process Compliance

Multiple Hooks can be configured during the build phase:

• Automatically update plan.md after an implementation is complete
• Prevent Agents from modifying sensitive folders
• Block unapproved dependency upgrades

These Hooks are the key mechanism for keeping the workflow both autonomous and compliant.

Testing and Deployment: From Reactive Response to Proactive Validation

Agent-Driven Comprehensive Testing

In traditional SDLC, testing is often the bottleneck — developers finish a feature and then wait for QA to schedule a review, resulting in long feedback cycles. The AI SDLC goal is to let Agents complete as much testing as possible before human review:

1. Unit tests: Agents automatically write test cases and verify they pass
2. Linting: Run deterministic code style checks
3. End-to-end tests: Use Playwright, TestSprite, or Cursor Browser for UI testing and screenshots
4. Build verification: Ensure the project compiles successfully with no errors

Cursor's Cloud Agent can automatically spin up servers, test the software, and generate screen recordings, dramatically reducing the burden on human reviewers.

Continuous Evaluation Mechanisms

Anthropid recommends applying evals to skill changes or model upgrades:

• Collect around 20 historical issues and their expected outcomes
• Run test cases in the CI pipeline
• Detect whether new models or skills cause SDLC performance regressions

Automated Code Review Workflow

After an Agent creates a Pull Request, another Claude instance automatically steps in to review it:

• Checks code against security policies and coding standards
• Generates review comments asynchronously
• Decides whether to approve based on agents.md, skills.md, and Hook policies

You can configure release gates that require approval from specific individuals or the satisfaction of specific conditions before merging into the main branch.

The Maintenance Phase: From Reactive Response to Proactive Diagnosis

Traditional maintenance is reactive — waking up to alerts in the middle of the night or watching tickets pile up unaddressed. In the AI-native SDLC, maintenance becomes proactive and asynchronous:

1. Automatic triggering: Service anomalies, new tickets, Slack messages, or scheduled jobs trigger Claude
2. Autonomous diagnosis: The Agent analyzes logs, metrics, and error messages
3. Intent generation: Claude automatically creates an intent.md based on its diagnosis
4. Solution delivery: Provides a fix recommendation or an automated fix before an engineer ever gets involved

For example, when API request rates spike abnormally or a page goes down, the Agent can complete a diagnosis and draft a solution before you even open your laptop.

Governance and Version Control: Enterprise-Level Best Practices

For enterprise teams, governance mechanisms are critical:

• Version tracking: Save all versions of intent, spec, and plan files along with who modified them
• Metrics monitoring: Track DORA metrics to quantify AI's impact on engineering efficiency
• Tiered permissions: Distinguish between low-risk (single file edits), medium-risk (installing dependencies), and high-risk (production changes) operations

Anthropid emphasizes that these practices help enterprises demonstrate the real value of AI and provide data to support process improvement.

Implementation Recommendations: Adapt Flexibly to Your Team's Situation

While Anthropic provides a complete methodology, real-world application requires adaptation:

• Small teams: Start with a simple plan mode and gradually introduce intent and spec
• Mature teams: You may already use tools like Superpowers or be.mad — there's no need to tear everything down
• Architecture choices: From simple loops to graph engineering, large orchestration systems, or even "civilization engineering" — each has its applicable scenarios

The key is to standardize your process and keep it stable, so that teams, Agents, and skill libraries can grow together within a unified workflow.

Redefining the Human Role

The goal of the AI SDLC is not to eliminate humans entirely, but to reduce the time humans spend at each stage while preserving critical review checkpoints. Depending on the project's criticality and the team's maturity, you can choose:

• High human involvement (review at every step)
• Hybrid mode (human review at key checkpoints)
• Highly automated (final review only, suitable for low-risk projects)

Rob mentioned in the video that he helps teams make the transition to AI-native development through his Switch Dimension course, emphasizing that there is no one-size-fits-all solution — strategy needs to be adjusted based on real-world circumstances.