agentleFS
tjst-ttjst-t/claude-skills/skills/sprint/SKILL.md

sprint

Skill0 starsChanged 4 months agoMITView on GitHub

Manages Agile Sprint lifecycle — plan, prototype, run, verify, demo, refine, done. Generates roadmaps, executes sprints autonomously, and tracks progress via docs/ROADMAP.json.

29 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use ecosystem-reference, fractal-delegation and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • naman10parikhSkill

    ecosystem-reference

    Quick-access directory of Claude Code ecosystem repos, skills, plugins, MCPs, and patterns. Use when improving the harness.

    Also in 5 projects that use this

  • naman10parikhSkill

    fractal-delegation

    Also in 5 projects that use this

  • KirchliveSkill

    skill-routing

    Decides which of the installed skills a task needs and loads them before the work starts. This skill should be used at the beginning of any multi-step task — build, fix, refactor, migrate, review, plan, release, research, write, design, video — and again at every phase change, after context compaction, and when work moves into a different part of the codebase. Use it for requests like "let's build X", "fix this bug", "refactor Y", "plan the migration", "review this", and also when the user asks which skill applies, why a skill did not fire, or asks to check what is available.

    Also in 5 projects that use this

  • sublimotionSkill

    agent-runtime

    Launch and manage detached agent runs on EKS via the agent-runner CLI. Use when the user says "launch an agent run", "agent runtime", "agent-runner", "run this spec on the cluster", "check run status", "agent run logs", or "stop a run". Do NOT use for writing the agent-runner code itself (edit the sibling ../agent-runner repo), Terraform of the foundation (use terraform-automation), or GPU serving deployments (use infra-deployer).

    Also in 5 projects that use this

  • GoZippySkill

    repo-scout

    Also in 5 projects that use this

  • BenjaminGSkill

    harness-review

    Turn one PR's review comments into harness fixes — classify each cause by the most solid place it can live (codebase, lint, rules, skill), then draft the fixes in a separate PR.

    Also in 5 projects that use this

  • +6 more from naman10parikh

The file

We split this skill into the rules it gives an agent

6 rules. 0 are common, 1 is distinctive, and 5 are very specific to this project.

  • 0

    Common

    Most of the 26 edited versions we read keep these.

  • 1

    Distinctive

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When a command is invoked, read the corresponding reference file before taking any action.

    line 34
  2. Very specific:

    Every sprint command accepts an --auto flag that flips its decision posture:

    line 38
  3. Very specific:

    Log everything: Test output, build output, and verification results go to docs/sprint-logs/{SprintID}/.

    line 52
  4. Very specific:

    Roadmap is the source of truth: Always read docs/ROADMAP.json before taking action.

    line 53
  5. Very specific:

    GUI spec is mandatory in sprint plan: Always run the GUI spec process (references/gui-spec.md) during sprint plan.

    line 63
  6. Very specific:

    Acceptance criteria traceability: Every acceptance criterion in ROADMAP.json must have a corresponding test tagged with [AC-{StoryID}-{N}].

    line 68

“Common” is measured: kept by at least 6 in 10 of the 26 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Sprint Runner

Manages the Agile Sprint lifecycle: plan → prototype → run → verify → demo → refine → done.

Roadmap Location

The roadmap file is always at docs/ROADMAP.json in the project root. If it doesn't exist, prompt the user to run sprint init first. If docs/ROADMAP.md exists but ROADMAP.json does not, run sprint init to migrate.

Commands

CommandDescriptionDetail
sprint initInitialize or migrate the roadmapSee references/sprint-init.md
sprint planPrepare the next sprint collaborativelySee references/sprint-plan.md
sprint prototypeGenerate HTML prototype for GUI reviewSee references/sprint-prototype.md
sprint runExecute the current sprintSee references/sprint-run.md
sprint verifyVerify completeness and quality (--with-verifier adds an independent checker)See references/sprint-verify.md
sprint demoDemonstrate deliverables by running the programSee references/sprint-demo.md
sprint refineInteractive UI/UX refinement with userSee references/sprint-refine.md
sprint doneFinalize and commit the sprintSee references/sprint-done.md
sprint fixQuick fix without full sprint ceremony (alias: sprint hotfix)See references/sprint-fix.md
sprint helpShow command list and usage guideSee references/sprint-help.md
sprint autoExecute one sprint fully autonomously (deprecated — prefer autopilot)See references/sprint-auto.md
sprint ideaDiscuss and add new features to roadmap (alias: sprint propose)See references/sprint-idea.md
sprint roadmapGenerate two-tier roadmap from VISION (rolling-wave: detail to next milestone, coarse beyond)See references/sprint-roadmap.md

When a command is invoked, read the corresponding reference file before taking any action.

Auto mode (--auto flag)

Every sprint command accepts an --auto flag that flips its decision posture:

  • Default (no flag) — collaborative. When a decision is genuinely ambiguous (multiple viable approaches with real trade-offs), stop and ask the user. This is the right mode when a human is driving.
  • sprint <cmd> --auto — autonomous. When a decision is ambiguous, pick the best-practice default, log it to docs/sprint-logs/{SprintID}/decisions.json with rationale, and proceed without prompting. This is how autopilot always invokes sprint.

--auto changes who resolves an ambiguous choice, never what is allowed. It does NOT relax any gate: the forbidden-action categories (immediate-stop still stops), the 8-guard done judgment, and test-discipline all still apply. Under --auto, sprint verify additionally enables the independent verifier (--with-verifier).

The legacy sprint auto command is the single-command form of "run plan→run→verify→done all with --auto". It is being superseded by the autopilot skill (see references/sprint-auto.md); prefer autopilot for multi-Sprint autonomous execution.

Important Behaviors

  • Auto-decide, confirm once: During sprint plan and reviews, auto-select the recommended approach when there is a clear best practice. Present a single summary with all decisions (auto-decided + open questions) for the user to confirm or adjust. Only ask individual questions for genuinely ambiguous design decisions with meaningful trade-offs.
  • Enforce user stories: During sprint plan, verify all Stories follow the "{役割}として、{やりたいこと}をしたい。なぜなら、{理由}だから。" format. Autonomously rewrite task-decomposition Stories as proper user stories.
  • Autonomous technical decisions: During sprint run, make technical decisions autonomously when there is a clear best practice. Only escalate for significant architectural impact. Log autonomous decisions in docs/sprint-logs/{SprintID}/.
  • Log everything: Test output, build output, and verification results go to docs/sprint-logs/{SprintID}/.
  • Roadmap is the source of truth: Always read docs/ROADMAP.json before taking action.
  • Respect dependencies: Flag incomplete prior Sprints as blockers during sprint plan.
  • Actually invoke /review: During sprint run (per-Story) and sprint verify (Sprint-level), call the /review skill yourself via the Skill tool. Never skip or delegate this.
  • Two-level review, both bounded: Story-level review in sprint run (fix loop capped at 2 cycles per Story) + Sprint-level review in sprint verify (scoped to cross-Story surfaces, re-run at most once). Both are mandatory; neither loops until "no findings remain".
  • Parallel execution with worktrees: Independent Stories run in parallel via sub-agents with worktree isolation. Ensure .claude/worktrees/ and .claude/autopilot-*.lock are in .gitignore before first worktree creation.
  • Sub-agent model: Implementation and review sub-agents use model: "sonnet". Main agent uses the default model.
  • Sub-agent prompts must be self-contained: Include all necessary context in each sub-agent prompt — never assume prior conversation is available.
  • Demo with running program: sprint demo runs make serve (or equivalent) and demonstrates acceptance criteria live. Never substitute test code execution.
  • Refine is interactive only: sprint refine requires the user to look at the running app and provide feedback. It is skipped in sprint auto. In autopilot, it runs at milestone boundaries after the demo.
  • Always commit and push on done: sprint done must leave a clean working tree.
  • GUI spec is mandatory in sprint plan: Always run the GUI spec process (references/gui-spec.md) during sprint plan. Let it determine whether GUI work exists. (This was a standalone gui-spec skill; it is now a sprint reference, reached only from sprint plan / sprint idea.)
  • Prototype before implementation: For GUI Stories, run sprint prototype after sprint plan and before sprint run. The approved HTML prototype in prototype/ is the visual reference for implementation sub-agents. In autopilot, prototyping covers all GUI Stories up to the next milestone.
  • Two-tier testing: GUI Stories produce two test files — mock tests (*.mock.spec.ts) for error/edge cases, E2E tests (*.e2e.spec.ts) for acceptance criteria against the real server. Non-GUI Stories produce acceptance tests in tests/acceptance/.
  • Mock tests gate Story completion in sprint run: A GUI Story cannot be marked [x] in sprint run unless its mock tests pass. E2E tests run later in sprint verify.
  • Test discipline is the source of truth: All nine rules — every Story has a user scenario, tests drive the user's entry point (CLI subprocess / real HTTP client / real-browser Playwright / library public API), no silent skips, GUI E2E observes UI state through the real backend, status reflects reality, what you ship is what you test (Rule 6: the Sprint's diff scan ensures every implemented user-observable surface has a passing test, not just declared AC), and 実機検証は本番モードで (Rule 7: priority_rule 9 smoke must run in production mode — no MOCK=true / --fake-* / DRY_RUN=1 / in-process Fake), plus Rule 8 (data-path Sprints must carry a destructive multi-version test) and Rule 9 (test status is machine-derived from real exit codes, never authored by judgment) — live in references/test-discipline.md. plan / run / verify / done / auto all defer to it. When something feels ambiguous about what a test must look like, read that file.
  • Acceptance criteria traceability: Every acceptance criterion in ROADMAP.json must have a corresponding test tagged with [AC-{StoryID}-{N}]. sprint verify checks this mapping and creates missing tests.
  • Auto mode logs all decisions: During sprint auto, every decision (planning, implementation, review) must be logged to docs/sprint-logs/{SprintID}/decisions.json with rationale referencing VISION.json or DESIGN_PRINCIPLES.json. Work happens on an autopilot/{base-branch}/{SprintID} branch, not directly on the base branch.
  • All data files are JSON: ROADMAP, VISION, DESIGN_PRINCIPLES, and all sprint-logs use JSON format. See references/ROADMAP_SCHEMA.json and references/SPRINT_LOGS_SCHEMA.json for structure. ARCHITECTURE.md and CLAUDE.md remain Markdown.
  • DESIGN/ is binding when present: docs/DESIGN/ is managed by the design skill. When the directory exists, sprint plan / run / roadmap must read the relevant ADRs and respect them as constraints. Accepted ADRs are not negotiable in sprint commands — if a Sprint needs to contradict one, escalate to the user via design adr (amend / supersede) before proceeding. Tentative ADRs are advisory.
  • 8-Guard Done Judgment: Before marking any Story as done in sprint verify / sprint done / sprint auto, apply all 8 guards defined in references/sprint-done-judgment.md. The mechanical guards (2/3/6/7 + configured 5/8 greps) are machine-run once by hooks/run-guards.py (guards-run.json); the model applies policy on the hits and evaluates the judgment guards (1/4 + applicability of 5/8) — never re-runs the greps by hand. Any failed guard moves the Story to needs_user_review, not done. Record each guard's pass/fail/warn outcome in verification-results.json under done_judgment.
  • Machine-derived test status: sprint verify runs the project's declared verification through hooks/run-verify.py, which writes a machine-authored verdict (verify-run.json) from the real process exit code + JUnit. The model copies status from that verdict and authors only evidence — it never decides pass/fail by reading output. sprint done's gate and an integrity hook block recording a pass over a machine failure. This is the fix for the fabrication incident; it is language-agnostic (exit codes + optional JUnit). Full contract: references/verify-execution.md.
  • Independent verifier (--with-verifier): The default sprint verify runs in the same session that implemented the code, which grades itself too leniently (self-grading bias). sprint verify --with-verifier additionally spawns a separate read-only Claude session that re-checks AC against real code, the forbidden-action categories (test-discipline.md Rule 6), ADR conformance, and compromise completeness, writing docs/sprint-logs/{SprintID}/verification-report.json. That report is the trust source — where it disagrees with the self-report, the verifier wins. autopilot --auto always enables it; manual sprint verify defaults to off (token cost). Full spec: references/verifier-agent.md.
  • priority_rule 9 exception scope is strict: The exception clause (障害シナリオへの限定) requires explicit障害シナリオ identifiers (kill-9 / 停電 / Shamir-unseal / ネットワーク遮断 / disk-full / OOM / プロセスクラッシュ) in the Story's review_reason. sprint rejects exception claims without these markers and falls back to the normal real-mode smoke requirement.
  • Mock-mode does not satisfy real-mode smoke (test-discipline Rule 7): Tests that use MOCK=true, --fake-* flags, DRY_RUN=1, in-process FakeCore / InMemoryStore, or *_fake_*: true defaults do not count toward priority_rule 9 "dev VM 実機 smoke" requirement.

Roadmap I/O — Token discipline

Sprint commands MUST read only the slice they need from docs/ROADMAP.json via jq (Bash tool), NOT the whole file via Read. Writes MUST use in-place jq mutation with redirect-and-move, NOT Read + Write of the whole file. Reading or rewriting the whole ROADMAP for a small change is the single largest source of avoidable token waste in this skill.

See references/roadmap-jq.md for the complete reading patterns, write envelope, and named filter table. When a reference file says "Read docs/ROADMAP.json", interpret it as "read the relevant slice"; when it says "update ROADMAP.json", use the appropriate write filter from that table.

Reference Files

  • references/roadmap-jq.md — read this when first touching ROADMAP.json — full jq read/write patterns and named filter table
  • references/sprint-done-judgment.md — canonical 8-guard done judgment (Guard 1–8) applied before any Story can be marked done (the autopilot skill points here; guard 由来 lives in references/done-judgment-rationale.md, read only when auditing/revising the guards)
  • references/sprint-init.md — init command details
  • references/sprint-plan.md — plan command details
  • references/sprint-prototype.md — prototype (HTML mockup for GUI review) command details
  • references/sprint-run.md — run command details
  • references/sprint-verify.md — verify command details
  • references/sprint-demo.md — demo command details
  • references/sprint-refine.md — refine (interactive UI/UX adjustment) command details
  • references/sprint-done.md — done command details
  • references/sprint-fix.md — fix (quick fix without sprint ceremony) command details. Alias: sprint hotfix.
  • references/sprint-help.md — help (command list and usage guide)
  • references/sprint-auto.md — auto (fully autonomous single sprint) command details
  • references/sprint-idea.md — idea (add new features to roadmap) command details. Alias: sprint propose.
  • references/sprint-roadmap.md — roadmap generation from VISION command details
  • references/test-discipline.md — canonical rules for tests: user scenarios, entry-point-driven testing, no-silent-skip, real-browser GUI E2E, status truthfulness. Shared by plan / run / verify / done / auto.
  • references/story-scenarios.md — user scenario taxonomy and templates (CLI / API / GUI / library), referenced from test-discipline.md Rule 1
  • references/gui-spec.md — GUI spec process (state diagrams + Playwright E2E/mock generation from UI Stories). Run from sprint plan / sprint idea. Formerly the standalone gui-spec skill.
  • references/gui-spec-test-generation.md — E2E/mock test-writing rules and endpoint contract format (read before writing any GUI test)
  • references/gui-spec-test-examples.md — E2E and mock test code examples
  • references/time-domain-tests.md — time-domain AC schema, progression-sampler Playwright template, fix workflow (shared by gui-spec, sprint verify, sprint fix)
  • references/ROADMAP_SCHEMA.json — roadmap JSON schema and example (includes the optional Review Mode extension fields)
  • references/SPRINT_LOGS_SCHEMA.json — sprint log JSON schemas (decisions, verify-run, guards-run, run-metrics, verification-results, refine, failures, scenario, gui-spec)
  • references/verify-execution.md — machine-derived test status contract: .claude/verify.json, the run-verify.py wrapper, the sprint done machine gate, the integrity hook (language-agnostic; fixes the fabrication incident)
  • references/VERIFY_RUN_SCHEMA.json — verify-run.json schema (machine-authored test verdict)
  • references/verifier-agent.md — independent verifier sub-agent spec (used by sprint verify --with-verifier)
  • references/VERIFICATION_REPORT_SCHEMA.json — verification-report.json schema (verifier output)
  • references/REOPEN_SCHEMA.json — reopen.json schema (Sprint re-open from autopilot Review Mode ①)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.