Menu
Le prompt qui vérifie d'abord la source est sélectionné par défaut. Vous pouvez passer à une commande directe ou télécharger une copie locale.
Lisez SKILL.md et les fichiers associés affichés par SkillsMP avant de décider de l'installer.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/joris887/exosuit --skill sprint-endLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Execute comprehensive backlog review. Analyzes story quality, Definition of Ready compliance, dependencies, zombie stories, and generates a backlog health report.
First-run framework setup. Detects existing project stack or guides new project creation from vision/braindump.
Use when the user has a complex idea that needs design exploration before story decomposition.
Affichage de SKILL.md
| name | sprint-end |
| version | 2.10.1 |
| description | Use when the user wants to ship a sprint's work to main via PR. |
| trigger | manual |
| depends-on | ["code-quality","test-validator","security-audit"] |
| references | ["references/quality-gates.md","references/error-recovery.md"] |
| micro-components | {"step-1":["discover-commands","verify-clean-git-state"],"step-2":["quality-gate-sequence"]} |
| disable-model-invocation | true |
| user-invocable | true |
| allowed-tools | Read, Glob, Grep, Bash, Edit, Write |
Skill metrics: Emit a start event to the activity log:
echo "{\"type\":\"skill\",\"event\":\"start\",\"skill\":\"sprint-end\",\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" >> docs/sessions/.activity-log.jsonl
Ending the sprint. Discovering and wrapping up all work on the current branch.
Read the **Profile:** line from CLAUDE.md to determine the active project profile.
Skip: Step 2 quality agent dispatch, Step 3 documentation updates (epics, backlog, metrics, context, architecture, PRD review, debt register), ground rules compliance check, ADR compliance check. Tests must still pass — safety is not reduced.
**Strict mode:** All quality gates mandatory — skip the selection AskUserQuestion and run `/quality-check --all` automatically. PR body MUST include an Audit Trail section: files changed, agents run with verdicts, gates passed/failed, coverage delta. Ground rules compliance and ADR compliance checks are mandatory (if files don't exist, flag as a gap). On sprint completion, write a sprint-level audit entry to `docs/sessions/.audit-log.jsonl`: ```json {"type":"sprint-audit","sprint":"","profile":"strict","stories_completed":[""],"agents_run":[""],"gates_passed":true,"coverage_delta":"+N%","ts":""} ```Progress tracking: Create step-level tasks:
At each step boundary, mark current task completed and next task in_progress.
START → 1. Discover Sprint State (from git, no assumptions)
→ [On main or no commits?] → STOP (nothing to ship)
→ 2. Quality Gates (tests, test protection, quality agents)
→ [All gates pass?]
→ NO: Fix issues → re-run gates
→ YES: 3. Documentation Updates (epics, backlog, progress)
→ 3.5. Commit Documentation Artifacts
→ 4. Push and Create PR
→ 5. Wait for CI
→ [CI green?]
→ NO: Fix → push → re-check
→ YES: 6. Merge and Clean Up (squash, delete branch, worktree)
→ 7. Sprint Complete Summary → DONE
At step boundaries, write docs/sessions/.failure-state.md with YAML frontmatter so the Stop hook and /continue can programmatically detect incomplete workflows.
At workflow start (Step 1 entry):
---
status: active
skill: sprint-end
phase: "1"
phase_name: "Discover Sprint State"
started_at: "[ISO-8601 timestamp from date -u +%Y-%m-%dT%H:%M:%SZ]"
story: "[branch name or sprint identifier]"
branch: "[from git branch --show-current]"
next_action: "Discover sprint state from git"
files_modified: []
---
## Context
[Free-form notes — stories in sprint, quality gate status, PR state]
At each step transition: Update the frontmatter fields: phase, phase_name, next_action, and append to files_modified. Update the Context section with current progress.
On successful completion (Step 7 — Sprint Complete): Delete .failure-state.md — clean state means no failure to recover from.
No assumptions about previous context. Discover everything from git.
Check story completion status: Read docs/progress.md for the current story status. If it shows a phase earlier than "DONE" (e.g., "Phase 3 — tests pass, self-review pending"), the last story was only partially completed. Factor this into quality gates — run the missing steps as part of sprint-end rather than flagging them as new issues.
Read the Default branch from CLAUDE.md's Git Workflow section. If not set, detect at runtime:
DEFAULT_BRANCH=$(grep -oP '^\- \*\*Default branch:\*\* \K\S+' CLAUDE.md 2>/dev/null)
if [ -z "$DEFAULT_BRANCH" ]; then
DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@')
fi
if [ -z "$DEFAULT_BRANCH" ]; then
for branch in main master develop; do
if git show-ref --verify --quiet "refs/heads/$branch"; then DEFAULT_BRANCH="$branch"; break; fi
done
fi
Discover from git (using the detected default branch):
git branch --show-current
git log $DEFAULT_BRANCH..HEAD --oneline
git diff --stat $DEFAULT_BRANCH...HEAD
git diff --name-only $DEFAULT_BRANCH...HEAD
If on the default branch: There is no sprint to end. Inform user and stop.
If no commits ahead of the default branch: Nothing to ship. Inform user and stop.
If in a worktree: Detect with git rev-parse --git-common-dir. Note the worktree path for cleanup in step 6.
Child stream check (parallel work): Discover any streams fanned out from this branch by /parallel-work:
# Branches whose recorded parent is the current branch.
# Note: git canonicalizes config keys to lowercase in --get-regexp output.
git config --get-regexp '^branch\..*\.exosuitparent$' 2>/dev/null \
| awk -v P="$(git branch --show-current)" '$2==P {print $1}' \
| sed 's/^branch\.//; s/\.exosuitparent$//'
For each child branch found, count work not yet merged into this branch:
git rev-list --count HEAD..<child-branch>
"Stream
<child>has [N] commits not merged into this sprint branch. Run/merge-upinside its worktree first, or explicitly confirm abandoning that work." Proceed only when every child is merged or the user has explicitly abandoned it.
git worktree list --porcelain, for cleanup in step 6.Analyze: branch name, all commits since branching, all files changed, stories completed (parse from commit messages).
Check CLAUDE.md Commands for a dev: command. If one is configured:
run_in_background: true), show whatever output it produces (URLs, status, CLI output — do NOT assume localhost), let user verifyThis catches visual/UX issues that automated tests don't cover. Advisory, not blocking.
Mindset: Assume there are problems. Your job is to find them. Your first assessment is almost never "all clear."
If the user deselects any: "Note: skipping gates may allow issues to reach main. All gates recommended for production sprints."
Dispatch quality gates via /quality-check:
/quality-check (defaults to code + tests + security based on profile)/quality-check --all/quality-check --code --security (any combination of flags)The /quality-check skill handles parallel agent dispatch, profile-aware defaults, and unified reporting. See .claude/skills/quality-check/SKILL.md for details.
Do NOT use native agents (.claude/agents/code-reviewer.md, .claude/agents/security-analyst.md) for static quality gates — use the skill-based dispatch through /quality-check.
Exception — integration-tester: For "All quality gates" or strict profile, /quality-check --all automatically includes the integration-tester agent.
Run only selected gates. The HARD-GATE still applies: if /quality-check returns FAIL, do NOT proceed.
Read references/quality-gates.md for detailed checks (tests, test protection, quality agents with scope-based scaling, recovery). For error recovery during this step, consult references/error-recovery.md — search for ## Step 2.
Compliance ledger: Record results in the sprint spec's ## Outcome → Ground rules field (e.g., "5/5 checked, Clean" or "5/5 checked, 1 violation: [description]"). This data is available to /retrospective for longitudinal compliance analysis.
UAT Coverage: X/Y pass | Z untested | W fail
Critical untested: [list or "none"]
Based on what was done in the sprint, update relevant documentation:
docs/reference/backlog/E##-*.md):
- [ ] ID — Title (P#, in-progress) → - [x] ID — Title (P#, done)**Status:** done[DONE] if epic uses old markersecho "{\"type\":\"story\",\"event\":\"status-change\",\"id\":\"<story-id>\",\"from\":\"review\",\"to\":\"done\",\"story_type\":\"<type>\",\"size\":\"<size>\",\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" >> docs/sessions/.activity-log.jsonl
created: date >2 sprint cycles old still not done)docs/sprints/sprint-N.md):
## Outcome section with metrics:
git show $(git log --oneline --diff-filter=A -- docs/sprints/sprint-N.md | tail -1 | cut -d' ' -f1):docs/sprints/sprint-N.md)## Current Sprint to show completed stategit log --numstat to find lines modified within 14 days of creation / total lines (or use scripts/pm/metrics.sh --churn)docs/sessions/.activity-log.jsonl — compute skill success rate and context reset frequency (or use scripts/pm/metrics.sh --ai-effectiveness)## Sprint History: | N | [goal] | ✅/❌ | X | X.Xd | X% | +X% | 0.XX | 0.XX | X/5 | #N |## Metrics table: For each metric row, update the Current column with this sprint's value. Recompute Trend sparklines from the last 6 Sprint History rows (use ▁▂▃▄▅▆▇█ — map values to 8 levels; for lower-is-better metrics like cycle time/CFR/churn, invert so up=improving). Compute Status using BOTH absolute and relative thresholds:
scripts/pm/metrics.sh --churn and include the top 3 hotspot files in the note (e.g., "Churn 🟡 — hotspots: src/auth/session.ts (7 changes), src/api/routes.ts (5 changes)").## Next Steps with post-sprint actionsdocs/context/): If sprint changes affect architecture, patterns, or tech stack, incrementally update the relevant context files (use git diff $DEFAULT_BRANCH...HEAD --name-only to identify affected areas). Update updated: timestamps in YAML frontmatter.docs/context/system-patterns.md): Review commit messages and story plans from this sprint for pattern-related changes. If any story introduced a new implementation pattern, established a new convention, or changed the error handling/testing approach, update the relevant section. Add new implementation recipes when a repeated entity type was added for the first time (e.g., first API endpoint, first background job). Remove patterns for approaches no longer used.docs/architecture/ARCHITECTURE.md): If any story in this sprint changed architecture (check the Update Triggers section), verify the doc was updated during story-cycle Phase 4e. If not, update it now and set Last Verified date to today.sbom.json to reflect current dependencies. If no SBOM tool is available, skip — note "SBOM generation: no tool available" in the PR body. This is informational, not blocking.docs/technical-debt.md):
origin: ai-generatedActive items: X | Resolved this quarter: Y## Outcome: Debt delta: +N added / -N resolved (net: +/-N). This data feeds into /retrospective for trend analysis.If docs/reference/PRD_SUMMARY.md exists, review it against sprint learnings:
If changes are needed, update PRD_SUMMARY.md and bump the version in the header comment.
If docs/context/personas.md exists and user-facing stories were delivered this sprint: check the Persona Assumptions table. Were any assumptions validated or invalidated by this sprint's work? Update their Confidence column (ASSUMED → CONFIRMED or INVALIDATED) with a brief note of the evidence. Bump the updated: date in frontmatter.
Skip when: No user-facing stories were delivered (pure infrastructure/refactoring sprint), or personas.md doesn't exist.
Commit all documentation changes as a separate commit. This ensures documentation is preserved even if the push or PR step fails or is skipped.
# Check if there are uncommitted documentation changes
if ! git diff --quiet docs/ CLAUDE.md 2>/dev/null || \
! git diff --quiet --cached docs/ CLAUDE.md 2>/dev/null || \
git ls-files --others --exclude-standard docs/ | grep -q .; then
git add docs/ CLAUDE.md
git commit -m "docs(sprint): update sprint documentation and session artifacts
Co-Authored-By: Claude <noreply@anthropic.com>"
fi
If there are no documentation changes, skip this step gracefully. This commit happens regardless of whether push will be performed.
LINES_CHANGED=$(git diff --stat $DEFAULT_BRANCH...HEAD | tail -1 | grep -oE '[0-9]+ insertion|[0-9]+ deletion' | grep -oE '[0-9]+' | paste -sd+ | bc 2>/dev/null || echo "0")
If LINES_CHANGED exceeds 400 lines, warn:
Large PR detected ([LINES_CHANGED] lines changed). Research shows PRs in the 200–400 line range have 40% fewer defects, and each additional 100 lines adds ~25 minutes of review time. Consider breaking this into stacked PRs for more effective review.
Offer to proceed as-is or help split the PR.
By story: Create one PR per completed story. Cherry-pick each story's commits to a new branch:
git checkout $DEFAULT_BRANCH
git checkout -b feat/<story-description>
git cherry-pick <story-commit-hashes>
git push -u origin feat/<story-description>
gh pr create --title "<type>(<scope>): <story summary>"
Repeat for each story. Each PR should be ≤400 LOC.
By layer: Split into backend/frontend/infrastructure PRs if changes span layers.
By module: Split into separate PRs per module or package boundary.
Create split PRs in dependency order so CI passes on each. Reference the sprint spec in each PR for context. See docs/reference/GIT_WORKFLOW.md → Stacked PRs for advanced tooling.
git push -u origin $(git branch --show-current)
Create PR with GitHub CLI. The repository includes a PR template (.github/pull_request_template.md) — fill in its sections rather than providing a raw body:
gh pr create --title "<type>(<scope>): <summary>" --body "$(cat <<'EOF'
## Type of Change
- [x] <matching type from template>
## Summary
<1-3 sentences summarizing what was done and why>
## Changes
<list of key changes, grouped by area>
## Test Evidence
<paste test output from step 2>
## Quality Gates
- [x] All tests pass
- [x] Test count did not decrease
- [x] Code quality agent reviewed
- [x] Test validator agent reviewed
- [x/n/a] Security audit reviewed
- [x] No hardcoded secrets introduced
- [x] Coding standards followed
## Self-Review Checklist
- [x] I read the diff and it matches the intent
- [x] No debug code or TODOs left behind
- [x] Error handling is appropriate
- [x] New code follows existing patterns
- [x/n/a] Documentation updated where needed
## AI Assistance
- **AI-assisted:** <list components where AI generated or significantly modified code>
- **Human-written:** <list components written or heavily edited by hand, or "N/A">
- **AI review focus:** <specific areas where reviewers should check for AI anti-patterns>
Generated with [Claude Code](https://claude.com/claude-code)
EOF
)"
Note: The framework includes a Claude PR Review workflow (.github/workflows/claude-pr-review.yml). If configured with an ANTHROPIC_API_KEY secret, it runs automated code review on PRs. Check its status alongside other CI checks.
No CI detected — the local quality gates in step 2 serve as verification. Proceed to merge.
gh pr view --json reviewRequests,reviews
If human review is required:
docs/reference/TEAM_WORKFLOW.md → Code Review Process):
gh pr edit --add-reviewer <reviewer>
**Human review required before merge.**
- Reviewer(s): [list]
- Status: [Pending / Approved / Changes Requested]
Options:
→ Wait for review (recommended)
→ Continue to other work while waiting (`/story-cycle` or `/sprint-start --worktree`)
If no human review required: Proceed to merge.
Child stream cleanup (before the merge, while still on the sprint branch): For each merged child stream noted in step 1:
git worktree remove <child-worktree-path> # fails if the worktree is dirty — resolve first
git branch -d <child-branch> # safe delete works: the child is merged into this branch
git config --remove-section branch.<child-branch> 2>/dev/null || true
This must happen before switching to the default branch — after the squash merge, git branch -d would no longer recognize the children as merged. For any stream the user chose to abandon (unmerged commits), leave its branch in place and report it: safe delete will refuse, and force-deleting branches is blocked by the framework's git hooks on purpose. The user can delete it manually once they are certain.
Once CI is green (or local gates passed) and any required reviews are complete:
gh pr merge --squash --delete-branch
git checkout $DEFAULT_BRANCH
git pull origin $DEFAULT_BRANCH
git worktree prune
Worktree cleanup (if running in a worktree detected in step 1):
WORKTREE_PATH=$(pwd)
cd <main-worktree-path>
git worktree remove "$WORKTREE_PATH"
git worktree prune
Inform the user that the worktree has been removed and they should close the Claude Code instance that was using it.
Verify clean state:
git status
git log --oneline -3
Skill metrics: Emit a completion event:
echo "{\"type\":\"skill\",\"event\":\"end\",\"skill\":\"sprint-end\",\"outcome\":\"success\",\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" >> docs/sessions/.activity-log.jsonl
### Sprint Complete
**Sprint [N]: [goal]**
**Goal achieved:** [yes/no]
**Branch:** `sprint-<number>` (merged and deleted)
**PR:** #<number> (<url>)
**Stories:** [completed]/[total] delivered
**Throughput:** [X] stories | **Churn:** [X]%
**Tests:** [total] passing ([+delta] vs main) | **Coverage:** [X]%
**Carried over:** [count] stories
- [Goal-critical]: [list — these threaten the sprint goal, prioritize in next sprint]
- [Non-critical]: [list — correct prioritization, schedule when ready]
Non-critical carry-over is a positive signal — it means the team correctly prioritized goal-critical work over lower-priority items.
**Main is clean and up to date.**
**Sprint spec:** `docs/sprints/sprint-<number>.md`
**Next Steps:**
→ `/retrospective` — review sprint metrics and process
→ `/sprint-start` — begin the next sprint
→ `/handoff` — if ending the session
| Dependency | If Missing |
|---|---|
| Sub-agents | Run quality checks manually in the main context |
| CI pipeline | Local quality gates (step 2) serve as verification |
| Test runner | Warn user, skip test count delta, note in PR body |
| Linter | Skip lint check, note in PR body |
| Type checker | Skip typecheck, note in PR body |
gh CLI | Push manually, create PR via web UI |
Read CLAUDE.md Commands section before running quality gates (or use the discover-commands micro-component from .claude/prompts/discover-commands.md):
docs/reference/CODING_STANDARDS.md