Eric Tech · Published 2026-09-20

Claude Code: The Complete AI-Native SDLC Guide

privateReview: unreviewedConfidence: high
sdlcclaudeagentstestingciagentic-sdlcclaude-codeartifact-chainevals-in-ciguardrail-hooksSelf-verificationcontext-engineeringai-pr-review
Open on YouTube ↗

Summary

Overview

  • Speaker: Eric
  • Channel: Eric Tech
  • Main topic: AI-Native Software Development Lifecycle (SDLC) using Claude Code and Anthropic Playbook
  • Purpose: To guide viewers on how to apply the AI-Native SDLC Playbook in their own software development lifecycle using Claude Code, building apps with best practices and advanced agentic workflows. This video breaks down Anthropic's newly released 'AI-Native SDLC Playbook' for Claude Code, explaining how to transform every stage of software development—planning, designing, building, testing, deployment, and maintenance—using AI agents and modern development practices.

Topic Map

Introduction to AI-Native SDLC

  • Explanation: Explains what SDLC means and introduces Anthropic's AI-Native SDLC Playbook released by Boris Cherny and the Anthropic team.
  • Key claims:
    • Organizations write code at unprecedented speed with AI, but processes around code haven't changed.
    • Traditional SDLC runs in slow human loops; AI-native SDLC operates in hours, not weeks, with humans directing and governing.
  • Examples:
    • Claude Academy courses containing 14 lessons on AI-native SDLC.
  • Terminology:
    • SDLC
    • AI-Native SDLC Playbook
    • Claude Code
  • Why it matters: Understanding the shift from traditional human-speed development to agent-speed development.

Planning Stage (Intent)

  • Explanation: How planning works in AI-native SDLC using intent files and interactive interviews rather than committees and manual requirements gathering.
  • Key claims:
    • AI can interview developers via skills like 'grill-me' to gather requirements.
    • Conversations and decisions are captured in an intent.md file which is human-readable and machine-actionable.
  • Examples:
    • Claims status self-service intent.md template.
  • Terminology:
    • intent.md
    • grill-me skill
    • artifact chain
  • Why it matters: Streamlining requirement gathering into structured, machine-readable intent documents.

Design Stage (Spec)

  • Explanation: Converting intent into technical specs (spec.md).
  • Key claims:
    • intent.md defines the 'why', while spec.md defines the 'what', technical requirements, and expected behavior.
  • Examples:
    • Using prompts to instruct Claude to read intent.md and produce a requirements and design spec.
  • Terminology:
    • spec.md
    • design spec
  • Why it matters: Translating high-level intent into rigorous technical specifications for AI agents.

Building Stage (Plan)

  • Explanation: Converting intent and specs into an actionable implementation plan (plan.md).
  • Key claims:
    • plan.md takes intent and spec and breaks them into actionable tasks for AI agents to follow step-by-step or in parallel.
  • Examples:
    • Writing plan.md files using skills like writing-plans or superpowers.
  • Terminology:
    • plan.md
    • implementation plan
  • Why it matters: Structuring complex development tasks into manageable agent instructions.

Testing Stage & Feedback Loop

  • Explanation: Test-driven development (TDD), self-verification, and giving Claude feedback loops.
  • Key claims:
    • Always give Claude a way to verify its own work (tests, builds, lints, screenshot diffs) before an engineer sees it.
    • Verifying your work requires passing test, lint, and build checks.
  • Examples:
    • make test, make lint, make build commands ensuring zero failures before reporting done.
  • Terminology:
    • TDD
    • feedback loop
    • verifier subagent
  • Why it matters: Ensuring AI agents catch and fix their own errors before human review.

Continuous Evals in CI

  • Explanation: Running evaluation suites in CI to test agent performance after model swaps or rule changes.
  • Key claims:
    • Evals are the AI-native equivalent of stage-gate QA.
    • Collect 20 to 50 real tasks and run them as an eval suite in GitHub Actions.
  • Examples:
    • agent-evals.yml GitHub workflow configuration.
  • Terminology:
    • evals
    • CI/CD
    • regression test
  • Why it matters: Preventing model regressions and ensuring consistent agent output quality.

AI in PR Review Loop & Approval Gates

  • Explanation: How AI reviews pull requests and how hooks act as approval gates before production.
  • Key claims:
    • Claude reviews incoming PRs against organization policies and runs three passes (bugs, security, compliance).
    • Hooks act as guardrails to block unauthorized actions like editing certain files or touching production credentials.
  • Examples:
    • REVIEW.md file defining review instructions and pass criteria.
  • Terminology:
    • REVIEW.md
    • hooks
    • approval gates
  • Why it matters: Maintaining strict governance and safety over autonomous AI code changes.

CI/CD Integration & Maintenance

  • Explanation: Integrating Claude into deployment pipelines and maintaining systems via metric-driven loops.
  • Key claims:
    • Before deployment, Claude reads build logs and submits PRs for fixes; after deployment, it calls status tools to check releases.
    • Maintenance involves monitoring metrics and looping back to intent.md when issues arise.
  • Examples:
    • bands.yaml monitoring CI test failure rates over 30 days.
  • Terminology:
    • deployment
    • rollback
    • metrics
  • Why it matters: Closing the loop between production metrics and continuous improvement.

Key Points

Shift from Human Speed to Agent Speed

  • Explanation: Traditional SDLC is bottlenecked by manual building and planning; AI agents compress execution time drastically.
  • Evidence: Diagrams comparing traditional linear lines vs. AI-native fast loops.
  • Practical implication: Developers must focus on intent definition, review, and governance rather than boilerplate writing.

The Artifact Chain

  • Explanation: Development progresses systematically from intent.md to spec.md to plan.md, creating a clear audit trail and context for agents.
  • Evidence: Flowcharts showing document handoffs between stages.
  • Practical implication: Eliminates ambiguity in prompt engineering by maintaining structured Markdown files.

Self-Verification and TDD

  • Explanation: Agents must write tests first and use automated lint, test, and build commands to verify their own code before human intervention.
  • Evidence: Claude configuration snippets requiring all three checks to pass before reporting done.
  • Practical implication: Reduces human review overhead and catches bugs earlier in the cycle.

Frameworks, Models & Processes

AI-Native SDLC Lifecycle Loop

  • How it works: A continuous loop through Plan, Design, Build, Test, Deploy, and Maintain driven by Claude agents.
  • Components:
    • Plan (intent.md)
    • Design (spec.md)
    • Build (plan.md)
    • Test (TDD / Evals)
    • Deploy (CI/CD + Hooks)
    • Maintain (Metrics / bands.yaml)
  • When to use: When building applications using Claude Code and agentic workflows.

Examples & Case Studies

Creating a claims status self-service app intent document

  • Illustrates: How to capture user problems, proposed outcomes, affected users, and constraints in intent.md
  • Lesson: Structured markdown files provide clear intent for AI agents.

Setting up GitHub Actions eval workflows

  • Illustrates: Automating agent regression testing after model swaps
  • Lesson: Continuous evals ensure that updates to prompts or models do not break existing agent capabilities.

Actionable Takeaways

  • Immediate:
    • Adopt intent.md and spec.md patterns for project planning.
    • Implement self-verification checks (test, lint, build) for AI coding sessions.
    • Use hooks as approval gates to protect production environments.
  • Strategic:
    • Transition from human-speed coding to agent-speed SDLC governance.
    • Establish continuous evaluation pipelines for AI agent skills.
  • Questions to investigate:
    • How to integrate custom enterprise security policies into Claude Code hooks?
    • What is the optimal size for an eval test suite in CI?

Claims Worth Verifying

  • Claude Code and Anthropic team released the AI-Native SDLC Playbook (factual)
  • Evals using 20 to 50 real tasks can effectively catch regression when swapping AI models (best practice)

Notable Quotes

"Organizations have started using AI to write code at a speed unthinkable one year ago, yet the processes around the code haven't changed at the same pace." (at 0:07) "Always give Claude a way to verify its own work, whether tests, a build, or a screenshot diff." (at 15:21)

Compressed Summary

  • AI-native SDLC transforms traditional slow development loops into fast agentic loops.
  • Development follows an artifact chain from intent.md to spec.md to plan.md.
  • Agents must self-verify via test, lint, and build checks before reporting task completion.
  • Continuous evals in CI and hooks as approval gates ensure safety and prevent regression.
  • Keywords: sdlc, claude, agents, testing, ci
  • Core insight: AI-native software development replaces manual human bottlenecks with structured markdown intent files, self-verifying agent loops, and automated continuous evaluations.

Core insights

6
Architecturemedium noveltystrong evidence

The development lifecycle is driven by an ordered chain of versioned Markdown artifacts (intent.md → spec.md → plan.md) where each file has a distinct semantic role: intent.md = why, spec.md = what/expected behavior, plan.md = decomposed actionable tasks. This makes agent context an auditable repository artifact rather than ephemeral prompt text.

Why it matters

It relocates the grounding context for agents out of chat history and into reviewable, diffable files, which changes how context is versioned, reviewed, and rolled forward between agent runs.

Generalization

Any long-horizon agent workflow (not just coding) can be decomposed into chained, human-readable artifacts with separated why/what/how responsibilities, giving structured context handoff and an audit trail.

Conversations and decisions are captured in an `intent.md` file which is human-readable and machine-actionable.
Open source video
intent.md defines the 'why', while spec.md defines the 'what', technical requirements, and expected behavior.
Open source video
plan.md takes intent and spec and breaks them into actionable tasks for AI agents to follow step-by-step or in parallel.
Open source video
Mechanismmedium noveltystrong evidence

Self-verification is treated as a hard gate: the agent must have a machine-checkable way to verify its own work (tests, builds, lints, screenshot diffs) and pass test/lint/build with zero failures before it is allowed to report completion to a human.

Why it matters

Defining 'done' as passing an automated check rather than the agent's own assertion converts self-reported completion into an objectively falsifiable signal and reduces human review load.

Generalization

Agent harnesses should terminate on externally verifiable criteria (a build/test/lint exit contract) rather than model self-assertion; the verification surface is a first-class part of the runtime design.

Always give Claude a way to verify its own work (tests, builds, lints, screenshot diffs) before an engineer sees it.
Open source video
make test, make lint, make build commands ensuring zero failures before reporting done.
Open source video
Practicemedium noveltymoderate evidence

Evaluation suites are run in CI as the AI-native equivalent of stage-gate QA: a fixed set of 20 to 50 real tasks executed in GitHub Actions, triggered specifically after model swaps or rule changes.

Why it matters

It treats a model version change like a dependency upgrade, requiring regression evidence before accepting it, which is the operational mechanism for catching silent behavioral drift.

Generalization

Any system with a nondeterministic model in the loop needs a captured real-task suite wired into CI to gate model/prompt/rule changes, mirroring how software gates library upgrades.

Evals are the AI-native equivalent of stage-gate QA.
Open source video
Collect 20 to 50 real tasks and run them as an eval suite in GitHub Actions.
Open source video
agent-evals.yml GitHub workflow configuration.
Open source video
Architecturemedium noveltymoderate evidence

Policy enforcement is moved out of the model's discretion into deterministic hooks that act as approval gates, blocking specific actions such as editing certain files or touching production credentials.

Why it matters

It separates governance (enforced by the runtime, not by instructions the model may ignore) from the model's reasoning, giving a hard boundary that cannot be talked around by prompt content.

Generalization

Safety-critical constraints on autonomous agents should be implemented as out-of-band runtime interception points, while in-model prompts handle softer behavioral guidance.

Hooks act as guardrails to block unauthorized actions like editing certain files or touching production credentials.
Open source video
Mental Modelmedium noveltymoderate evidence

The maintenance feedback loop closes back onto requirements, not just code: production metrics are monitored and issues loop back to intent.md, with artifacts like bands.yaml tracking CI test failure rates over 30 days.

Why it matters

It makes requirements a living, continuously revised artifact and treats production telemetry as an input to re-planning, rather than a post-hoc bug-fix pipeline.

Generalization

Closed-loop agent systems should route operational telemetry back to the earliest specification artifact so re-planning is driven by observed behavior, not only by defect reports.

Maintenance involves monitoring metrics and looping back to intent.md when issues arise.
Open source video
bands.yaml monitoring CI test failure rates over 30 days.
Open source video
Mechanismmedium noveltymoderate evidence

Automated PR review is decomposed into three independent passes (bugs, security, compliance) with the review instructions and pass criteria externalized into a REVIEW.md file.

Why it matters

Separating review concerns into distinct passes and versioning the rubric in-repo makes AI review criteria inspectable and tunable independently of the reviewer implementation.

Generalization

Review/grading agents should use decomposed, concern-specific passes with externally stored rubrics rather than one monolithic prompt, so each criterion can be tuned and audited.

Claude reviews incoming PRs against organization policies and runs three passes (bugs, security, compliance).
Open source video
REVIEW.md file defining review instructions and pass criteria.
Open source video

Deep dives

5

Staleness and invalidation in a chained artifact pipeline (intent.md → spec.md → plan.md)

Research question

When intent.md changes mid-flight, how should downstream spec.md and plan.md be invalidated, regenerated, or reconciled, and what explicit staleness metadata minimizes silent drift between artifacts?

Why

The artifact chain only works as a context contract if downstream files can be proven consistent with the intent they derive from; without an invalidation scheme, agents execute against superseded specs and the audit trail becomes misleading rather than authoritative.

Maintenance involves monitoring metrics and looping back to intent.md when issues arise.
Open source video
plan.md takes intent and spec and breaks them into actionable tasks for AI agents to follow step-by-step or in parallel.
Open source video
intent.md defines the 'why', while spec.md defines the 'what', technical requirements, and expected behavior.
Open source video
Source video

Externally verifiable termination contracts for autonomous coding agents

Research question

Does enforcing a machine-checkable exit contract (test/lint/build with zero failures) before an agent may report completion measurably reduce human review defects and rework compared with agents that self-assess completion?

Why

If 'done' is defined by an automated gate rather than model assertion, completion becomes falsifiable and review load becomes a measurable dependent variable instead of an anecdote about agent quality.

Always give Claude a way to verify its own work (tests, builds, lints, screenshot diffs) before an engineer sees it.
Open source video
Verifying your work requires passing test, lint, and build checks.
Open source video
Source video

Minimum viable eval-suite size and pass thresholds as a CI stage gate

Research question

What suite size and pass-rate threshold, for a given task-diversity profile, reliably detects regressions introduced by model swaps or rule changes before they reach production?

Why

A 20-50 task suite is named as the stage gate but no acceptance bar or sensitivity analysis is given, so operators cannot distinguish a meaningful gate from a formality that yields false confidence about unmodeled cases.

Evals are the AI-native equivalent of stage-gate QA.
Open source video
Collect 20 to 50 real tasks and run them as an eval suite in GitHub Actions.
Open source video
agent-evals.yml GitHub workflow configuration.
Open source video
Source video

Bypass surface of enumerated hook guardrails

Research question

Against an agent operating under a block-list of hook-enforced actions, what fraction of unsafe behaviors are caught, and what novel or unenumerated actions escape the guardrail?

Why

Hooks convert governance from model discretion into runtime interception, but the guarantee is bounded by the enumeration itself; quantifying bypass surface determines whether hooks are a real safety boundary or only a speed bump.

Hooks act as guardrails to block unauthorized actions like editing certain files or touching production credentials.
Open source video
Source video

Conflict arbitration among decomposed review passes (bugs, security, compliance)

Research question

When independent review passes disagree or when a REVIEW.md rubric is wrong, how should disagreements be arbitrated and how should rubric quality itself be validated?

Why

Decomposed passes with an in-repo rubric are only useful if rubric defects and inter-pass conflicts are detectable; otherwise three passes create three places for silent mis-grading.

Claude reviews incoming PRs against organization policies and runs three passes (bugs, security, compliance).
Open source video
REVIEW.md file defining review instructions and pass criteria.
Open source video
Source video

Article ideas

4

Your Agent's Context Is a Repository Artifact, Not a Chat Log

Grounding context for long-horizon agents should live in versioned, diffable, stage-scoped files with separated why/what/how responsibilities, because chat history cannot be reviewed, rolled forward, or audited the way an intent/spec/plan chain can.

Angle

Trace how relocating context from prompt text into repository artifacts changes review workflows, staleness handling, and the contract boundary between each stage.

Source video

Stop Asking the Model If It's Done: External Termination Contracts for Agents

Agent completion should be defined by externally checkable exit criteria, not model self-assertion, because a verification surface is a runtime design decision that determines how much human review an agent can remove.

Angle

Argue that self-reported completion is unfalsifiable and show what changes when test/lint/build gates become the only path to a 'done' signal.

Source video

Governance You Can't Prompt Away: Moving Policy from Model Discretion to Runtime Interception

Safety-critical constraints belong in deterministic interception points rather than instructions the model may disregard, accepting that block-lists only cover enumerated actions and must be treated as a bounded, red-teamed surface.

Angle

Contrast prompt-resident policy with hook-enforced policy and be explicit about the residual bypass surface.

Source video

The 20-Task Stage Gate: Why Small Eval Suites Are Both Indispensable and Insufficient

Treating a model swap like a dependency upgrade is the correct operational instinct, but a 20-50 task suite needs an explicit pass bar and diversity argument or it becomes ritual evidence rather than regression detection.

Angle

Frame eval suites as deployment gates and interrogate what size and threshold make the gate meaningful.

Source video

Project ideas

4

Artifact-Chain Linter with Staleness Provenance

movement-lab

Adding explicit provenance and staleness markers to intent.md → spec.md → plan.md reduces the rate at which agents execute against superseded requirements compared with an unmarked chain.

Proof of concept

Build a CLI/CI check that hashes and records the parent-artifact revision each downstream file was generated from, flags stale descendants, and blocks plan execution when spec is stale relative to intent.

Measurement

Count of agent runs executed against stale downstream artifacts, and time-to-detect intent drift, in a seeded repository where intent is mutated mid-flight.

Source video

Exit-Contract Harness: Zero-Failure Completion Gate

gatehouse

Binding agent completion to a zero-failure test/lint/build contract reduces human review defects and rework per merged change versus agents that self-report completion.

Proof of concept

Wrap an agent runner so the done signal is emitted only by the exit codes of test/lint/build commands, and A/B against a self-assessment baseline on the same task backlog.

Measurement

Human review defects per merged PR, rework minutes per task, and false-completion rate (tasks reported done that fail the contract).

Source video

Eval-Suite Sensitivity Calibrator

beyond-evals

Regression-detection sensitivity scales with task diversity rather than raw task count, so suites below a diversity threshold fail to catch model-swap regressions even at 50 tasks.

Proof of concept

Inject known regressions into a fixed set of 20-50 real tasks, vary suite size and diversity coverage, and run the suite via a GitHub Actions workflow on both baseline and regressed model configurations.

Measurement

Detection rate and false-negative rate per injected regression as a function of suite size and diversity coverage; minimum viable suite configuration.

Source video

Hook Bypass Red-Team Rig

gatehouse

An enumerated block-list guardrail leaves a measurable bypass surface, and red-team-derived action classes can be converted into new block rules that reduce that surface without blocking legitimate work.

Proof of concept

Red-team an agent under a hook guardrail that blocks file edits and production credential access, enumerate unsafe actions not on the list, then extend the rule set and re-run.

Measurement

Number and severity of unsafe actions executed per red-team episode before and after rule extension; false-block rate on legitimate tasks.

Source video

Architectural implications

3

Governance constraints are implemented as deterministic hooks rather than as prompt instructions.

Before

Safety rules lived as instructions in the model's system prompt or context, enforced at the model's discretion.

After

Hooks intercept and block specific actions (file edits, production credential access) at the runtime boundary.

Consequence

Policy becomes non-negotiable and testable independently of model behavior, but requires maintaining interception logic and anticipating which actions to block.

Source video

Agent grounding context is externalized into chained version-controlled files (intent.md, spec.md, plan.md, REVIEW.md) rather than accumulated in conversation state.

Before

Requirements and plans lived in chat history or tribal knowledge, and were re-explained per session.

After

Each stage reads a prior stage's artifact, forming an explicit, diffable handoff chain.

Consequence

Context becomes reviewable and reproducible, and stage boundaries become contract boundaries between agents/humans.

Source video

Model and rule changes are gated by a real-task eval suite in CI.

Before

Model swaps or prompt/rule changes were validated manually or not at all.

After

A fixed 20-50 task suite runs in GitHub Actions as a stage gate before accepting change.

Consequence

Shifts the operational definition of reliability from anecdote to repeatable regression evidence, at the cost of building and maintaining task datasets.

Source video

Tradeoffs and failure modes

4

Fast agent loops vs human governance

Benefit

AI-native SDLC compresses execution from weeks to hours, freeing humans to focus on intent, review, and governance.

Cost or risk

Humans directing and governing at agent speed requires review and approval capacity that may not scale to match the loop speed.

Traditional SDLC runs in slow human loops; AI-native SDLC operates in hours, not weeks, with humans directing and governing.
Open source video
Source video

Eval suite as regression gate

Benefit

Catches agent regressions after model swaps or rule changes before they reach production.

Cost or risk

A suite of only 20 to 50 real tasks may not represent production task diversity, so passing it can give false confidence about unmodeled cases.

Collect 20 to 50 real tasks and run them as an eval suite in GitHub Actions.
Open source video
Source video

Self-verification via test/lint/build

Benefit

Agents catch and fix their own errors before human review, cutting review overhead.

Cost or risk

Correctness of the gate is bounded by the coverage and quality of the tests and checks the agent itself relies on.

Verifying your work requires passing test, lint, and build checks.
Open source video
Source video

Hooks as approval gates

Benefit

Blocks unauthorized actions such as editing certain files or touching production credentials.

Cost or risk

Hooks can only block anticipated actions; novel or unenumerated actions may bypass the guardrail until the rule set is extended.

Hooks act as guardrails to block unauthorized actions like editing certain files or touching production credentials.
Open source video
Source video

Open questions

4

Does the artifact chain (intent.md → spec.md → plan.md) hold up when requirements change mid-flight, and who reconciles stale artifacts?

Why unresolved

The summary shows maintenance looping back to intent.md but does not specify how downstream spec and plan files are invalidated or regenerated.

Research direction

Prototype an artifact-chain versioning scheme with explicit staleness/invalidations and measure how often downstream artifacts drift from intent.

Source video

What acceptance thresholds and pass criteria make the 20-50 task eval suite a meaningful stage gate?

Why unresolved

The summary names the mechanism and count but gives no pass-rate bar or statistical treatment.

Research direction

Run experiments on task-suite size vs regression-detection sensitivity to derive minimum viable eval set sizes.

Source video

How are review passes (bugs, security, compliance) arbitrated when they conflict, and how is pass criteria quality in REVIEW.md validated?

Why unresolved

The summary lists three passes and a REVIEW.md file but not conflict resolution or rubric validation.

Research direction

Build a multi-pass review harness and measure inter-pass disagreement rates and rubric sensitivity.

Source video

Do hooks meaningfully contain agent risk given they only block enumerated actions?

Why unresolved

The summary describes hooks blocking listed actions (certain files, production credentials) without discussing coverage of unenumerated behavior.

Research direction

Red-team an agent under hook guardrails to measure bypass surface for actions not on the block list.

Source video

Key claims

8
opinionVerification needed

Giving agents a self-verification mechanism (tests, builds, lints, screenshot diffs) before human review is a core requirement of AI-native development.

Evidence

Always give Claude a way to verify its own work (tests, builds, lints, screenshot diffs) before an engineer sees it.

Question

How much does enforced self-verification actually reduce human review defects and rework versus unverified agent output?

Source video
comparativeVerification needed

Traditional SDLC runs in slow human loops while AI-native SDLC operates in hours, not weeks.

Evidence

Traditional SDLC runs in slow human loops; AI-native SDLC operates in hours, not weeks, with humans directing and governing.

Question

What is the measured end-to-end cycle time reduction for comparable projects under an AI-native SDLC versus traditional SDLC?

Source video
causalVerification needed

Evals function as the AI-native equivalent of stage-gate QA, run in CI with 20 to 50 real tasks.

Evidence

Evals are the AI-native equivalent of stage-gate QA.

Question

Do CI eval suites of this size reliably detect model-swap regressions in production agent systems?

Source video
factualVerification needed

Hooks act as guardrails blocking unauthorized actions such as editing certain files or touching production credentials.

Evidence

Hooks act as guardrails to block unauthorized actions like editing certain files or touching production credentials.

Question

What fraction of unsafe agent actions can hooks block, and how are bypasses via unenumerated actions handled?

Source video
factualVerification needed

Claude reviews incoming PRs against organization policies using three passes (bugs, security, compliance) configured through REVIEW.md.

Evidence

Claude reviews incoming PRs against organization policies and runs three passes (bugs, security, compliance).

Question

What is the precision/recall of each AI review pass versus human reviewers on the same PR set?

Source video
comparativeVerification not requested

intent.md defines the 'why' while spec.md defines the 'what' and expected behavior.

Evidence

intent.md defines the 'why', while spec.md defines the 'what', technical requirements, and expected behavior.

Source video
factualVerification needed

plan.md decomposes intent and spec into actionable tasks that agents follow step-by-step or in parallel.

Evidence

plan.md takes intent and spec and breaks them into actionable tasks for AI agents to follow step-by-step or in parallel.

Question

Does explicit task decomposition in plan.md improve agent success rates versus unplanned execution?

Source video
causalVerification needed

Production metrics and CI failure monitoring (bands.yaml over 30 days) feed back into requirement artifacts to drive maintenance.

Evidence

Maintenance involves monitoring metrics and looping back to intent.md when issues arise.

Question

Does routing production telemetry back to intent.md measurably reduce recurrence of issues compared to standard bug-fix workflows?

Source video

Connections

5