본문으로 건너뛰기
cccskills
무료GitHub에 공개

plan-sprint

Plan a sprint by refining backlog items, defining a sprint goal, calculating team capacity, selecting items, and decomposing them into tasks. Produces a SPRINT-PLAN.md with goal, selected items, task breakdown, and capacity allocation. Use when starting a new sprint in a Scrum or agile project, re-planning after significant scope change, transitioning from ad-hoc work to structured sprint cadence, or after backlog grooming when items are ready for inclusion.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

설치 방법 보기

포함된 파일(1)

  • SKILL.md9.1 KB

SKILL.md(원문)

설치하기 전에 에이전트에게 전달되는 지시 내용을 확인할 수 있습니다.

Plan a Sprint

Plan a time-boxed sprint by selecting refined backlog items up to team capacity, defining a clear sprint goal, and decomposing selected items into actionable tasks. This skill produces a complete sprint plan that guides team work for the duration of the sprint iteration.

When to Use

  • Starting a new sprint in a Scrum or agile project
  • Re-planning a sprint after significant scope change
  • Transitioning from ad-hoc work to structured sprint cadence
  • After backlog grooming when items are ready for sprint inclusion
  • Planning the first sprint after project charter approval

Inputs

  • Required: Product backlog (prioritized, with estimates)
  • Required: Sprint duration (typically 1-2 weeks)
  • Required: Team members and their availability
  • Optional: Previous sprint velocity (story points or items completed)
  • Optional: Sprint number and date range
  • Optional: Carry-over items from previous sprint

Procedure

Step 1: Review and Refine Backlog Items

Read the current BACKLOG.md. For each candidate item near the top of the backlog, verify it has:

  • Clear title and description
  • Acceptance criteria (testable conditions)
  • Estimate (story points or T-shirt size)
  • No unresolved blockers

Refine any items missing these elements. Split items estimated larger than half the sprint capacity into smaller, more manageable pieces.

Expected: Top 10-15 backlog items are "sprint-ready" with acceptance criteria and estimates.

On failure: If items lack acceptance criteria, write them now. If items can't be estimated, schedule a refinement conversation and select only ready items.

Step 2: Define Sprint Goal

Write a single clear sprint goal — one sentence stating what the sprint will achieve. The goal should be:

  • Achievable within the sprint duration
  • Valuable to stakeholders
  • Testable (you can verify it was met at sprint end)
**Sprint Goal**: [One sentence describing the objective]

Example: "Enable users to reset their password through email verification with two-factor authentication."

Expected: Sprint goal articulated as one clear, testable sentence.

On failure: If no coherent goal emerges, the backlog priorities may be scattered — consult the product owner to focus on a single valuable outcome.

Step 3: Calculate Team Capacity

Calculate available person-days for each team member:

## Team Capacity
| Team Member | Available Days | Overhead (%) | Net Capacity |
|-------------|---------------|-------------|--------------|
| [Name] | [Sprint days - PTO] | 20% | [Available × 0.8] |
| [Name] | [Sprint days - PTO] | 20% | [Available × 0.8] |
| **Total** | | | **[Sum] person-days** |

Overhead accounts for meetings, reviews, ad-hoc requests (typically 15-25%).

If using story points: use previous sprint velocity as capacity. If first sprint, use 60-70% of theoretical maximum.

Expected: Capacity calculated in person-days or story points with documented assumptions.

On failure: If no historical velocity exists, be conservative — plan to 60% capacity and adjust after the sprint. Better to under-commit and deliver than over-commit and fail.

Step 4: Select Items and Compose Sprint Backlog

Select items from the top of the product backlog until capacity is reached. Decompose each selected item into tasks (2-8 hours each):

# Sprint Plan: Sprint [N]
## Document ID: SP-[PROJECT]-S[NNN]

### Sprint Details
- **Sprint Goal**: [From Step 2]
- **Duration**: [Start date] to [End date]
- **Capacity**: [From Step 3] person-days / [N] story points
- **Team**: [List team members]

### Sprint Backlog
| ID | Item | Points | Tasks | Assignee | Status |
|----|------|--------|-------|----------|--------|
| B-001 | [Item title] | 5 | 4 | [Name] | To Do |
| B-002 | [Item title] | 3 | 3 | [Name] | To Do |
| B-003 | [Item title] | 8 | 6 | [Name] | To Do |
| **Total** | | **16** | **13** | | |

### Task Breakdown

#### B-001: [Item title]
**Acceptance Criteria**: [From backlog item]

- [ ] Task 1: [Description] (4h, [Assignee])
- [ ] Task 2: [Description] (2h, [Assignee])
- [ ] Task 3: [Description] (4h, [Assignee])
- [ ] Task 4: [Description] (2h, [Assignee])

#### B-002: [Item title]
**Acceptance Criteria**: [From backlog item]

- [ ] Task 1: [Description] (3h, [Assignee])
- [ ] Task 2: [Description] (4h, [Assignee])
- [ ] Task 3: [Description] (2h, [Assignee])

#### B-003: [Item title]
**Acceptance Criteria**: [From backlog item]

- [ ] Task 1: [Description] (3h, [Assignee])
- [ ] Task 2: [Description] (4h, [Assignee])
- [ ] Task 3: [Description] (2h, [Assignee])
- [ ] Task 4: [Description] (3h, [Assignee])
- [ ] Task 5: [Description] (4h, [Assignee])
- [ ] Task 6: [Description] (2h, [Assignee])

### Risks and Dependencies
| Risk | Impact | Mitigation |
|------|--------|-----------|
| [Risk 1] | [Impact] | [Mitigation] |
| [Risk 2] | [Impact] | [Mitigation] |

### Carry-Over from Previous Sprint
| ID | Item | Reason | Remaining Effort |
|----|------|--------|-----------------|
| B-XXX | [Item] | [Reason] | [Hours/points] |

Expected: Sprint backlog with items selected up to capacity, each decomposed into tasks with time estimates.

On failure: If total points exceed capacity, remove the lowest-priority item. Never exceed capacity by more than 10%. If dependencies block sequencing, re-order or defer items.

Step 5: Document Commitments and Save

Write the sprint plan to SPRINT-PLAN.md (or SPRINT-PLAN-S[NNN].md for archival). Confirm:

  • Sprint goal is achievable with selected items
  • No team member is overallocated (>100% capacity)
  • Dependencies between items are sequenced correctly
  • Carry-over items are accounted for in capacity
  • All acceptance criteria copied from backlog items

Run a final validation:

# Check that total task hours align with capacity
grep -A 100 "Task Breakdown" SPRINT-PLAN.md | grep -o '([0-9]*h' | sed 's/[^0-9]//g' | awk '{sum+=$1} END {print "Total hours:", sum}'

Expected: SPRINT-PLAN.md created with complete sprint backlog and task breakdown. Total hours should be ≤80% of available person-days × 8 hours.

On failure: If commitments don't align with goal, revisit item selection in Step 4. If task hours exceed capacity, remove the last item or decompose tasks more granularly.

Validation

  • Sprint goal is one clear, testable sentence
  • Team capacity calculated with documented assumptions (overhead %, PTO accounted)
  • Selected items do not exceed capacity (points or person-days)
  • Every selected item has acceptance criteria copied into task breakdown
  • Every selected item is decomposed into tasks (2-8 hours each)
  • No team member overallocated beyond 100% capacity
  • Carry-over items from previous sprint documented with remaining effort
  • Dependencies between items sequenced correctly
  • Risks and mitigations documented
  • SPRINT-PLAN.md file created and saved

Common Pitfalls

  • No sprint goal: Without a goal, the sprint is just a bag of tasks. The goal provides focus and a basis for scope decisions mid-sprint.
  • Over-commitment: Planning to 100% capacity ignores interruptions, bugs, and overhead. Plan to 70-80% to leave buffer for the unexpected.
  • Tasks too large: Tasks over 8 hours hide complexity and make progress tracking difficult. Decompose until tasks are 2-8 hours.
  • Ignoring carry-over: Unfinished items from the last sprint consume capacity this sprint. Account for them explicitly in capacity calculations.
  • Sprint goal as item list: "Complete B-001, B-002, B-003" is not a goal. A goal describes the outcome: "Users can reset their password through email verification."
  • No task ownership: Every task should have an assignee at planning time to surface capacity conflicts early.
  • Skipping acceptance criteria: Tasks without acceptance criteria can't be tested. Copy acceptance criteria from backlog items into the task breakdown section.

Related Skills

  • manage-backlog — maintain and prioritize the product backlog that feeds sprint planning
  • draft-project-charter — provides project context and initial scope for the first sprint
  • generate-status-report — report sprint progress and velocity to stakeholders
  • conduct-retrospective — review sprint execution and improve the planning process
  • create-work-breakdown-structure — WBS work packages can feed the backlog in hybrid agile-waterfall approaches

리뷰

아직 리뷰가 없습니다. 사용해 본 소감을 남겨 주세요.

댓글

로그인 없이 쓸 수 있습니다. 사용 후기, 질문, 작동하지 않은 환경 등을 편하게 남겨 주세요.

아직 댓글이 없습니다. 첫 댓글을 남겨 보세요.

보내면 바로 공개됩니다. 이메일 주소나 전화번호 같은 개인 정보는 쓰지 마세요. URL은 2개까지입니다.

0 / 1,000자

이 양식은 reCAPTCHA로 보호되며 Google 개인정보처리방침 및 서비스 약관이 적용됩니다.

같은 저장소의 스킬

Execute structural metamorphosis using strangler fig migration, chrysalis phases, and interface preservation. Covers transformation planning, parallel running, progressive cutover, rollback design, and post-metamorphosis stabilization for system architecture evolution. Use when assess-form has classified the system as READY for transformation, when migrating from monolith to microservices, when replacing a core subsystem while dependents continue operating, or when any architectural change must be gradual rather than big-bang.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

pjt222/agent-almanac422026년 10월 15일 업데이트

adaptic

무료

Master skill composing the 5-step synoptic cycle for panoramic synthesis across multiple domains. Orchestrates meditate, expand-awareness, observe, awareness, integrate-gestalt, and express-insight into a coherent process that produces unified understanding rather than sequential compromise. Use when a problem genuinely spans 3+ domains and the interactions between domains matter more than depth in any one, when sequential analysis feels like compromise rather than integration, or before major architectural decisions affecting multiple stakeholders.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

pjt222/agent-almanac422026년 10월 15일 업데이트

Scaffold a new puzzle type across all 10+ pipeline integration points in jigsawR. Creates the core puzzle module, wires it into the unified pipeline (generation, positioning, rendering, adjacency), adds ggpuzzle geom/stat layers, updates DESCRIPTION and config.yml, extends the Shiny app, and creates a comprehensive test suite. Use when adding a completely new puzzle type to the package or following the 10-point integration checklist to ensure nothing is missed end-to-end.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

pjt222/agent-almanac422026년 10월 15일 업데이트

Add Rcpp or RcppArmadillo integration to an R package for high-performance C++ code. Covers setup, writing C++ functions, RcppExports generation, testing compiled code, and debugging. Use when an R function is too slow and profiling confirms a bottleneck, when you need to interface with existing C/C++ libraries, or when implementing algorithms (loops, recursion, linear algebra) that benefit from compiled code.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

pjt222/agent-almanac422026년 10월 15일 업데이트

aikido

무료

Practice aikido as a defensive martial art emphasizing harmony, redirection, and controlled resolution. Covers centering and grounding, ukemi (safe falling and rolling), core techniques (irimi-nage, shiho-nage, kote-gaeshi, ikkyo), blending and tai sabaki (body movement), randori (multiple attacker practice), weapons awareness, and applying principles off the mat. Use when learning a defensive martial art that prioritizes de-escalation, developing the ability to redirect aggression without causing unnecessary harm, building safe falling skills, or cultivating calm centeredness under physical pressure.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

pjt222/agent-almanac422026년 10월 15일 업데이트

Analyze an arbitrary codebase to identify functions, APIs, and data sources suitable for exposure as MCP tools, producing a tool specification document. Use when planning an MCP server for an existing project, auditing a codebase before wrapping it as an AI-accessible tool surface, comparing what a codebase can do versus what is already exposed via MCP, or generating a tool spec to hand off to scaffold-mcp-server.

한국어 요약은 준비 중입니다. 원문 설명을 표시하고 있습니다.

pjt222/agent-almanac422026년 10월 15일 업데이트

pjt222의 스킬 모두 보기

이 스킬의 문제 신고