The reconciled tactical execution behind the AI-Native SDLC: the exact skills, hooks, agents, and file names behind each stage, checked against Anthropic's published playbook.
The AI-Native SDLC is the what and why. This page is the how.
When the deliverable is itself an agentic system, the same pipeline runs in agentic mode (the ADLC). Each stage below carries a marked agentic block with what changes. Design and Test are where the modes fork in kind, so those two blocks are marked and carry their own detail.
Is the deliverable's runtime behavior fixed at build time, or decided at runtime? Asked once at Stage 0, recorded at Stage 1. These are the operating principles, repo structure, and execution patterns for agentic-mode engagements. They describe the shape of the work, not the specific tools used to do it. Tool choices belong in each project's context engine and change with the landscape.
Anthropic's playbook runs six stages: Plan → Design → Build → Test → Deploy → Maintain. Sparq splits the first stage into two gates, sold together as one commercial unit, the Evidence Sprint. This is the actual differentiator.
| Sparq stage | Anthropic stage | What Sparq adds |
|---|---|---|
| 0 · Intent Framing | Plan | Structured workshop (2–4 hrs) + strict inline assumption-tagging before intent.md exists |
| 1 · Evidence Gate | Plan | Required external-signal checkpoint (Promote/Iterate/Pivot/Stop) + tracker sync and merge on close |
| 2 · Design | Design | 1:1 |
| 3 · Build | Build | 1:1 |
| 4 · Test | Test | 1:1 |
| 5 · Deploy | Deploy | 1:1 |
| 6 · Maintain | Maintain | 1:1, plus product-analytics bands widened beyond Anthropic's infra-only example |
Commercially: Stages 0–1 together are the Evidence Sprint, the thing that used to be pitched as discovery, now scoped to roughly 2 weeks because the output is evidence and a costed Build decision, not a stack of workshop artifacts. Everything from Design onward tracks Anthropic's canonical mechanics closely.
A 2–4 hour structured workshop. 10 min silent assumption dump → failure premortem → domain walkthrough across Value / Usability / Feasibility / Viability / Operational → architecture exposure with engineering. The full procedure is on the New Discovery page. No untagged claims survive the file.
Meeting-transcription MCP (Whisper/Fathom/Recall.ai) for live capture, plus Miro/Mural/Slack MCP for stickies and threads.
Interactive elicitation: asks probing questions, rephrases claims as testable assertions.
Parses the transcript in real time and auto-tags into the 5 risk categories.
Red-teams the room on technical constraints and unstated dependencies.
Pre-commit. Rejects the commit if any claim lacks an [ASSUMPTION: Category] tag.
Agentic mode
Establish whether an agentic architecture is actually necessary. Surface business value, feasibility bounds, and the specific ways an autonomous system can fail that a conventional build never has to consider.
Silent dump across five lenses: Value, Usability, Feasibility, Viability, Operational.
Explicitly catalog risks related to dynamic reasoning, open-ended tool calling, and token explosion.
Tag every assertion in intent.md with: [VALIDATED], [DIRECTIONAL], [ASSUMPTION], or [AGENTIC-RISK]. These are an intent-tagging convention, distinct from model confidence markers.
Pull the highest-risk Value/Usability assumption. Frame a minimal external-facing slice. Attach it to a real client touchpoint; synthetic-only validation is disallowed without a logged exception. Record signal. Product + Delivery decide: Promote / Iterate / Pivot / Stop. On a Promote, close by merging cleared intent.md into /intent/, mapping scope blocks into the enterprise tracker, and defining hard boundary markers.
Evidence Work skills and the resulting evidence-of-signal live in a per-project repo.
Distinct from the narrow Evidence Slice. Where an Evidence Slice tests one assumption, a Vision Prototype is a holistic build, full breadth, selective depth, meant to show the client the future-state value, not validate a single risk. Optional per engagement, but when built, it sits alongside the Promote decision and the costed Build proposal.
Conversation Intelligence MCP (Gong/Zoom/Teams/Chorus) for signal capture; Enterprise Tracker MCP (Jira/Azure DevOps/ServiceNow) and a non-interactive Claude CI runner for the close.
Maps quotes to tagged assumptions, evaluates signal strength, and caps internal-only feedback at Directional confidence so it can't be mistaken for a real-occasion validation.
Pre-gate multi-persona simulation so live client time isn't burned on an obviously broken pitch.
Blocks the push to /intent/ unless an explicit decision tag and signature block are present.
Automates mapping between Markdown scope blocks and enterprise epic/story schemas.
GitHub Action that fires only when the intent.md frontmatter reads gate_status: cleared, instantiating Stage 2 (Design).
Agentic mode
Verify high-risk assumptions with minimal spend before committing to architecture. For agentic systems this gate carries more weight because architecture decisions (tool access, autonomy scope) are expensive to unwind once made.
Build a targeted slice or prototype touching the highest-risk assumption.
Multi-persona synthetic simulations with malformed prompts, indirect prompt injections, and edge-case tool parameters.
Connect to a real client touchpoint to collect empirical runtime telemetry. Internal-only signal caps at Directional confidence.
Explicit status: Promote, Iterate, Pivot, or Stop.
Compressed design session(s), Claude + core engineering leads. Enterprise skills injected into context. Architecture must satisfy the Evidence Gate's operational bounds without over-building beyond intent.md.
Figma MCP or repo-native design: design capability doesn't have to live in Figma. Where the capability is confidently prototype-driven, the design system is built directly in Claude Code / Cursor and lives in the repo, feeding spec.md without a Figma round-trip. Choose per project; both paths converge on the same artifact.
Organization-wide security compliance skill.
Brand compliance skill.
UX standards skill.
Agent behavioral guardrails skill.
Verifies spec.md has every required section (API specs, failure modes, data models) before the stage can transition.
Agentic modeWhere the modes fork
Design the system's runtime authority on purpose. This is where building an agent most clearly diverges from using one to build: the deliverable's own behavior has to be designed, bounded, and budgeted before implementation begins.
Map orchestrator patterns: prompt chaining, routing, parallelization, or orchestrator-worker. Default to deterministic workflows; escalate to autonomous agents only when genuinely required.
Map every task category to an explicit authorization level: Autonomous, Automated with Logging, HITL Approval Required, or Prohibited. This is a strategic decision made once per system.
Set CAPEX/OPEX budgets as a first-class design constraint alongside functional requirements. Ongoing inference cost is a constraint, not an afterthought.
Define MCP server boundaries. Every tool, legacy connection, and enterprise platform the agent touches is exposed via a standardized protocol. No ad-hoc network requests or direct database calls.
Git worktree isolation (cap 2–3 per engineer). Plan Mode first: Claude writes plan.md before touching source. Engineer accepts the plan, then code generation starts. Scoped Auto Mode execution within defined paths. Deliberately mimics Anthropic's own Build stage: plan mode, CLAUDE.md, subagents, hooks. Sparq-specific tooling layers on top.
Claude Code CLI, CLAUDE.md as the repo's context engine.
Spins up a fresh context window, runs the app, verifies behavior against plan.md.
Strips redundant abstraction from generated diffs.
For builds with embedded AI agents. evaluates prompt responses for safety/hallucination/tool-calling accuracy.
Intercepts file edits outside the scope defined in plan.md.
Agentic mode
Execute under Evaluation-Driven Development. Evaluations are the specification that governs whether the system is behaving correctly, not just whether it compiles.
The implementation path is drafted and human-accepted before any code generation begins. The plan is committed to plan.md in Git.
Isolate agent sessions across separate Git worktrees. Enforce a session cap per engineer to preserve review quality.
Draft evaluation scenarios in parallel with feature code, not after it. For a probabilistic system, the eval suite is part of the spec, not a downstream check on it.
Evaluate model outputs continuously during implementation for hallucination rate, formatting compliance, and tool-calling accuracy.
Agent self-verification (build, unit tests, visual regression) before submission. Non-interactive CI eval suite runs 20–50 task scenarios. Test files are read-only during bug-fix tasks; the agent must fix the code, never weaken the assertion.
Headless Playwright/Puppeteer MCP, .github/workflows/agent-evals.yml.
Blocks Edit/Write on tests/** during bug-fix tasks.
Blocks PR merge if task accuracy falls below the threshold.
Agentic modeWhere the modes fork
A probabilistic system can pass every functional test and still fail on tool selection or safety alignment. Those need their own verification.
Run evaluation suites across 20-50+ task scenarios on every relevant change.
If an eval fails, modify prompts, tool schemas, or context in CLAUDE.md. Never lower evaluation thresholds to reach a passing state.
All three axes must pass independently. Specific thresholds are set per project at Design.
Multi-pass PR review (Bugs → Security/PII → spec.md/plan.md compliance). Environment autonomy is tiered: Dev is fully autonomous, Staging requires a clean CI eval run plus automated review, Production requires named human Release Manager sign-off.
Claude Code PR Review Agent.
Multi-pass review writing findings to REVIEW.md.
allowManagedHooksOnly, permissions.deny, sandboxed shell, disableSideloadFlags, allowManagedMcpServersOnly, matching Anthropic's reference settings.json.
Its own named control rather than folded into managed settings generically.
Agentic mode
Transition a probabilistic system into production using tiered autonomy, not a single go/no-go review.
Security boundaries, alignment against spec, and functional correctness as separate review passes.
When the same mistake recurs, the repo context engine (CLAUDE.md) is updated so it does not recur again. The context engine is a governed artifact with its own feedback loop.
Statistical process control on bands.yaml (Western Electric rules). On a breach, a background agent diagnoses root cause and writes a fresh raw intent.md back into Stage 0's triage queue. closing the loop without a human starting it. On-call engineers can also tag Claude directly in incident threads. Every resolved bug becomes a permanent regression case in the Stage 4 eval suite.
Infra MCP (Datadog/Prometheus/New Relic) and Product Analytics MCP (PostHog/Mixpanel/Pendo/Zendesk) feeding the same sensor.
Background monitor triggering triage agents on band breaches.
Turns post-mortem logs into permanent regression tests.
ChatOps bot for on-call. Anthropic's actual Claude Tag product, not a generic ChatOps MCP Bot.
Agentic mode
Manage probabilistic drift over time. Monitor token consumption, capture real-world edge cases, and feed incidents back into intent triage automatically.
Monitor performance bands in bands.yaml: token consumption per task, reasoning drift, tool invocation error rates. Apply statistical control rules (e.g., Western Electric) against operational and product metrics.
When telemetry flags an anomaly, a background process diagnoses the incident, compiles a permanent regression case into the eval suite, and raises a new item in intent.md. The lifecycle is a loop.
Review governance quarterly against accumulated incident logs, drift data, and token expenditure reports.
An agentic-mode engagement requires seven infrastructure layers. The specific products filling each layer are project-level decisions maintained in the repo context engine, not prescribed here.
Repository-level code execution, plan drafting, worktree-isolated coding, tool invocation.
Multi-persona ideation, assumption dumps, raw intent tagging, client workshop facilitation.
Dynamic repository context, agent instructions, project boundaries, subcommands and skills. Lives in CLAUDE.md and the .claude/ directory.
Standardized server/client tool binding, database wrapping, legacy system isolation. Zero direct API access; all enterprise interactions routed through protocol-level boundaries.
Strategic reasoning, orchestrator planning, code generation. Model choice is a project decision, not an organizational one.
Non-deterministic assertion running, multi-scenario bench testing, pass/fail grading against 20-50+ scenarios. Keep datasets format-agnostic (.jsonl or .yaml) so they parse interchangeably across eval tools.
Token accounting, prompt cost tracking, runtime latency monitoring. Standardize on OpenTelemetry format so traces stream to any aggregator without modifying application code.
Dynamic session context, semantic retrieval. May be in-memory, protocol-served, or backed by a dedicated vector store depending on the system's context requirements.
Every agentic-mode deliverable repository conforms to this canonical layout. The context engine lives at the root. Stage artifacts sit alongside the code they govern. Eval datasets live next to the runners that execute them.
.
CLAUDE.md # Central Context Engine & System Instructions
.claude/
settings.json # Engine permissions, allowed tool boundaries
commands/ # Executable subcommands for development tasks
skills/ # Modular agent skills & domain workflows
intent.md # Stage 0 raw/tagged intent & premortem
spec.md # Stage 2 Technical architecture spec
autonomy-matrix.yaml # Stage 2 Autonomy Authorization Matrix
plan.md # Stage 3 Pre-execution implementation plan
REVIEW.md # Stage 5 Multi-pass safety & deployment review
bands.yaml # Stage 6 Operational drift & token tracking bands
evals/
datasets/ # 20-50+ core task scenarios (.jsonl / .yaml)
runners/ # Evaluation harness and grader logic
baselines/ # Historical benchmark pass rates
mcp-servers/ # Isolated MCP servers for system integration
src/ # Agent runtime logic & deterministic workflowsThe repo context engine (CLAUDE.md) is not a static config file. It has its own feedback loop: when an agent repeats a mistake, the correction goes into the context engine. PR review checks for staleness. It contains deterministic operational rules, build commands, and agent boundaries.
Agents never make ad-hoc network requests or direct database calls. Every enterprise interaction is routed through a protocol-level boundary (MCP server or equivalent) with input validation and autonomy checks enforced at the tool handler level.
Evaluation datasets are stored in standard formats (.jsonl or .yaml) so they parse interchangeably across any eval framework. The datasets are the durable asset; the runner is replaceable.
Standardize on open telemetry formats so traces stream to any aggregator without modifying application code. The observability layer is a slot, not a commitment.
Every place the two internal source documents disagreed and the call that was made.
| Stage | Conflict | Call made |
|---|---|---|
| 0 | assumption-extractor (A) vs intent-elicitor + assumption-linter (B) | Not a conflict. different functions. Keep all three. |
| 0 | Workshop length: 60–90 min (both docs) | Extended to 2–4 hrs to reflect real client kickoffs. |
| 1 | Skill named evidence-signal-check (A) vs evidence-synthesizer (B) | Canonicalize as evidence-synthesizer. |
| 1 | Separate confidence-decision.md (A) vs updated intent.md (B) | Canonicalize as intent.md updated in place, in the per-project repo. |
| 1 | Old Stage 2 (tracker sync) as its own numbered stage | Folded into Stage 1 as a closing action. automatic result of a Promote. |
| 2 | 4 compliance skills (A) vs 2 (B) | Keep A's full 4; add B's spec-compliance-linter on top. |
| 2 | Figma-only tooling (both docs) | Added repo-native design as an equal path, not a fallback. |
| 3/4 | Test-lock hook placed at Build (A) vs Test (B) | Move to Test. matches Anthropic's own placement. |
| 3 | prompt-evaluator.md present (A) vs absent (B) | Keep. relevant for embedded-AI-agent builds. |
| 5 | Bundled MDM settings (A) vs split config-engine + network hook (B) | Canonicalize on B's split, matches Anthropic's reference settings.json. |
| 6 | Generic ChatOps MCP Bot (B) | Rename to Claude Tag. it's a real, named Anthropic product. |
Anthropic treats CLAUDE.md with its own feedback loop: the correction goes into CLAUDE.md the second time an agent repeats a mistake, and PR review flags staleness. Neither internal doc gives CLAUDE.md this maintenance loop; it's currently just a context source.
Anthropic's Deploy stage includes scheduled, model-driven security scanning (Claude Security) running independently of PR review, a recurring scan, not point-in-time, with findings fed back as fresh intent.md. Sparq's only security coverage at Deploy is currently the PR review pass.
Anthropic's playbook defines explicit metrics per stage (e.g., time from intent.md commit to spec.md commit; first-pass CI success rate; time from band breach to intent.md in triage). Neither internal doc names how Sparq will measure whether the pipeline itself is working.