Agile Team for Claude Code

An AI agentic team designed for your agile workflow. For anyone building a product independently — with the discipline of a real team behind every decision.

Quick Start • Agents • Commands • Contributing

The problem it solves

When you're building a product alone, you skip the things that matter most — not because you don't care, but because there's nobody to hold you to them.

You ship without a proper review. You make a product decision, forget the reasoning, then reverse it two weeks later. You write a story with no acceptance criteria and call it done anyway. Security holes slip through. Tech debt piles up quietly. You know what good process looks like — you just have no one to run it with.

It doesn't matter if you're a developer, a founder, or someone building with AI for the first time. The gap is the same: the work is solo, but the discipline that makes teams ship well — review loops, clear ownership, sprint memory — isn't.

This gives you that team. An AI agentic team designed around your agile workflow, not a single assistant trying to do everything at once.

What it actually does

Seven agents. Each one has a single job and won't budge from it. When you run /review, QA checks first — if your code doesn't meet the acceptance criteria, the review stops there. No code review of broken code. If it passes, four agents process your diff in sequence, then the PO collects all findings and gives you one verdict:

You run:  /review

  qa           → tests pass? AC met? edge cases covered?
                 ↓ FAIL → stop here. back to dev. no exceptions.
                 ↓ PASS → proceed

  pr-reviewer  → correctness, style, edge cases, dead code
  security     → secrets, OWASP, CVEs, input validation, auth
  tech-lead    → architecture alignment, tech debt, patterns

  po           → collects all findings:
                   FIX NOW    → blocks merge
                   BACKLOG    → added to BACKLOG.md automatically
                   WON'T FIX  → documented with reasoning

You get:  APPROVED → run /complete to commit
          CHANGES REQUESTED → fix → /review again
          + every non-blocking issue in your backlog, not forgotten

That's the pattern for every command. Multiple specialists. One synthesizer. One artifact.

Before and after

The 7 Agents

po-agent

pm-agent

dev-agent

qa-agent

pr-reviewer

security

tech-lead

How a day works

First time only
  /init "I'm building a REST API for expense tracking"
  → agents scan your project, write real stories, set sprint goal

Sprint planning (start of sprint)
  /sprint-plan
  → PO proposes stories from backlog
  → dev commits capacity ("I can take 3 stories, STORY-001 is 2 days...")
  → tech-lead estimates complexity, flags dependencies
  → QA validates acceptance criteria
  → SM finalizes sprint in STATE.md

Every morning
  /standup
  → each agent reports: done / doing / blocked
  → blockers get an owner and mitigation
  → today's focus confirmed from NEXT.md

When you pick up a story
  /new-task
  → PO selects highest priority unblocked story
  → tech-lead writes spec if M+ complexity
  → dev confirms: AC clear, approach clear, ready to start

You implement the story, then...
  /review
  → QA validates first: tests pass? AC met? (hard stop if not)
  → code review: style, security, architecture
  → PO verdict: APPROVED or CHANGES REQUESTED

  If CHANGES REQUESTED → fix → /review again
  If APPROVED →

  /complete STORY-XXX "description"
  → commit with proper format
  → story closed in STATE.md
  → NEXT.md updated

  → more stories? /new-task
  → all done?    /sprint-close

If something is blocking you
  /unblock STORY-XXX "what was blocked and how it's resolved"
  → tech-lead confirms resolution
  → blocker cleared from STATE.md

End of sprint
  /sprint-close → velocity tallied, carry-overs moved to backlog
  /retro        → all agents reflect, actions become backlog stories
  /sprint-plan  → plan the next sprint

Session Continuity

At the end of every session, pm-agent writes memory/NEXT.md — specific enough that zero context is needed to resume.

Next time you open Claude Code:
  /standup   → team picks up exactly where you left off

Five files persist your full project state across every session:

memory/
├── NEXT.md       Exact next step — specific file, function, outcome
├── STATE.md      Sprint goal, velocity, blockers, in-progress stories
├── BACKLOG.md    All stories — from /stories, /review, /retro
├── DECISIONS.md  Architecture decisions (DEC-001, DEC-002, ...)
└── LEARNINGS.md  Retro learnings — append-only, never deleted

Setup

Prerequisites

• Claude Code CLI or desktop app

1. Install inside your project

cd your-project
curl -fsSL https://raw.githubusercontent.com/thecoderbuddy/agile-team-skill/main/install.sh | bash

Or clone and install locally:

git clone https://github.com/thecoderbuddy/agile-team-skill.git
cd your-project
bash /path/to/agile-team-skill/install.sh

The installer asks before overwriting anything — safe to run on existing projects.

2. Open Claude Code

cd your-project
claude

3. Onboard the team

New project:

/init "I'm building a task manager CLI in Python"

Existing project — agents scan the codebase and infer what's built and missing:

/init

Agents will write real stories into BACKLOG.md, set a sprint goal in STATE.md, and tell you exactly what to do next.

4. Begin

/sprint-plan   ← agents plan your first sprint together
/standup       ← start

All 30 Commands

Why this works when one agent doesn't

A single agent reviewing your PR has no tension. It helped write the code, evaluated the security, and decided the verdict — same context, same perspective, all the way through. It has no reason to push back hard.

These agents disagree with each other. Each one has a narrower job and genuine constraints the others don't share:

• QA has a hard veto — nothing ships without passing tests, no exceptions
• Security has a soft veto — can block a PR; findings never silently disappear
• The PO never writes findings — only synthesizes them and makes the call
• The Scrum Master never prioritizes — only ensures nothing is lost

When QA fails, the chain stops. When security finds a critical issue, it escalates — it doesn't suggest. When a finding doesn't block merge, it goes straight to the backlog, not into a chat message you'll scroll past and forget.

That's the difference between a team and a panel of assistants.

Built from experience running a 40-agent AI engineering team on a real product.

Project Structure

agile-team-skill/
├── install.sh                        ← one-command installer
├── CLAUDE.md                         ← project constitution
├── .claude/
│   ├── agents/                       ← 7 specialist agents
│   │   ├── po-agent.md
│   │   ├── pm-agent.md
│   │   ├── dev-agent.md
│   │   ├── qa-agent.md
│   │   ├── pr-reviewer-agent.md
│   │   ├── security-analyst-agent.md
│   │   └── tech-lead-agent.md
│   ├── commands/                     ← 30 slash commands
│   │   ├── init.md                   /init
│   │   ├── standup.md                /standup
│   │   ├── review.md                 /review
│   │   └── ...
│   └── hooks/                        ← session tracking
└── memory/                           ← persistent team state
    ├── NEXT.md
    ├── STATE.md
    ├── BACKLOG.md
    ├── DECISIONS.md
    └── LEARNINGS.md

Multiple Projects

Install once per project. Each project gets its own memory/ — completely separate sprint state, backlog, and decisions. Same 7 agents, same 30 commands, different context.

~/projects/
├── api/       ← .claude/ + memory/ + CLAUDE.md (sprint 3)
└── frontend/  ← .claude/ + memory/ + CLAUDE.md (sprint 1)

Contributing

New agents, new ceremony commands, improvements to collaboration chains — all welcome.

• Add an agent: create .claude/agents/your-agent.md. Define its role in each ceremony — that's the collaboration chain contract.
• Add a command: create .claude/commands/your-command.md. Define which agents participate, in what order, and what artifact they produce.

Release History

• 1.1.0 — Real scrum flow: dev capacity in sprint planning, QA gates code review, /unblock command, handoff lines throughout.
• 1.0.0 — Initial release. 7 agents, 30 commands, full agile lifecycle.

License

MIT — use it, fork it, adapt it for your team.