CC-402: Agentic SDLC Blueprint

Learning Guide

The traditional software development lifecycle was designed for human teams working at human speeds. Claude Code doesn't just accelerate existing workflows -- it enables a fundamentally different development lifecycle where AI agents participate in every phase: brainstorming, planning, implementation, testing, review, and deployment. This module presents the complete agentic SDLC blueprint, showing how each phase transforms when agents are first-class participants.

The AI-Native Development Lifecycle

An AI-native SDLC differs from a traditional one in several ways:

• Brainstorming is structured: Instead of unstructured whiteboard sessions, agents explore the solution space systematically, identifying tradeoffs, prior art, and edge cases.
• Planning produces executable specifications: Plans are precise enough that an agent can implement them without further clarification.
• Implementation is parallel: Multiple agents work simultaneously on independent components.
• Testing is continuous: Tests are written alongside (or before) implementation, not as an afterthought.
• Review is automated: Code review agents catch issues instantly, not hours or days after a PR is opened.
• Deployment is gated: Governance controls ensure quality and compliance before any code reaches production.

Test-Driven Development with Claude Code

TDD with Claude Code is more powerful than traditional TDD because the agent can maintain the full context of both the test expectations and the implementation simultaneously. The cycle becomes:

1. Write the test first. Describe what the code should do in test form. The agent writes failing tests that define the expected behavior, edge cases, and error handling.
2. Implement to pass. A second agent (or the same agent in a new phase) writes the minimum code needed to make the tests pass. The implementation is guided by concrete test cases, not abstract requirements.
3. Refactor with safety. With a comprehensive test suite in place, refactoring becomes safe. The agent can restructure code aggressively, confident that any regression will be caught immediately.
4. Expand coverage. After the initial implementation, a validation agent identifies untested paths and adds additional test cases. The goal is comprehensive coverage, not just happy-path coverage.

// TDD workflow with Claude Code
// Step 1: Test agent writes tests
describe('createUser', () => {
  it('should create a user with valid input', ...);
  it('should reject duplicate email', ...);
  it('should hash the password', ...);
  it('should enforce password complexity', ...);
  it('should return 400 for missing required fields', ...);
});

// Step 2: Implementation agent makes tests pass
// Step 3: Refactor agent improves structure
// Step 4: Coverage agent adds edge case tests

The Brainstorming-Planning-Implementation-Review Cycle

Phase 1: Brainstorming

Start with an open-ended prompt to an Explore agent: "Investigate how similar features are implemented in this codebase. What patterns exist? What constraints apply? What approaches are possible?" The agent produces a structured analysis that informs the planning phase.

Good brainstorming agents produce:

• A list of existing patterns the new feature should follow.
• Technical constraints (database schema limitations, API conventions, framework requirements).
• Alternative approaches with tradeoff analysis.
• Potential risks and edge cases.

Phase 2: Planning

A Plan agent receives the brainstorming output and produces a step-by-step implementation plan. Each step specifies the file to modify, the change to make, the acceptance criteria, and any dependencies on other steps. The plan is granular enough that an implementation agent can execute each step without ambiguity.

Store the plan in memory or a plan file. It serves as the contract between the planning and implementation phases.

Phase 3: Implementation

Implementation agents execute the plan. Independent steps run in parallel (via worktree isolation). Dependent steps run sequentially. Each agent focuses on a narrow scope, following the plan's specification precisely.

Phase 4: Review

Review agents examine all changes against multiple criteria:

• Correctness: Does the code do what the plan specifies?
• Security: Are inputs validated? Are queries parameterized? Are permissions checked?
• Convention: Does the code follow the project's established patterns?
• Coverage: Are all new code paths tested?
• Performance: Are there unbounded queries, missing indexes, or expensive operations?

Code Review Agents

Automated code review is one of the highest-value applications of Claude Code in an SDLC. A well-configured review agent can catch issues that human reviewers miss (they never get tired, never skim) while freeing human reviewers to focus on architecture and design decisions.

Effective code review agents need:

• Project context: The CLAUDE.md file with coding standards, the MEMORY.md with gotchas, and access to the codebase for pattern comparison.
• A review checklist: Specific things to verify, not just "review the code." SQL injection, missing auth checks, unbounded queries, missing error handling -- enumerate what matters.
• Structured output: Findings should include file path, line number, severity, description, and suggested fix. This makes review feedback actionable.

PR Automation

Claude Code integrates with git workflows to automate the PR lifecycle:

1. Branch creation: Agents create feature branches following naming conventions.
2. Commit hygiene: Each logical change is a separate commit with a descriptive message.
3. PR creation: The agent generates a PR with a summary, test plan, and description of changes.
4. Automated review: A review agent runs against the PR diff and posts findings as comments.
5. CI integration: The agent monitors CI results and fixes failures.

// PR automation flow
1. git checkout -b feature/user-notifications
2. [Implementation agents work]
3. git add [specific files]
4. git commit -m "Add notification endpoints and SSE stream"
5. gh pr create --title "Add user notifications" --body "..."
6. [Review agent posts review comments]
7. [Fix agent addresses review feedback]
8. [CI passes -> ready for merge]

Testing Strategies with Agents

Unit Testing

Agents excel at unit tests because they can generate comprehensive test matrices covering every code path, edge case, and error condition. The cost per test case is minimal, so you can achieve thorough coverage. Focus agent-generated unit tests on pure functions, API route handlers, and business logic.

Integration Testing

Integration tests verify that components work together correctly. Agents can set up test databases, seed data, exercise API endpoints, and verify responses. The key challenge is managing test state -- agents must ensure each test starts from a known state and cleans up after itself.

End-to-End Testing

E2E tests simulate real user workflows. With Playwright integration, Claude Code agents can navigate pages, fill forms, click buttons, and verify rendered output. E2E tests are expensive to write and maintain, so use agents to generate them for critical user flows rather than attempting comprehensive E2E coverage.

Quality Gates

Quality gates are automated checkpoints that code must pass before it can progress through the SDLC. Common gates include:

• Test coverage threshold: New code must meet a minimum coverage percentage (e.g., 80% lines, 70% branches).
• Zero lint errors: Code must pass linting with zero errors and zero warnings.
• Type safety: TypeScript strict mode with zero any types.
• Security scan: No known vulnerabilities in dependencies. No hardcoded secrets.
• Build success: Clean build with no warnings.
• Review approval: At least one review agent (and optionally one human) must approve.

The Superpowers Skill System as SDLC Framework

Skills in Claude Code are reusable templates for specific types of work. When organized into an SDLC framework, skills become the building blocks of your development process:

• brainstorm -- Explores solution space, produces options analysis.
• plan -- Creates step-by-step implementation plans.
• implement -- Executes plan steps with full code generation.
• test -- Writes and runs tests, reports coverage.
• review -- Examines changes against quality criteria.
• deploy -- Manages deployment with governance gates.

Each skill follows the seven-section template: frontmatter, when-to-use, context, process, output format, guardrails, and standalone mode. This standardization means every phase of your SDLC is documented, repeatable, and auditable.

Continuous Improvement Patterns

The agentic SDLC isn't static. It improves over time through several feedback mechanisms:

• Memory accumulation: Each session stores learnings, gotchas, and procedures. The agent gets smarter about your project with every session.
• Trajectory analysis: By reviewing what worked and what didn't, you can refine agent prompts, adjust skill definitions, and improve orchestration patterns.
• Coverage tracking: Monitor test coverage, code quality metrics, and review finding trends over time. Use this data to identify areas where the SDLC needs strengthening.
• Retrospective agents: Periodically dispatch an agent to analyze recent work and suggest process improvements.

For the complete overview of Claude Code's capabilities in the development lifecycle, see the Claude Code Overview documentation.