Sprint

Autonomous multi-agent development plugin for Claude Code. Spec-driven, iterative sprints with specialized agents.

Part of Agentic Forge — Claude Code plugins for autonomous AI workflows.

Stop prompting in circles. Sprint replaces ad-hoc AI coding with structured, specification-driven development. Write specs, run /sprint, and let coordinated agents handle the rest.

At its core, the /sprint command is a spec-driven, self-iterative state machine — it reads your specifications, orchestrates specialized agents through defined phases, and loops autonomously until the work is done or validation passes.

What is Sprint?

Sprint is a Claude Code plugin that turns Claude into an autonomous development team:

• Project Architect analyzes requirements, creates specifications, and coordinates work
• Implementation Agents (Python, Next.js, CI/CD, or any tech via allpurpose-agent) build features according to specs
• Testing Agents (QA, UI) validate the implementation
• Sprint Orchestrator — the self-iterative state machine that manages phases, handoffs, and convergence

You write specs → Agents implement → Tests validate → Iterate until done

The orchestrator drives the loop: specs in, working code out. No manual intervention required between phases.

Why It Works

Unlike single-shot prompting where context bloats and AI mistakes compound, Sprint uses a convergent multi-pass approach:

• Context preservation — Each agent receives only what it needs (specs, contract, relevant code). No wasted tokens on irrelevant history.
• Specs shrink, not grow — Completed work is removed from specs. Each iteration focuses only on what remains.
• Errors get erased — Working code stays untouched while issues get fixed. The signal-to-noise ratio improves with each pass.

Think of it like a diffusion process: the picture starts noisy, but with each iteration, the noise reduces and clarity emerges. By the final pass, only the solution remains.

Most sprints converge well before 5 iterations. If they don't, the system pauses and asks you what to do — adjust specs, continue iterating, or intervene manually. You stay in control.

Multi-Paradigm Design

Sprint is technology-agnostic. While it includes specialized agents for Python/FastAPI and Next.js, the system works with any tech stack:

• The allpurpose-agent adapts to Go, Rust, Flutter, Ruby, or any technology
• Create your own specialized agents for your preferred stack
• The architect automatically selects appropriate agents based on project structure

The Second Brain Effect

Two files give agents persistent memory across sprints — reducing token usage and keeping context focused:

.claude/project-goals.md — The business brain (you maintain this)

• Product vision and target audience
• Market analysis and differentiators
• Success metrics and constraints
• What you're building and why

The more detail you provide, the sharper and more shrewd the architect becomes.

.claude/project-map.md — The technical brain (architect maintains this)

• Project structure and architecture
• API surface and database schema
• Routes, components, environment variables
• Where everything lives and how it connects

Agents read this instead of scanning the entire codebase. The architect keeps it lean and current.

Installation

From Agentic Forge (recommended)

# Add the marketplace
/plugin marketplace add damienlaine/agentic-forge

# Install the plugin
/plugin install sprint

# Update to latest version
/plugin marketplace update damienlaine/agentic-forge

Local Development

# Clone this repo
git clone https://github.com/damienlaine/agentic-sprint.git

# Run Claude Code with the plugin
claude --plugin-dir ./agentic-sprint

Quick Start

1. Set Up Your Project

# Interactive project onboarding
/sprint:setup

This creates both Second Brain documents through guided questions:

• .claude/project-goals.md (business vision)
• .claude/project-map.md (technical architecture)

2. Create Your First Sprint

/sprint:new

This creates .claude/sprint/1/specs.md. Edit it with your requirements.

3. Run the Sprint

/sprint

Watch the agents work:

1. Architect analyzes specs and creates detailed specifications
2. Implementation agents build in parallel
3. Testing agents validate the work
4. Architect reviews and iterates (up to 5 times)
5. Sprint completes with a status summary

Commands

| Command | Description | |---------|-------------| | /sprint | Run the full sprint workflow | | /sprint:new | Create a new sprint | | /sprint:setup | Interactive project onboarding | | /sprint:test | Manual UI testing with live browser | | /sprint:generate-map | Generate project-map.md | | /sprint:clean | Remove old sprint directories |

Manual Testing Mode

Sometimes you want to explore the UI yourself rather than run automated tests. There are two ways:

Within a Sprint

Set UI Testing Mode: manual in your specs.md:

## Testing
- UI Testing: required
- UI Testing Mode: manual

When the architect requests UI testing:

1. Chrome opens a browser tab pointing to your app
2. You interact with the app manually — click around, test forms, explore edge cases
3. Console errors are monitored in real-time
4. Close the browser tab when you're done testing
5. Sprint continues with architect review of your session report

For Next.js projects, a diagnostics agent also monitors for compilation and hydration errors.

Standalone Testing

For quick testing outside of sprints:

/sprint:test

Opens a browser, monitors errors, and saves a report when you say "finish testing".

Reports feed into sprints: The report is saved to .claude/sprint/[N]/manual-test-report.md. When you run /sprint, the architect sees your observations and prioritizes fixing the issues you discovered.

Plugin Structure

sprint/
├── .claude-plugin/
│   └── plugin.json           # Plugin manifest
├── commands/                  # Slash commands
│   ├── sprint.md              # Main workflow (/sprint)
│   ├── new.md                 # Create sprints (/sprint:new)
│   ├── setup.md               # Project onboarding
│   ├── test.md                # Manual UI testing
│   ├── generate-map.md        # Generate project map
│   └── clean.md               # Cleanup utility
├── agents/                    # Agent definitions
│   ├── project-architect.md   # Coordinator agent
│   ├── python-dev.md          # Python/FastAPI backend
│   ├── nextjs-dev.md          # Next.js frontend
│   ├── allpurpose-agent.md    # Any tech stack
│   ├── qa-test-agent.md       # API/unit testing
│   ├── ui-test-agent.md       # E2E browser testing
│   ├── nextjs-diagnostics-agent.md  # Next.js monitoring (optional)
│   ├── cicd-agent.md          # CI/CD pipelines
│   └── website-designer.md    # Static websites
├── skills/                    # Knowledge modules
│   ├── sprint-workflow/       # How sprints work
│   ├── spec-writing/          # Writing effective specs
│   ├── agent-patterns/        # Agent coordination
│   └── api-contract/          # Contract design
└── docs/                      # Documentation

Agents

Implementation Agents

| Agent | Tech Stack | Description | |-------|------------|-------------| | python-dev | FastAPI, PostgreSQL | Python backend development | | nextjs-dev | Next.js 16, React 19 | Next.js frontend development | | cicd-agent | GitHub Actions, Docker | CI/CD pipelines | | allpurpose-agent | Any | Adapts to any technology | | website-designer | Static HTML/CSS | Marketing websites |

Testing Agents

| Agent | Purpose | Tools | |-------|---------|-------| | qa-test-agent | API & unit tests | pytest, jest, vitest | | ui-test-agent | E2E browser tests | Chrome browser MCP | | nextjs-diagnostics-agent | Runtime monitoring (Next.js only) | Next.js DevTools MCP |

Writing Your Own Agents

Create a markdown file in your project's .claude/agents/ or contribute to this plugin:

---
name: your-agent
description: What this agent does
model: opus
---

[Agent instructions...]

The architect can then request your agent via SPAWN REQUEST blocks.

Specification Files

specs.md - Your input (minimal or detailed):

# Sprint 1: User Authentication

## Goal
Add user authentication with email/password login

## Scope
### In Scope
- Registration endpoint
- Login endpoint
- JWT tokens

### Out of Scope
- OAuth providers
- Password reset

## Testing
- QA: required
- UI Testing: required
- UI Testing Mode: automated

api-contract.md - Generated shared interface:

## POST /api/auth/login
Request: { email: string, password: string }
Response: { token: string, user: User }

Skills

Sprint includes knowledge modules that Claude can load when needed:

• sprint-workflow — Convergent diffusion model, phase lifecycle
• spec-writing — How to write effective specifications
• agent-patterns — SPAWN REQUEST format, report structure
• api-contract — Designing shared contracts

Best Practices

1. Run setup first — Use /sprint:setup to create project-goals.md and project-map.md
2. Write clear specs — The better your specs.md, the better the output
3. Iterate small — Multiple small sprints beat one big sprint
4. Checkpoint often — Commit before running sprints
5. Review reports — Agent reports show what was done and why

Troubleshooting

Sprint stuck in iteration loop

• Check status.md for blockers
• Review agent reports for errors
• Max 5 iterations before pause

Agents not following specs

• Ensure api-contract.md is clear and complete
• Check for conflicting information in spec files
• Architect may need to clarify specs

Documentation

• Agent Architecture - Deep dive into agent system

License

MIT License - See LICENSE

Contributing

Contributions are highly encouraged! This is a community project — the built-in agents are just a starting point.

Ways to contribute:

• Add new agents for different tech stacks (Go, Rust, Vue, Django, etc.)
• Improve existing agents with better prompts, patterns, or capabilities
• Share your workflows — what sprint configurations work well?
• Report issues — what breaks? what's confusing?
• Improve docs — help others get started

Built with Claude Code. Part of Agentic Forge.