https://github.com/sohei56/claude-scrum-team
Scrum development team powered by Claude Code Agent Teams. AI Scrum Master and Developers run Sprint cycles while you stay in the Product Owner seat.
https://github.com/sohei56/claude-scrum-team
agile ai-agents automation claude claude-agent-teams claude-code developer-tools multi-agent python3 scrum
Last synced: about 2 months ago
JSON representation
Scrum development team powered by Claude Code Agent Teams. AI Scrum Master and Developers run Sprint cycles while you stay in the Product Owner seat.
- Host: GitHub
- URL: https://github.com/sohei56/claude-scrum-team
- Owner: sohei56
- License: mit
- Created: 2026-02-21T04:21:44.000Z (4 months ago)
- Default Branch: main
- Last Pushed: 2026-04-11T10:44:12.000Z (2 months ago)
- Last Synced: 2026-04-11T12:24:15.380Z (2 months ago)
- Topics: agile, ai-agents, automation, claude, claude-agent-teams, claude-code, developer-tools, multi-agent, python3, scrum
- Language: Shell
- Homepage:
- Size: 2.84 MB
- Stars: 3
- Watchers: 1
- Forks: 0
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
- Codeowners: .github/CODEOWNERS
- Security: SECURITY.md
Awesome Lists containing this project
README
claude-scrum-team
AI-Powered Scrum Team for Claude Code — a full Scrum workflow driven by multi-agent coordination via Agent Teams
Why? •
Demo •
Features •
Quick Start •
Architecture •
Development
---
Run `scrum-start.sh` in any project directory and a full AI Scrum team takes over — a **Scrum Master** coordinates **Developer** agents through Sprint cycles while you act as the **Product Owner**, approving goals and reviewing the working product.
## Why?
Vibe coding is fast but chaotic. Spec-Driven Development (SDD) is disciplined but demands everything upfront. Most real projects live in between — requirements are fuzzy and need to be shaped as you go.
**claude-scrum-team** brings Scrum's inspect-and-adapt loop to Claude Code, giving you structured iteration without requiring a complete specification on day one. You stay in the Product Owner seat — describing what you want, approving Sprint Goals, and reviewing working software each Sprint — while a team of AI agents handles the rest.
## Demo
One command sets up agents, skills, and hooks — then launches Claude Code with a Scrum Master agent alongside a real-time TUI dashboard in tmux.
### What a session looks like
1. **You describe your project** — the Scrum Master spawns a Developer to elicit requirements and write `requirements.md`
2. **Backlog Refinement** — the SM creates and refines PBIs from your requirements
3. **Sprint Planning** — the SM proposes a Sprint Goal; you approve or adjust
4. **Design + Implementation + Cross-Review** — Developers design and implement their PBIs in parallel, then review each other's work (no self-review)
5. **Sprint Review** — the SM launches the app and demos every completed PBI; you confirm each works
6. **Retrospective** — the team reflects and records improvements for the next Sprint
7. **Repeat** until the Product Goal is achieved, then an **Integration Sprint** runs automated tests and a final UAT
## Features
- **14 ceremony skills** covering the full Scrum lifecycle: requirements elicitation, backlog refinement, sprint planning, design, implementation, cross-review, sprint review, retrospective, and integration testing
- **Multi-agent coordination** — Scrum Master (Delegate mode) orchestrates up to 6 parallel Developer agents per Sprint
- **Real-time TUI dashboard** — Textual-based four-panel display (Sprint Overview, PBI Progress Board, Communication Log, Work Log) with watchdog filesystem monitoring
- **Design document governance** — immutable catalog (`catalog.md`) with editable enablement config (`catalog-config.json`), enforced by phase-gate hooks
- **Quality enforcement hooks** — phase gates (source code restrictions), completion gates (exit criteria), quality gates (Definition of Done), dashboard events, and session context restoration
- **State persistence** — all state in `.scrum/` JSON files for full session resume capability
- **Automated testing** — Integration Sprints run smoke tests, unit tests, and E2E via Playwright
- **Retrospective-driven improvement** — improvements from past Sprints are applied automatically
### AI-Specific Adaptations
This is not a carbon copy of human Scrum — it adapts the framework to how AI agents actually work.
**Extensions leveraging AI strengths:**
- **Dynamic team sizing** — the number of Developer agents is optimized per Sprint based on PBI count and complexity
- **Independent cross-review** — the Scrum Master spawns project-managed reviewer sub-agents (`code-reviewer`, `security-reviewer`, `codex-code-reviewer`) for unbiased, design-driven code review that checks implementation against requirements and design docs
**Constraints addressing AI weaknesses:**
- **Mandatory Requirements Sprint** — the first Sprint is dedicated solely to requirements elicitation, preventing the team from charging ahead without a map
- **No work without a PBI** — all development must be tied to a backlog item, stopping the Scrum Master from drifting into ad-hoc fixes mid-conversation
- **Controlled document creation** — only document types listed in the design catalog may be created, curbing the AI tendency to produce sprawling, unstructured documentation
- **PO-driven Sprint scope** — Sprint boundaries are set by meaningful review checkpoints rather than velocity estimates, since AI agents have no stable velocity baseline
### Sprint Lifecycle
```
┌─────────────────────────────────────────────────────────────┐
│ Requirements Sprint (Sprint 0) │
│ Requirements Elicitation ──▶ Initial Product Backlog │
└──────────────────────────────┬──────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ Sprint N │
│ │
│ 1. Backlog Refine PBIs: draft ──▶ refined │
│ ▼ │
│ 2. Planning PO approves Sprint Goal │
│ ▼ │
│ 3. Scaffold Specs Create design doc stubs from catalog │
│ ▼ │
│ 4. Spawn Teammates Launch Developer agents for PBIs │
│ ▼ │
│ 5. Design Write design specs (parallel) │
│ ▼ │
│ 6. Implementation Build features with TDD (parallel) │
│ ▼ │
│ 7. Cross-Review Devs review each other's work │
│ ▼ │
│ 8. Sprint Review Demo to PO, accept/reject PBIs │
│ ▼ │
│ 9. Retrospective Record improvements for next Sprint │
└──────────┬──────────────────────────┬───────────────────────┘
│ │
▼ ▼
Next Sprint N+1 ┌───────────────────────────────────────┐
│ Integration Sprint │
│ Smoke Tests ──▶ UAT ──▶ Release │
└───────────────────────────────────────┘
```
## Quick Start
```bash
# Clone the repository
git clone git@github.com:sohei56/claude-scrum-team.git
# In your project directory:
cd /path/to/your/project
# Launch the Scrum team (auto-installs Python dependencies if needed)
sh /path/to/claude-scrum-team/scrum-start.sh
```
The script validates prerequisites (auto-installing `textual` and `watchdog` if missing), copies agent definitions, Skills, hooks, and the design catalog to your project's `.claude/` directory, and launches a tmux session with Claude Code (Scrum Master) and the TUI dashboard.
For detailed setup instructions, see [quickstart.md](docs/quickstart.md).
### Prerequisites
- **Claude Code CLI** installed and on PATH
- **Python 3.9+** with `textual` and `watchdog`
- **tmux** (recommended) for side-by-side dashboard layout
### Your role as Product Owner
| You do | The AI team does |
|--------|-----------------|
| Describe what you want to build | Elicit and write detailed requirements |
| Approve Sprint Goals | Plan Sprints and assign PBIs |
| Review demos in the running app | Design, implement, and cross-review code |
| Report defects during UAT | Fix defects and re-test automatically |
| Make release decisions | Run automated test suites |
## Architecture
| Component | Description |
|-----------|-------------|
| `scrum-start.sh` | Entry point — validates prereqs, copies agents/skills, launches tmux |
| `agents/` | Scrum Master (Delegate mode) and Developer agent definitions |
| `skills/` | 14 ceremony Skills with mandatory Inputs/Outputs |
| `hooks/` | Phase gates, completion gates, quality gates, dashboard events, session context |
| `dashboard/app.py` | Textual TUI with real-time panels |
| `scripts/` | Status line, user setup, contributor setup |
| `.scrum/` | Runtime state (JSON, gitignored) |
| `docs/design/` | Design documents governed by `catalog.md` (read-only) + `catalog-config.json` (enabled list) |
| `agents/` sub-agents | Project-managed specialist sub-agents: `code-reviewer`, `security-reviewer`, `codex-code-reviewer`, plus PBI Pipeline sub-agents (`pbi-designer`, `pbi-implementer`, `pbi-ut-author`, `codex-design-reviewer`, `codex-impl-reviewer`, `codex-ut-reviewer`) |
| `.mcp-servers/` | MCP server implementations (OpenAI/Codex bridge for cross-model review) |
## Development
See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and workflow.
## License
[MIT](LICENSE)