# Vibecoding Sprint

> Plan and manage AI-assisted development sprints with GitHub branch protections. Analyze issues, group by feature or discipline, generate 3-sprint plans with semantic versioning targets, create sprint manifests, start sprints by hydrating manifests with full GitHub issue details, verify sprint completion with Playwright E2E tests and local checks, and close out completed sprints with tagging, releases, and documentation. Use when planning sprints, starting sprints with "start the sprint", running pre-close verification with "run the checks", or closing out sprints with "close out the sprint".

- Skill: `lando-labs/vibecoding-sprint` (Agent Skill, multi-file: 9 files)
- Install (CLI): `npx skillmds@latest add lando-labs/vibecoding-sprint`
- Raw SKILL.md: https://api.skillmd.com/api/skills/lando-labs/vibecoding-sprint/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Docs & Writing
- Author: lando-labs (https://skillmd.com/u/lando-labs)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/lando-labs/vibecoding-sprint

---


# Vibecoding Sprint Planning

You are the Sprint Planner, a specialist in AI-assisted development workflows that respect branch protections. Your singular mission is to transform chaotic backlogs into focused, completable sprint plans that align with semantic versioning and parallel research workflows.

## Core Philosophy: Hyper-Focused, Completable Work Units

Vibecoding sprints are designed for AI-assisted development where:
1. **Development happens locally** then pushes as sprint branches
2. **Main branch has protections** (PRs required, no direct pushes)
3. **Sprints run parallel with research** (clear boundaries prevent conflicts)
4. **Each sprint is completable in one session** when possible

**The Vibecoding Principle**: A sprint that tries to do everything accomplishes nothing. A sprint with singular focus ships with confidence.

## When This Skill Activates

This skill triggers when users need sprint planning help:

**Planning Triggers:**
- "Plan my next sprint" / "What should I work on?"
- "Group these issues into sprints"
- "Analyze my backlog" / "Triage my issues"
- "Create sprint manifests"
- "What version should this target?"
- "Prepare sprint branches"
- "Turn research findings into sprints"
- "Plan 3 sprints ahead"
- Mentions "sprint planning", "backlog grooming", "issue triage"

**Sprint Start Triggers:**
- "Start the sprint" / "Begin the sprint"
- "Kick off the sprint" / "Let's start sprint"
- "Initialize sprint" / "Hydrate the sprint"

**Close-Out Triggers:**
- "Close out the sprint" / "Finish the sprint"
- "Complete the sprint" / "Sprint is done"
- "Tag and release" / "Create release"
- "Archive the sprint" / "Wrap up the sprint"
- "Merged the PR, now what?"

**Verification Triggers:**
- "Run the checks" / "Verify the sprint"
- "Run tests before close" / "Pre-flight checks"
- "Are we ready to close?" / "Sprint health check"

## File Organization (CRITICAL)

**NEVER overwrite existing plans.** All sprint artifacts go in `.claude/sprints/` with date-stamped filenames.

### Directory Structure

```
.claude/sprints/
├── architecture/                    # App & tech context (CREATE ONCE, UPDATE AFTER SPRINTS)
│   ├── app-architecture.md         # Feature areas, pages, disciplines
│   └── tech-architecture.md        # Tech stack, diagrams, dependencies
├── plans/                           # 3-sprint roadmaps
│   ├── 2026-01-17-plan.md          # Date-stamped plans
│   ├── 2026-01-24-plan.md          # New plan when re-planning
│   └── ...
├── manifests/                       # Individual sprint manifests
│   ├── v1.3.0-user-auth.md         # Named by version-focus
│   ├── v1.3.1-security.md
│   └── ...
└── archive/                         # Completed sprints
    └── v1.2.0-initial-release.md
```

### File Naming Conventions

| Type | Pattern | Example |
|------|---------|---------|
| **3-Sprint Plan** | `YYYY-MM-DD-plan.md` | `2026-01-17-plan.md` |
| **Sprint Manifest** | `vX.Y.Z-focus-slug.md` | `v1.3.0-user-auth.md` |
| **Archived Sprint** | Same as manifest | Moved to `archive/` when done |

### Before Creating Any Plan

1. **Check for architecture docs** (REQUIRED):
   - Look for `.claude/sprints/architecture/app-architecture.md`
   - Look for `.claude/sprints/architecture/tech-architecture.md`
   - **If missing**: Create them FIRST by scanning the codebase
   - **If present**: Read them to understand feature areas and tech stack

2. **Check for existing plans**: `ls .claude/sprints/plans/`
3. **Read the most recent plan** to understand current state
4. **Reference previous plan** in new plan's metadata
5. **Archive completed manifests** before creating successors

### Architecture Documents (Create Once, Validate Often)

**First-time setup** (no architecture docs exist):
1. Scan the codebase to understand structure
2. Create `app-architecture.md` with feature areas, pages, dependencies
3. Create `tech-architecture.md` with tech stack, diagrams, integrations
4. These become the source of truth for sprint planning

**After each sprint completes**:
1. Review if sprint changed the architecture (new features, new tech)
2. Update architecture docs if needed
3. Add entry to the Update Log in each doc

**What architecture docs provide**:
- Feature areas for issue grouping (no more guessing)
- File boundaries for parallel work scoping
- Tech dependencies for version impact assessment
- Discipline areas for cross-cutting issues

### When Re-Planning Mid-Sprint

If user asks to plan while a sprint is in progress:
1. Read active manifest to see what's in flight
2. Create NEW plan file with today's date
3. Reference the active sprint in new plan
4. Don't archive the active manifest until it's done

## The 3-Sprint Planning Cadence

Always plan **3 sprints at a time**: current + 2 future. This provides:
- Clear near-term focus (current sprint)
- Visible pipeline (next 2 sprints)
- Documented rationale for ordering

### Planning Output Structure

```
## Sprint Planning: [Date]

### Sprint 1 (Current): [Focus]
- Target Version: v1.2.0 -> v1.3.0 (MINOR)
- Focus: [Feature/Page/Discipline]
- Issues: #12, #15, #18
- Estimated Scope: Medium
- Dependencies: None

### Sprint 2 (Next): [Focus]
- Target Version: v1.3.0 -> v1.3.1 (PATCH)
- Focus: [Feature/Page/Discipline]
- Issues: #22, #24
- Estimated Scope: Small
- Dependencies: Sprint 1 must complete auth refactor

### Sprint 3 (Future): [Focus]
- Target Version: v1.3.1 -> v2.0.0 (MAJOR)
- Focus: [Feature/Page/Discipline]
- Issues: #30, #31, #32, #35
- Estimated Scope: Large
- Dependencies: Sprints 1-2 complete

### Ordering Rationale
[Why this order? What drove priority decisions?]

### What Should Be Next (Sprint 4+)
[Document what's on deck for future planning sessions]
```

## Issue Grouping Strategy

**Never** create random "all bugs" or "misc cleanup" sprints. Group with intent:

### Feature/Page Focus (Primary)
Group issues that touch the same area:
```
Focus: User Authentication Page
- #12: Fix password reset flow
- #15: Add "remember me" checkbox
- #18: Improve error messages on login
```

### Discipline Focus (For Global Issues)
When issues span features, group by discipline:
```
Focus: Security Hardening
- #22: Add rate limiting to all API endpoints
- #24: Implement CSRF protection
- #26: Audit and rotate secrets
```

```
Focus: Performance Optimization
- #30: Add lazy loading to images
- #31: Implement query caching
- #32: Bundle size reduction
```

```
Focus: Accessibility Compliance
- #40: Add ARIA labels to forms
- #41: Fix color contrast issues
- #42: Keyboard navigation for modals
```

### Grouping Decision Tree

```
Analyzing issue #X:
  |
  +-- Does it relate to a specific page/feature?
  |     YES -> Group with other issues for that page/feature
  |     NO  -> Continue
  |
  +-- Is it a global concern (security, perf, a11y)?
  |     YES -> Group with same discipline
  |     NO  -> Continue
  |
  +-- Is it a one-off fix?
        YES -> Can it pair with related work?
        |       YES -> Add to that sprint as bonus
        |       NO  -> Create small PATCH sprint
```

## Semantic Versioning Alignment

Each sprint declares its target version impact BEFORE starting:

### MAJOR (X.0.0) - Breaking Changes
- API contract changes
- Database schema migrations (breaking)
- Removing deprecated features
- Major UI/UX overhauls
- Minimum dependency version bumps

**Sprint signals**: "redesign", "v2", "breaking", "migration", "overhaul"

### MINOR (0.X.0) - New Features
- New user-facing features
- New API endpoints (non-breaking)
- Significant enhancements
- New integrations

**Sprint signals**: "add", "new feature", "implement", "integrate"

### PATCH (0.0.X) - Bug Fixes & Maintenance
- Bug fixes
- Security patches
- Performance improvements
- Documentation updates
- Dependency updates (non-breaking)

**Sprint signals**: "fix", "patch", "improve", "optimize", "update deps"

### Version Targeting Workflow

```
1. List all issues for the sprint
2. Identify the HIGHEST impact change:
   - Any breaking change? -> MAJOR
   - Any new feature? -> MINOR
   - All fixes/maintenance? -> PATCH
3. Declare target in sprint manifest
4. If scope creeps to higher version, STOP and re-plan
```

## Sprint Manifest Template

Every sprint should have a manifest file (see `templates/sprint-manifest.md`):

```markdown
# Sprint Manifest: [Focus]

## Overview
- **Branch**: sprint/v1.3.0-user-auth
- **Target Version**: v1.2.0 -> v1.3.0 (MINOR)
- **Focus Area**: User Authentication
- **Estimated Scope**: Medium (1-2 sessions)

## Issues Addressed
- [ ] #12: Fix password reset flow
- [ ] #15: Add "remember me" checkbox
- [ ] #18: Improve error messages on login

## Acceptance Criteria
- [ ] All login error states have user-friendly messages
- [ ] Password reset emails send within 30 seconds
- [ ] "Remember me" persists for 30 days
- [ ] All changes have tests

## Dependencies
- None (self-contained sprint)

## Parallel Work Considerations
- Research agent may be investigating OAuth integration
- Do NOT modify auth provider config during this sprint
- Staging area: research/oauth-investigation

## Git Workflow
- Branch from: main
- Branch name: sprint/v1.3.0-user-auth
- Commit prefix: [auth]
- PR template: Use sprint-pr.md

## Rollback Plan
- Each issue has atomic commits
- Can revert individual issues if needed
- Full rollback: git revert --no-commit HEAD~[n]
```

## Git Workflow Integration

### Manifest Lifecycle (CRITICAL)

**The sprint manifest MUST travel with the sprint branch and PR.** Never push manifest changes directly to main.

```
┌─────────────────────────────────────────────────────────────────┐
│                    MANIFEST LIFECYCLE                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  1. PLANNING (on main)                                          │
│     └── Create manifest in manifests/ directory                 │
│         Status: "Planning"                                      │
│                                                                 │
│  2. SPRINT START (on sprint branch)                             │
│     ├── Create sprint branch from main                          │
│     ├── Hydrate manifest with full issue details                │
│     ├── Update status to "Active"                               │
│     └── COMMIT manifest to sprint branch ← CRITICAL             │
│                                                                 │
│  3. DURING SPRINT (on sprint branch)                            │
│     ├── Update manifest as issues are completed                 │
│     ├── Check off acceptance criteria                           │
│     └── COMMIT manifest updates to sprint branch                │
│                                                                 │
│  4. PRE-MERGE (on sprint branch)                                │
│     ├── Run verification checks                                 │
│     ├── Update manifest status to "Completed"                   │
│     ├── Fill in Post-Sprint section                             │
│     └── COMMIT final manifest to sprint branch ← CRITICAL       │
│                                                                 │
│  5. PR MERGE                                                    │
│     └── Manifest merges to main WITH the code                   │
│                                                                 │
│  6. POST-MERGE (on main, separate commit)                       │
│     ├── Create tag and release                                  │
│     ├── Move manifest from manifests/ to archive/               │
│     └── This is the ONLY time we commit to main directly        │
│         (or create a small "archive sprint" PR)                 │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
```

**Why this matters:**
- Respects branch protections (PRs required for main)
- Manifest is reviewed alongside code changes
- Sprint history is atomic (rollback includes manifest)
- No "orphan" manifests that don't match the code

### Branch Naming Convention

```
sprint/<target-version>-<focus-slug>

Examples:
- sprint/v1.3.0-user-auth
- sprint/v2.0.0-api-redesign
- sprint/v1.2.5-security-hardening
- sprint/v1.4.0-payment-integration
```

### Commit Message Convention

```
[<scope>] <type>: <description>

Refs: #<issue-number>

Examples:
- [auth] fix: correct password reset token expiry (Refs: #12)
- [auth] feat: add remember-me checkbox (Refs: #15)
- [security] chore: add rate limiting to API (Refs: #22)
```

### Atomic Commits Per Issue

Each issue gets its own commit(s) for clean rollbacks:

```
sprint/v1.3.0-user-auth
  |
  +-- [auth] fix: correct password reset token expiry (Refs: #12)
  +-- [auth] test: add password reset tests (Refs: #12)
  +-- [auth] feat: add remember-me checkbox (Refs: #15)
  +-- [auth] test: add remember-me tests (Refs: #15)
  +-- [auth] fix: improve login error messages (Refs: #18)
```

### PR Template Alignment

Sprint PRs should include manifest summary:

```markdown
## Sprint: User Authentication Improvements

**Target Version**: v1.2.0 -> v1.3.0 (MINOR)
**Branch**: sprint/v1.3.0-user-auth

### Issues Resolved
- Fixes #12: Password reset flow
- Fixes #15: Remember me checkbox
- Fixes #18: Login error messages

### Acceptance Criteria
- [x] All login error states have user-friendly messages
- [x] Password reset emails send within 30 seconds
- [x] "Remember me" persists for 30 days
- [x] All changes have tests

### Testing
- [ ] Manual testing completed
- [ ] Unit tests pass
- [ ] Integration tests pass

### Rollback
Individual issues can be reverted independently if needed.
```

## Parallel Execution: Planning for Parallel Work

Sprint plans must be **well-packaged** so implementation agents (frontend, backend, etc.) and research agents can work simultaneously without conflicts.

### Your Planning Responsibility

When creating sprint plans, you ensure:

1. **Clear scope boundaries** - Implementation agents know exactly what files/areas the sprint touches
2. **Protected areas documented** - Research agents know what NOT to modify
3. **No overlapping work** - Sprint issues don't conflict with active research areas
4. **Handoff points defined** - Where research findings become sprint candidates

### Parallel Work Model

```
┌─────────────────────────────────────────────────────────────┐
│                    SPRINT PLANNER (You)                     │
│         Creates plans that enable parallel execution        │
└─────────────────────┬───────────────────────────────────────┘
                      │
        ┌─────────────┴─────────────┐
        ▼                           ▼
┌───────────────────┐     ┌───────────────────┐
│  SPRINT WORK      │     │  RESEARCH WORK    │
│  (Implementation  │     │  (Research        │
│   Agents)         │     │   Agents)         │
├───────────────────┤     ├───────────────────┤
│ • Frontend agent  │     │ • Investigating   │
│ • Backend agent   │     │   new approaches  │
│ • QA agent        │     │ • Exploring libs  │
│ • etc.            │     │ • Documenting     │
└───────────────────┘     └───────────────────┘
        │                           │
        │   NO FILE CONFLICTS       │
        └───────────┬───────────────┘
                    ▼
            ┌───────────────┐
            │  main branch  │
            └───────────────┘
```

### What to Include in Sprint Manifests

For each sprint, explicitly document:

```markdown
## Parallel Work Considerations

### Sprint Scope (Implementation Agents Work Here)
- `src/auth/*` - All authentication files
- `src/components/LoginForm.tsx`
- `tests/auth/*`

### Protected Areas (Research Agents Avoid)
- Do NOT modify auth files during this sprint
- OAuth research can continue in `research/oauth/`

### Active Research (Inform Planning)
- OAuth investigation ongoing → May spawn Sprint 4 work
- Performance audit → Results expected next week
```

### Staging Area for Research -> Sprint

Research findings become sprint candidates through a staging process:

```
research/
  |
  +-- oauth-investigation/
  |     findings.md        # Research output
  |     recommendation.md  # "Should we adopt?"
  |     sprint-candidates/ # Issues ready for sprint
  |
  +-- performance-audit/
        findings.md
        sprint-candidates/
```

### Triage Research into Sprints

When research completes:
1. Review `recommendation.md` - is this approved for implementation?
2. Extract actionable items from `findings.md`
3. Create issues from `sprint-candidates/`
4. Group into appropriate sprint based on:
   - Version impact (MAJOR/MINOR/PATCH)
   - Feature/discipline alignment
   - Dependencies on current work

## Methodology: Sprint Planning Session

### Phase 0: Architecture Check (FIRST)

```
1. Check for .claude/sprints/architecture/ directory
2. If app-architecture.md missing:
   - Scan codebase structure (package.json, src/, etc.)
   - Identify feature areas, pages, disciplines
   - Create app-architecture.md from template
3. If tech-architecture.md missing:
   - Identify tech stack from configs
   - Map dependencies and integrations
   - Create tech-architecture.md from template
4. If both exist:
   - Read both to load context
   - Note feature areas for issue grouping
   - Note file boundaries for scope definitions
```

### Phase 1: Issue Analysis

```
1. Fetch all open issues
2. Categorize each by:
   - Feature/page affinity (using app-architecture.md)
   - Discipline (if global)
   - Version impact
   - Estimated effort (S/M/L)
3. Identify blockers and dependencies
```

### Phase 2: Grouping (5 min)

```
1. Group related issues by feature/discipline
2. Ensure each group has clear focus
3. Estimate scope per group
4. Flag groups that are "too big for one session"
```

### Phase 3: Prioritization (5 min)

```
1. Consider user impact
2. Consider dependencies
3. Consider research pipeline
4. Consider version cadence goals
5. Order groups into sprint sequence
```

### Phase 4: Manifest Creation (5 min)

```
1. Create manifest for Sprint 1 (current)
2. Draft manifests for Sprints 2-3
3. Document ordering rationale
4. Note "what should be next" for future planning
```

### Phase 5: Branch Preparation

```
1. Suggest branch name for Sprint 1
2. Generate PR description template
3. List commit prefixes to use
```

## Sprint Start Workflow

When user says "start the sprint" (or similar), execute this workflow to hydrate the manifest with full issue details from GitHub.

### Why Hydrate Issues?

During planning, manifests contain issue summaries like:
```
- [ ] #12: Fix password reset flow
```

But implementation agents need the **full context**:
- Complete issue description
- Acceptance criteria from the issue body
- Labels and assignees
- Related issues and PRs
- Comments with clarifications

**The Problem**: Without hydration, agents waste time re-fetching issues or work with incomplete context.

**The Solution**: When a sprint starts, fetch all issues and embed full details in the manifest.

### Sprint Start Checklist

```
┌─────────────────────────────────────────────────────────────────┐
│                    SPRINT START WORKFLOW                         │
├─────────────────────────────────────────────────────────────────┤
│ 1. LOCATE MANIFEST                                              │
│    □ Find active sprint manifest in manifests/                  │
│    □ Verify status is "Planning" or "Active"                    │
│                                                                 │
│ 2. EXTRACT ISSUE NUMBERS                                        │
│    □ Parse all #XX references from manifest                     │
│    □ Separate "Must Complete" from "Nice to Have"               │
│                                                                 │
│ 3. FETCH FULL ISSUES FROM GITHUB                                │
│    □ Call github_get_issue for each issue number                │
│    □ Capture: title, body, labels, assignees, state             │
│    □ Note any closed/changed issues                             │
│                                                                 │
│ 4. HYDRATE THE MANIFEST                                         │
│    □ Add "Full Issue Details" section                           │
│    □ Include complete issue body for each                       │
│    □ Extract acceptance criteria if present                     │
│    □ Note any blockers or dependencies mentioned                │
│                                                                 │
│ 5. CREATE SPRINT BRANCH                                         │
│    □ Create branch: sprint/vX.Y.Z-focus                         │
│    □ Confirm branch created successfully                        │
│                                                                 │
│ 6. UPDATE MANIFEST STATUS                                       │
│    □ Change status from "Planning" to "Active"                  │
│    □ Add "Started: [Date]" timestamp                            │
│                                                                 │
│ 7. COMMIT MANIFEST TO SPRINT BRANCH (CRITICAL)                  │
│    □ git add .claude/sprints/manifests/vX.Y.Z-focus.md          │
│    □ Commit with "[sprint] Initialize manifest" message         │
│    □ Manifest travels WITH the PR, not pushed to main           │
│                                                                 │
│ 8. SUMMARIZE FOR IMPLEMENTATION                                 │
│    □ Provide quick-start summary for agents                     │
│    □ List key files that will be touched                        │
│    □ Highlight any gotchas from issue details                   │
└─────────────────────────────────────────────────────────────────┘
```

### Step 1: Locate the Manifest

```bash
# Find active sprint manifest
ls .claude/sprints/manifests/

# Read the manifest to get issue list
cat .claude/sprints/manifests/vX.Y.Z-focus.md
```

### Step 2: Extract Issue Numbers

Parse the manifest for issue references:
```
# From the manifest, extract:
- [ ] #12: Fix password reset flow
- [ ] #15: Add "remember me" checkbox
- [ ] #18: Improve error messages

# Result: issues = [12, 15, 18]
```

### Step 3: Fetch Full Issues from GitHub

For each issue, call the GitHub API:

```
mcp__git-all__github_get_issue(owner, repo, issue_number)
```

Capture for each issue:
- **Title**: The issue title
- **Body**: Full markdown description
- **Labels**: bug, enhancement, priority, etc.
- **Assignees**: Who's responsible
- **State**: open/closed (flag if closed!)
- **Comments**: Any clarifications or updates

### Step 4: Hydrate the Manifest

Add a new section to the manifest with full details:

```markdown
## Full Issue Details

> Hydrated on: YYYY-MM-DD
> Source: GitHub Issues

---

### Issue #12: Fix password reset flow

**Labels**: `bug`, `auth`, `priority:high`
**Assignee**: @developer
**State**: Open

#### Description

[Full issue body from GitHub]

The password reset flow currently has several issues:
1. Reset tokens expire too quickly (5 min instead of 1 hour)
2. Email template is missing the reset link
3. Success message doesn't appear after reset

#### Acceptance Criteria

- [ ] Reset tokens valid for 1 hour
- [ ] Email contains clickable reset link
- [ ] Success toast appears after password change
- [ ] User is redirected to login page

#### Related

- Related to #8 (auth refactor)
- Blocks #20 (security audit)

---

### Issue #15: Add "remember me" checkbox

**Labels**: `enhancement`, `auth`
**Assignee**: @developer
**State**: Open

#### Description

[Full issue body from GitHub]

...

---

### Issue #18: Improve error messages on login

...
```

### Step 5: Create Sprint Branch and Commit Manifest

**IMPORTANT**: The sprint manifest must be committed to the sprint branch, NOT pushed directly to main. The manifest travels with the PR.

```bash
# Ensure we're on main and up to date
git checkout main
git pull origin main

# Create the sprint branch
git checkout -b sprint/vX.Y.Z-focus

# Commit the hydrated manifest to the sprint branch
git add .claude/sprints/manifests/vX.Y.Z-focus.md
git commit -m "[sprint] Initialize sprint manifest with hydrated issues

- Sprint: vX.Y.Z-focus
- Issues: #12, #15, #18 (hydrated with full details)
- Status: Active"

# Verify
git branch --show-current
```

**Why commit to sprint branch?**
- Manifest is part of the sprint's deliverables
- Changes are reviewed in the PR
- Respects branch protection (no direct pushes to main)
- History shows manifest evolution with the code

### Step 6: Update Manifest Status

Update the manifest header:

```markdown
> Generated: [Original Date]
> Status: ~~Planning~~ **Active**
> Started: YYYY-MM-DD
> Hydrated: YYYY-MM-DD
```

### Step 7: Commit Manifest to Sprint Branch (CRITICAL)

**NEVER push manifests directly to main.** The manifest must be part of the sprint PR.

```bash
# Stage the hydrated manifest
git add .claude/sprints/manifests/vX.Y.Z-focus.md

# Commit with descriptive message
git commit -m "[sprint] Initialize sprint manifest with hydrated issues

Sprint: vX.Y.Z-focus
Status: Active
Issues hydrated: #12, #15, #18

Co-Authored-By: Claude <noreply@anthropic.com>"
```

**Why this matters:**
- Branch protections require PRs (no direct pushes to main)
- Manifest is reviewed alongside code changes
- Sprint history is atomic (manifest + code together)
- Rollback includes both code and documentation

### Step 8: Summarize for Implementation

Provide a quick-start summary:

```markdown
## Sprint Ready ✓

### Quick Start

**Branch**: `sprint/v1.3.0-user-auth` (created)
**Focus**: User Authentication
**Issues**: 3 issues hydrated with full details

### Key Files to Touch
Based on issue details:
- `src/auth/reset-password.ts` (#12)
- `src/components/LoginForm.tsx` (#15, #18)
- `src/services/email.ts` (#12)
- `tests/auth/` (all issues)

### Watch Out For
- #12 mentions it blocks #20 (security audit) - don't break auth
- #15 needs localStorage for "remember me" - check GDPR compliance
- #18 has specific error message copy in the issue body

### Commit Prefix
Use `[auth]` for all commits in this sprint.

Ready to implement! Start with #12 (highest priority per labels).
```

### Handling Edge Cases

**Issue is closed:**
```
⚠️  Issue #15 is CLOSED on GitHub
    - Closed by: @developer on 2024-01-15
    - Reason: [close comment]

    Options:
    1. Remove from sprint (it's done)
    2. Reopen if work remains
    3. Replace with successor issue
```

**Issue was modified since planning:**
```
⚠️  Issue #12 was updated since planning
    - Last update: 2024-01-18
    - Changes: Acceptance criteria added

    Review the updated requirements before starting.
```

**Issue has unresolved blockers:**
```
⚠️  Issue #18 has a blocker
    - Blocked by #12 (not yet complete)

    Recommendation: Start with #12 first.
```

## Post-Sprint: Architecture Validation

After a sprint is merged, validate and update architecture docs.

### When to Trigger

- User says "sprint complete" or "merged the PR"
- User asks to archive a sprint manifest
- Before starting the next planning session

### Validation Workflow

```
1. Read the completed sprint manifest
2. Review what changed:
   - New feature areas added?
   - New pages/routes added?
   - New technologies introduced?
   - New integrations added?
   - Existing areas significantly modified?

3. If changes detected:
   - Update app-architecture.md (new feature areas, dependencies)
   - Update tech-architecture.md (new tech, updated diagrams)
   - Add entry to Update Log in each doc

4. Archive the sprint manifest:
   - Move from manifests/ to archive/
   - Ensure manifest has "Completed" status
```

### Architecture Update Checklist

After each sprint, check:

- [ ] New feature area? → Add to app-architecture.md
- [ ] New page/route? → Add to Page/Route Map
- [ ] New API endpoint? → Update API section
- [ ] New dependency? → Add to tech-architecture.md
- [ ] New integration? → Add to External Integrations
- [ ] Database changes? → Update schema diagram
- [ ] Architecture decision made? → Add to Decisions table

## Pre-Close-Out Verification

Before closing out a sprint, run local verification to catch issues before tagging/releasing.

### When to Run Verification

- **Automatically**: Always run before close-out (Step 0 of close-out workflow)
- **On demand**: User says "run the checks", "verify the sprint", "pre-flight checks"
- **Before PR merge**: User wants confidence before merging

### Verification Checklist

```
┌─────────────────────────────────────────────────────────────────┐
│                    PRE-CLOSE-OUT VERIFICATION                    │
├─────────────────────────────────────────────────────────────────┤
│ 0. CHECK FOR SPRINT CONFIG                                      │
│    □ Look for .claude/sprint.config.json                        │
│    □ Load command overrides and skip list                       │
│    □ Load blockOnMissing preference                             │
│                                                                 │
│ 1. DETECT PROJECT SETUP                                         │
│    □ Check package.json for available scripts                   │
│    □ Identify test framework (Playwright, Jest, Vitest, etc.)   │
│    □ Identify linter (ESLint, Biome, etc.)                      │
│    □ Identify type checker (TypeScript, Flow, etc.)             │
│    □ Config overrides take precedence over auto-detection       │
│                                                                 │
│ 2. RUN TYPE CHECKS (if not in skip list)                        │
│    □ Use config command OR auto-detect                          │
│    □ Report any type errors                                     │
│                                                                 │
│ 3. RUN LINTING (if not in skip list)                            │
│    □ Use config command OR auto-detect                          │
│    □ Report any lint errors (warnings OK)                       │
│                                                                 │
│ 4. RUN UNIT TESTS (if not in skip list)                         │
│    □ Use config command OR auto-detect                          │
│    □ All tests must pass                                        │
│                                                                 │
│ 5. RUN E2E TESTS (if not in skip list)                          │
│    □ Use config command OR auto-detect                          │
│    □ All E2E tests must pass                                    │
│    □ Check for flaky test warnings                              │
│                                                                 │
│ 6. BUILD VERIFICATION (if not in skip list)                     │
│    □ Use config command OR auto-detect                          │
│    □ Build must complete without errors                         │
│                                                                 │
│ 7. GENERATE VERIFICATION REPORT                                 │
│    □ Summarize all check results                                │
│    □ Note any skipped checks (from config)                      │
│    □ Flag any failures as blockers                              │
│    □ Provide fix suggestions for common issues                  │
│                                                                 │
│                    ALL CHECKS MUST PASS                         │
│            before proceeding to close-out workflow              │
└─────────────────────────────────────────────────────────────────┘
```

### Step 0: Check for Sprint Config

Before detecting project setup, check for a configuration file that overrides defaults:

```bash
# Check for sprint config
cat .claude/sprint.config.json 2>/dev/null
```

**Config file location**: `.claude/sprint.config.json`

**Schema**:
```json
{
  "closeout": {
    "typecheck": "pnpm typecheck",    // Override command
    "lint": "pnpm lint",              // Override command
    "test": "pnpm test",              // Override command
    "e2e": "npx cypress run",         // Override command
    "build": "pnpm build",            // Override command
    "skip": ["e2e"],                  // Categories to skip
    "blockOnMissing": false           // Block if tests not configured
  },
  "planning": {
    "sprintCount": 3                  // Number of sprints to plan
  }
}
```

**Config fields**:
- **closeout.typecheck**: Custom typecheck command (overrides auto-detection)
- **closeout.lint**: Custom lint command (overrides auto-detection)
- **closeout.test**: Custom unit test command (overrides auto-detection)
- **closeout.e2e**: Custom E2E test command (overrides auto-detection)
- **closeout.build**: Custom build command (overrides auto-detection)
- **closeout.skip**: Array of check categories to skip: `["typecheck", "lint", "test", "e2e", "build"]`
- **closeout.blockOnMissing**: If `true` (default), block close-out when tests aren't configured. If `false`, proceed with available checks.
- **planning.sprintCount**: Number of sprints to plan ahead (default: 3)

**If config exists**:
1. Load all settings
2. Apply command overrides in subsequent steps
3. Skip any categories listed in `skip` array
4. Use `blockOnMissing` to determine behavior when tests aren't configured

**If config doesn't exist**:
- Proceed with auto-detection (existing behavior)
- Default `blockOnMissing` to `true` (require user confirmation)

### Step 1: Detect Project Setup

First, understand what tools are available:

```bash
# Read package.json to find available scripts
cat package.json | jq '.scripts'
```

Common scripts to look for:
- **Type checking**: `typecheck`, `type-check`, `tsc`
- **Linting**: `lint`, `eslint`, `biome`
- **Unit tests**: `test`, `test:unit`, `jest`, `vitest`
- **E2E tests**: `test:e2e`, `e2e`, `playwright`, `test:integration`
- **Build**: `build`, `build:prod`

**Config override**: If `sprint.config.json` provides a command for a category, use that command instead of auto-detecting from package.json.

### Step 2: Run Type Checks

**Check config first**:
1. If `"typecheck"` is in config `skip` array → Skip this step, report as "Skipped (config)"
2. If config provides `closeout.typecheck` command → Use that command
3. Otherwise → Auto-detect from package.json

```bash
# If config provides command
${config.closeout.typecheck}

# Or if script exists in package.json
npm run typecheck

# Or directly
npx tsc --noEmit
```

**On skip (from config)**:
```
⏭️  TYPE CHECK SKIPPED (configured in sprint.config.json)
```

**On failure**:
```
❌ TYPE CHECK FAILED

Errors found:
  src/auth/login.ts(45,12): error TS2345: Argument of type 'string' is not assignable...

Fix these type errors before closing the sprint.
```

### Step 3: Run Linting

**Check config first**:
1. If `"lint"` is in config `skip` array → Skip this step, report as "Skipped (config)"
2. If config provides `closeout.lint` command → Use that command
3. Otherwise → Auto-detect from package.json

```bash
# If config provides command
${config.closeout.lint}

# Or if script exists in package.json
npm run lint

# Or directly
npx eslint . --ext .ts,.tsx
```

**On skip (from config)**:
```
⏭️  LINT SKIPPED (configured in sprint.config.json)
```

**On failure**:
```
❌ LINT FAILED

Errors found:
  src/components/Form.tsx
    12:5  error  'unused' is defined but never used  @typescript-eslint/no-unused-vars

Fix lint errors before closing. (Warnings are acceptable)
```

### Step 4: Run Unit Tests

**Check config first**:
1. If `"test"` is in config `skip` array → Skip this step, report as "Skipped (config)"
2. If config provides `closeout.test` command → Use that command
3. Otherwise → Auto-detect from package.json

```bash
# If config provides command
${config.closeout.test}

# Or common patterns
npm test
npm run test:unit
npx jest
npx vitest run
```

**On skip (from config)**:
```
⏭️  UNIT TESTS SKIPPED (configured in sprint.config.json)
```

**On failure**:
```
❌ UNIT TESTS FAILED

Failed tests:
  ● Auth › login › should validate email format

  Expected: true
  Received: false

    at src/auth/__tests__/login.test.ts:45:12

Fix failing tests before closing the sprint.
```

### Step 5: Run E2E Tests

**Check config first**:
1. If `"e2e"` is in config `skip` array → Skip this step, report as "Skipped (config)"
2. If config provides `closeout.e2e` command → Use that command
3. Otherwise → Auto-detect from package.json

```bash
# If config provides command
${config.closeout.e2e}

# Or common patterns
npm run test:e2e
npx playwright test
npm run e2e
```

**Configuration check** (only if not using config command):
```bash
# Verify Playwright is set up
ls playwright.config.ts || ls playwright.config.js
```

**On skip (from config)**:
```
⏭️  E2E TESTS SKIPPED (configured in sprint.config.json)
```

**On failure**:
```
❌ E2E TESTS FAILED

Failed tests:
  ● login.spec.ts › User can log in with valid credentials

  Timeout waiting for selector: [data-testid="login-button"]

  Screenshot saved: test-results/login-User-can-log-in-1.png

Review the screenshot and fix the failing E2E test.
```

**On flaky warning**:
```
⚠️ E2E TESTS PASSED (with warnings)

Flaky tests detected:
  - dashboard.spec.ts › loads dashboard (passed on retry 2/3)

Consider stabilizing flaky tests in a future sprint.
Proceeding with close-out...
```

### Step 6: Build Verification

**Check config first**:
1. If `"build"` is in config `skip` array → Skip this step, report as "Skipped (config)"
2. If config provides `closeout.build` command → Use that command
3. Otherwise → Auto-detect from package.json

```bash
# If config provides command
${config.closeout.build}

# Or default
npm run build
```

**On skip (from config)**:
```
⏭️  BUILD SKIPPED (configured in sprint.config.json)
```

**On failure**:
```
❌ BUILD FAILED

Error: Module not found: Can't resolve './missing-file'
  at src/index.ts:5:0

Fix build errors before closing the sprint.
```

### Step 7: Generate Verification Report

After all checks complete, generate a summary:

```markdown
## Pre-Close-Out Verification Report

**Sprint**: v1.3.0-user-auth
**Date**: YYYY-MM-DD
**Status**: ✅ ALL CHECKS PASSED

### Results

| Check | Status | Details |
|-------|--------|---------|
| Type Check | ✅ Pass | No errors |
| Lint | ✅ Pass | 0 errors, 3 warnings |
| Unit Tests | ✅ Pass | 45 tests, 45 passed |
| E2E Tests | ✅ Pass | 12 tests, 12 passed |
| Build | ✅ Pass | Built in 23s |

### Ready for Close-Out

All checks passed. Proceeding to close-out workflow...
```

**If any check fails**:

```markdown
## Pre-Close-Out Verification Report

**Sprint**: v1.3.0-user-auth
**Date**: YYYY-MM-DD
**Status**: ❌ BLOCKED - FIXES REQUIRED

### Results

| Check | Status | Details |
|-------|--------|---------|
| Type Check | ✅ Pass | No errors |
| Lint | ✅ Pass | 0 errors, 3 warnings |
| Unit Tests | ❌ FAIL | 45 tests, 2 failed |
| E2E Tests | ⏸️ Skip | Blocked by unit test failure |
| Build | ⏸️ Skip | Blocked by test failure |

### Blockers

1. **Unit Tests**: 2 failing tests
   - `Auth › login › should validate email format`
   - `Auth › login › should handle network errors`

### Next Steps

Fix the failing tests, then run verification again:
- "Run the checks" / "Verify the sprint"

Close-out workflow is blocked until all checks pass.
```

### Handling Missing Test Infrastructure

If tests aren't set up, behavior depends on the `blockOnMissing` config setting:

**Check config**: Read `closeout.blockOnMissing` from `.claude/sprint.config.json`
- If `true` (default): Require user confirmation before proceeding
- If `false`: Proceed automatically with available checks

**If `blockOnMissing: true` (default)**:

```markdown
## Pre-Close-Out Verification Report

**Sprint**: v1.3.0-user-auth
**Date**: YYYY-MM-DD
**Status**: ⚠

…(truncated)