# Scrum > Run a complete SCRUM sprint with all ceremonies — Product Owner authors stories, Tech Lead designs, Scrum Master orchestrates implementers, Verifier+Aspect-Panel guard quality, Sprint Auditor adversarially audits, Retro feeds back to /tune-agent. Triggers on /scrum, "run a sprint", "scrum me this", "ship this with full process". - Skill: `sethdford/scrum-2` (Agent Skill) - Install (CLI): `npx skillmds@latest add sethdford/scrum-2` - Raw SKILL.md: https://api.skillmd.com/api/skills/sethdford/scrum-2/raw - Safety review: pending (external: skill-scanner PASS, skillspector CAUTION) - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: AI & ML - Author: sethdford (https://skillmd.com/u/sethdford) - Updated: 2026-09-22 - Page: https://skillmd.com/skills/sethdford/scrum-2 --- # /scrum — Full SDLC sprint with adversarial audit `/scrum ""` orchestrates a complete SCRUM team to deliver a multi-story sprint. ## The ceremonies ``` 1. SPRINT PLANNING product-owner → backlog of user stories + AC tech-lead → design + risk + sequencing for each story scrum-master → wave plan + agent assignments 2. WAVE EXECUTION (per parallel cluster) implementer agents (general-purpose / specialists, isolation: worktree) → work verifier → runs code, captures evidence, RESULT_verifier=PASS aspect-panel → confidence-weighted vote across 5 specialized verifiers critic → adversarial code review 3. SPRINT REVIEW scrum-master → DoD checklist per story; only closes on full evidence 4. SPRINT AUDIT (adversarial) sprint-auditor → independently re-derives whether each AC was delivered adversarial: looks for drift, scope creep, mocked tests, DoD violations, narrow fixes, dropped ACs 5. RETROSPECTIVE /mine-transcripts → extract corrections + patterns from sprint /tune-agent → if any agent had ≥2 verifier failures, propose patch retro.md → what worked, what broke, what to change next sprint ``` ## Files written per sprint ``` /sprints/sprint-/ ├── stories.md (product-owner) ├── designs/.md (tech-lead, one per story) ├── plan.md (scrum-master) ├── evidence// (verifier + panel + critic outputs per story) ├── review.md (scrum-master) ├── audit.md (sprint-auditor) └── retro.md (final) ``` ## Your protocol ### Phase 0: Branch / worktree isolation (mandatory pre-step) Before invoking product-owner, ensure the sprint has its own isolated workspace. **Step 0·0 — pick a NON-COLLIDING sprint name (mandatory).** Run `ls /sprints/ 2>/dev/null` (and check `docs/plans/`). If `sprint-` for your intended integer ALREADY EXISTS, do NOT reuse it — its `stories.md`/`audit.md`/`review.md` are a different sprint and will contaminate your Product Owner and Sprint Auditor (they'll read the stale backlog and audit the wrong thing). Use a UNIQUE name: `sprints/sprint--/` (e.g. `sprint-sota-activation-2026-05-31`). The branch/worktree/tag all derive from this unique name. **Then COMMIT the planning artifacts** (stories.md, designs/, plan.md) immediately after the PO/tech-lead/scrum-master write them — leaving them as uncommitted working-tree files lets a later implementer `git` op (stash/checkout/reset) silently revert them, losing your scope and re-exposing the stale committed version. Evidence: 2026-05-31 h-uman, naming a sprint `sprint-1` in a repo with sprints 1–60 derailed both the PO (wrong first draft) and the auditor (spurious FAIL on a reverted backlog); only the committed CODE survived. See `~/.claude/rules` memory `feedback_scrum_sprint_dir_collision.md`. **Step 0a — assess concurrent activity.** Run `bash scripts/sprint-status.sh` (or equivalent: `git status --short | wc -l`, `git for-each-ref refs/heads/sprint-*`, `git worktree list`). **Step 0b — choose isolation level based on what you see:** | Signal | Recommended isolation | Why | |---|---|---| | `>5 unrelated dirty files` | **Worktree** | A `git stash` wipe could lose concurrent agent work. A worktree gives you a separate working directory that the other agents can't touch. | | `>1 sprint-* branch with recent commits` | **Worktree** | Multiple sprints in flight on the same workspace share a single index — Sprint 1 was wiped twice this way. | | `>1 active worktree already` | **Worktree** | Mixing branch + worktree in one repo is the same risk surface as the original wiped-tree event. | | Otherwise (calm workspace) | **Branch** | Lighter weight; sufficient when you control the workspace. | **Worktree isolation:** ```bash git worktree add ../human-sprint- -b sprint-- cd ../human-sprint- ``` **Branch isolation:** - If `git branch --show-current` returns a `sprint--*` branch: continue. - Otherwise: `git checkout -b sprint--` from a stable base (usually `main` or the previous sprint's tip). - If the working tree has unstaged changes that aren't the sprint's: `git stash push -m "pre-sprint-"` first. **Step 0c — record the choice.** The sprint-master writes the chosen branch name AND the working directory (worktree path or repo path) to `/sprints/sprint-/plan.md` and surfaces it in every standup. If the branch name later changes, OR a different working directory is observed, that's a process violation — flag it. **Why this matters:** Sprint 1 ran on a shared `feat/*` branch and was wiped twice by concurrent `git reset --hard HEAD`. Sprint 2b discovered that even with a dedicated branch, a concurrent agent later renamed the branch tip to point at unrelated work — only because Sprint 2b's commits stayed reachable as detached objects (and `git rev-parse ` recovered them) did the audit trail survive. A worktree gives you a separate working directory the other agents can't touch even if they `git reset` the branch ref. ### Phase 1: Plan 1. Spawn `product-owner` agent with the goal. It returns `RESULT_product-owner=READY|NEEDS_CLARIFICATION|NEEDS_DESCOPE`. - If NEEDS_CLARIFICATION: surface to user, wait, retry. - If NEEDS_DESCOPE: split goal across multiple sprints; user picks first. 2. For each story (parallel where possible), spawn `tech-lead` to author design + risk. 3. Spawn `scrum-master` with the stories + designs to write the wave plan. The wave plan MUST cite the sprint branch name from Phase 0. ### Phase 2: Execute For each wave in plan: 1. Read scrum-master's plan; identify the agents to spawn. 2. Spawn parallel implementer agents (`Agent` tool with `isolation: worktree`). Each implementer prompt MUST include: - "Commit your work to `` with `git add && git commit -m \"...\"` BEFORE reporting DONE. Working-tree-only DONE reports will be rejected." - **Mandatory closing-line contract:** Your final report MUST have this exact format, with exit codes from a FRESH subprocess (not cached state): ``` RESULT_implementer-=DONE|PARTIAL|BLOCKED commits= build-exit= # from fresh `cmake --build` AFTER all edits test-exit= # from fresh `./build/human_tests` AFTER all edits test-summary="` and `remaining=`. Stubs asserting only `HU_ASSERT_TRUE(1)` do NOT count toward test counts. - Do NOT report DONE if exit codes are non-zero. Honest PARTIAL beats fabricated DONE. 3. After each implementer reports done: - **Verify the closing-line format first.** If it lacks proper exit codes or asserts DONE with build-exit≠0, reject immediately: "exit codes missing or DONE claimed with non-zero build. Re-run fresh cmake/tests and resubmit." - Verify the commit landed: `git log ^ --oneline` MUST show the implementer's commit. If not, reject the DONE report and re-dispatch. - Spawn `/verify` for that story (verifier agent runs the code) - If verifier PASS: spawn `critic` immediately for adversarial review (per-story, not batched) - If critic flags HAS_FINDINGS at HIGH/CRITICAL severity: re-open the story with the finding inline; do NOT advance to aspect-panel. - If critic CLEAN: spawn `/aspect-panel` for orthogonal coverage - If panel returns ESCALATE: surface to user; do not auto-resolve - Mark story DONE in TodoWrite **only** when commit + verifier + critic + panel all pass ### Phase 3: Review Spawn `scrum-master` Phase 5 (Sprint Review). It writes review.md with the DoD checklist per story. ### Phase 4: Audit (mandatory — never skip) Spawn `sprint-auditor` with paths to stories.md and review.md. It returns one of: - `RESULT_sprint-auditor=PASS` → sprint closes - `RESULT_sprint-auditor=PASS_WITH_NOTES` → sprint closes; notes go to retro - `RESULT_sprint-auditor=FAIL` → DO NOT CLOSE. Re-open the failing stories. Re-execute. - `RESULT_sprint-auditor=INCONCLUSIVE` → surface to user; ask for missing access ### Phase 5: Retro 1. Run `/mine-transcripts --since ` over this sprint's session window. 2. Read agent-tuning candidates. If any agent appears ≥2 times: recommend `/tune-agent `. 3. Write retro.md with: what worked, what broke, what changed next sprint, any tuning candidates. ### Phase 6: Close 1. Mark all sprint TodoWrite items completed. 2. **Tag the close commit immutably.** Run `scripts/tag-sprint-close.sh sprint-` from the repo root. Annotated tags don't move under branch hijacks or push-force; the tag becomes the canonical reference for any future cherry-pick, regression-hunter, or sprint-auditor invocation that needs to resolve "where did sprint-N actually end". Sprint 2c's branch-hijacking incident is the failure mode this prevents — by the time a future agent runs `git log sprint-2b-personal-model-honesty`, the branch tip may have been moved by an unrelated workstream; the tag `v-sprint-2b-close` cannot move silently. 3. Print summary to user. ## Hard rules - **No story closes without verifier PASS + panel PASS/CLEAN.** Hold the line even when implementer is confident. - **Audit is mandatory.** Never skip Phase 4. - **Audit FAIL re-opens stories.** Don't quietly accept partial deliveries. - **No scope creep without explicit PO sign-off.** sprint-auditor catches this; respect it. - **Retro happens even on perfect sprints.** Even green-on-everything has lessons. - **Sprint runs on a dedicated branch from planning.** At Phase 1, the scrum-master MUST create or check out `sprint--` (a branch or worktree dedicated to this sprint) before dispatching any implementer. Sprints MUST NOT run on a shared feature branch where other workstreams are landing concurrently. Sprint 1's wiped-tree event (concurrent `git reset --hard HEAD` from another agent) is the failure mode this rule prevents. - **Implementer commits before handoff.** Each implementer's last action MUST be `git add` + `git commit` to the sprint-isolated branch. A "DONE" report whose work is only in the working tree is NOT done — the next implementer's `git reset` or rebase will wipe it. The scrum-master rejects DONE reports unless `git log ^` shows the implementer's commit. This is not optional, even for tiny stories. - **Critic runs immediately after each story closes**, not at sprint end. Batched critic-at-close is how Sprint 1 shipped a regex bug into the production publish path; per-story critic catches it before the next implementer builds on top. ## Cost discipline A typical 3-story sprint costs: - product-owner: ~$0.30 (Sonnet, 1 invocation) - tech-lead: 3 × ~$0.50 (Opus, 1 per story) - implementer: 3 × ~$1.00-2.00 (sonnet/opus, varies) - verifier: 3 × ~$0.20 - aspect-panel: 3 × ~$0.50 (5 verifiers each, sonnet) - critic: 3 × ~$0.20 - sprint-auditor: 1 × ~$0.80 (Opus, careful read) - mine-transcripts retro: ~$0.50 Total per sprint: ~$8-15. Verify against `--max-budget-usd 20` per sprint by default. ## When NOT to use /scrum - Single-line fix (just edit it; the ceremony costs more than the work) - Exploratory spike (use `/spec` for design-first; use plain `/team` for implementation if it pans out) - No clear acceptance criteria possible (PO will refuse; surface to user first) - Test infrastructure missing (verifier can't run; auditor will be INCONCLUSIVE) ## Anti-patterns to refuse - Closing a sprint without sprint-auditor running - Treating audit FAIL as advisory (it is HARD) - Skipping retro - Letting the scrum-master write code (orchestration only) - Letting sprint-auditor trust the team's claims (independent verification only) - Running stories sequentially when they're independent (use waves) - Running stories in parallel when they share state (don't) ## Last line When the sprint closes successfully: ``` RESULT_scrum=SPRINT_CLOSED N= stories=/ audit=PASS retro= ``` When the sprint cannot close: ``` RESULT_scrum=BLOCKED reason= ```