agile-team-skill

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 • Pixel Office • 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 core agents — plus six extended specialists (Senior Engineer, Principal Engineer, AI Engineer, Design Lead, CTO, CEO) activated per project need via the .claude/memory/TEAM.md roster. 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

Before	After
Commit and hope nothing breaks	4 specialist agents review every diff
Security issues show up in production	Security reviewed on every commit — OWASP, secrets, CVEs
Lose context switching sessions	NEXT.md tells you exactly what to do, every session
Backlog is a pile of random notes	Stories written, groomed, and prioritized by a product owner
Tech debt accumulates silently	Tech debt gets a story the moment it’s introduced
Ship without acceptance criteria	QA hard veto — nothing ships without passing tests
Retros never happen	Every sprint closes with a retro that produces real backlog items

---

The 13 Agents

The core seven — on every project, in every ceremony:

po-agent

pm-agent

dev-agent

qa-agent

pr-reviewer

security

tech-lead

The extended six — activated per project need via the .claude/memory/TEAM.md roster:

senior-eng

principal

ai-engineer

design-lead

cto

ceo

Agent	What they do for you
po-agent	Writes proper user stories with acceptance criteria. Prioritizes your backlog. Synthesizes all review findings into a verdict.
pm-agent	Keeps you focused. Owns the sprint state and NEXT.md. Makes sure nothing is blocked without a plan.
dev-agent	Implements stories, reports in standups, flags blockers early.
qa-agent	Adds test scenarios to every story. Hard veto — nothing ships without passing tests. No exceptions.
pr-reviewer-agent	Senior-level code review on every diff. Correctness, patterns, performance, maintainability.
security-analyst-agent	Scans every diff for OWASP issues, secrets, CVEs, auth holes. Soft veto — can block a PR.
tech-lead-agent	Tracks architecture decisions. Estimates complexity. Writes tech specs for complex work. Flags tech debt.
senior-engineer-agent	Takes the hardest implementation work: L/XL stories, deep debugging, tricky refactors, spikes. Mentors dev.
principal-engineer-agent	On-demand consult for high-stakes technical calls: XL design reviews, migrations, build-vs-buy, reliability audits.
ai-engineer-agent	Owns AI feature quality when the project touches LLMs: model selection, prompt design, eval harnesses, AI cost budgets.
design-lead-agent	UX/UI lens on user-facing work: flows, design-system consistency, interaction states, accessibility.
cto-agent	Final technical escalation: veto overrides, platform/vendor adoption, SEV-1 postmortem sign-off.
ceo-agent	Business-outcome escalation: missed success metrics, priority deadlocks, “should we build this at all”.

---

The Pixel Office

Your team isn’t invisible. The office is a live visualization of everything the agents do — open it in a browser and watch the team work in real time:

• The whole team sits at their desks; spawning an agent lights up their laptop and shows what they’re working on in a speech bubble
• Finished agents walk over to report to the manager, then grab a coffee in the lounge before returning to their desk
• Ceremonies are real meetings: run /standup, /retro, or /sprint-plan and everyone walks to the conference room and takes a seat until the session ends
• Execs have private cabins, there’s a huddle room, a couch booth, and a whiteboard corner

Start it with one command (it tails the event feed your hooks write automatically):

bash .claude/office/serve.sh     # prints the URL, e.g. http://localhost:8123

No build step, no dependencies beyond Python’s built-in http.server. Try bash .claude/office/demo.sh for a scripted tour without running real ceremonies.

---

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 .claude/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

If a session drops mid-chain (rate limit, host sleep, lid close), the team writes a CHECKPOINT.md after every agent step. Run /resume and the chain picks up from exactly where it stopped — no repeated work, no lost progress. Corrupt or stale checkpoints are detected and discarded automatically.

Six files persist your full project state across every session:

.claude/memory/
├── NEXT.md       Exact next step — specific file, function, outcome
├── STATE.md      Sprint goal, velocity, blockers, in-progress stories
├── BACKLOG.md    Open stories — Index at top, bodies below
├── ARCHIVE.md    Completed stories — append-only, moved here by /complete
├── DECISIONS.md  Architecture decisions (DEC-001, DEC-002, ...)
└── LEARNINGS.md  Retro learnings — append-only, never deleted

---

Model configuration

Each agent has a model: field in its frontmatter. Edit the agent file directly to change which model it uses — Claude Code picks it up automatically.

# .claude/agents/security-analyst-agent.md
---
name: security-analyst-agent
model: sonnet    # change this to: sonnet | opus | haiku | inherit
---

Valid values: sonnet, opus, haiku, inherit (inherits the session default)

Most agents default to sonnet. pm-agent runs on haiku because its work is templated state writes — no deep reasoning needed. You can tune each agent independently:

Default install (balanced — calibrated for cost without losing review quality):

Agent file	Model	Why
pm-agent.md	haiku	templated STATE.md / NEXT.md writes — frequent and lightweight
everything else	sonnet	code review, security checks, synthesis — sonnet is the right tier

Quality-first override — bump the deep-reasoning agents to Opus for high-stakes projects:

Agent file	Model	Why
security-analyst-agent.md	opus	catches subtle vulnerabilities sonnet may miss
tech-lead-agent.md	opus	architecture decisions where depth pays off

Cost-optimised — Haiku across more roles, only review agents stay on Sonnet:

Agent file	Model	Why
pm-agent.md	haiku	already default
dev-agent.md	haiku	capacity estimates, status reports
po-agent.md	haiku	backlog updates, ceremony output
security-analyst-agent.md	sonnet	already default — keep here, don’t push to haiku
everything else	sonnet	review agents need the quality

Edit each agent’s .md file individually — there is no single config file.

---

Setup

Prerequisites — install Claude Code

Works on any Claude Code surface. Pick whichever fits your workflow:

Surface	How to install
Terminal CLI	claude.ai/code → “Install CLI”
Desktop app (Mac / Windows)	claude.ai/code → “Download”
VS Code	Extensions panel → search “Claude Code” (by Anthropic) → Install
JetBrains (IntelliJ, PyCharm, GoLand, …)	Plugins → search “Claude Code” → Install
Web	open claude.ai/code in any browser

The /plugin commands below work identically on every surface — they’re a Claude Code feature, not surface-specific.

Optional: gitleaks for pre-commit secret scanning.

brew install gitleaks   # macOS

The installer warns if gitleaks is missing and skips scanning until it’s available. Everything else works without it.

Quick Start (brand-new project — copy/paste)

In your terminal:

mkdir my-project && cd my-project
git init
claude              # or open this folder in VS Code / Claude Code Desktop / claude.ai/code

Then inside Claude Code, type these slash commands one by one:

/plugin marketplace add thecoderbuddy/agile-team-skill
/plugin install agile-team@agile-team-marketplace
/init "I'm building a REST API for expense tracking"
/sprint-plan
/standup

That’s the full zero-to-running flow. After /init, you’ll see .claude/memory/ and .claude/CLAUDE.md created in your project. After /sprint-plan, the team has a sprint goal and you’re ready to ship.

The detailed sections below walk through each step — including the VS Code / JetBrains / web variants and the alternative install.sh path.

---

1. Install

Two paths — pick one:

Option A: Claude Code plugin (recommended)

Works in any Claude Code surface (CLI, desktop app, claude.ai/code in browser, or VS Code / JetBrains extension). Run these inside Claude Code:

/plugin marketplace add thecoderbuddy/agile-team-skill
/plugin install agile-team@agile-team-marketplace

That’s it. The 13 agents, 30 commands, and safety hooks are available immediately. No files are written into your project — Claude Code holds the plugin centrally, and updates come through the marketplace.

Skip to step 3 below to onboard a project.

Option B: Local install via script

Writes .claude/ and the hooks directly into your project. Pick this if you want a tracked-in-repo install you can commit and customize per-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 your project in Claude Code

Surface	How
CLI	cd your-project && claude
Desktop app	Launch Claude Code → File → Open Folder → select your project
VS Code	Open the project in VS Code → click the Claude Code icon in the sidebar (or Cmd/Ctrl+Shift+P → “Claude Code: Open”)
JetBrains	Open the project → Tool Windows → Claude Code
Web	Open claude.ai/code → New session → connect your GitHub repo

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

Group	Commands
Onboarding	/init
Core ceremonies	/standup /sprint-plan /sprint-close /retro /review /stories /backlog /new-task /status
Story lifecycle	/discover /design /complete /unblock /bug /idea /missing
Reviews & audits	/arch-review /ux-review /security-review /risk-review /adr
Session management	/done /checkpoint /resume /health-check /logs /po /incident /focus-group

---

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/
├── README.md
├── install.sh                        ← one-command installer
└── .claude/                          ← everything lives here — clean project root
    ├── CLAUDE.md                     ← project constitution (auto-loaded by Claude Code)
    ├── agents/                       ← 13 specialist agents
    │   ├── po-agent.md … tech-lead-agent.md        (7 core)
    │   └── senior-engineer-agent.md … ceo-agent.md (6 extended)
    ├── commands/                     ← 30 slash commands
    │   ├── init.md                   /init
    │   ├── standup.md                /standup
    │   ├── review.md                 /review
    │   └── ...
    ├── hooks/                        ← safety gates + secret scanning + office events
    ├── office/                       ← live pixel-office visualization
    │   ├── index.html                the app (PixiJS)
    │   ├── serve.sh                  bash .claude/office/serve.sh
    │   └── events.jsonl              event feed written by hooks
    └── memory/                       ← persistent team state
        ├── NEXT.md
        ├── STATE.md
        ├── BACKLOG.md
        ├── ARCHIVE.md
        ├── DECISIONS.md
        └── LEARNINGS.md

---

Multiple Projects

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

~/projects/
├── api/       ← .claude/ (incl. memory + CLAUDE.md) (sprint 3)
└── frontend/  ← .claude/ (incl. 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.2.0 — The Pixel Office: live visualization of your agents (walk, work, meet, coffee breaks), 13-agent roster with custom character art, exec cabins + conference room + collab zones, everything relocated under .claude/ for a clean project root.
• 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.

---

Support

If this saves you time, consider buying me a coffee:

---

License

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

---