Sprint Planning Pack

We built the Sprint Planning Pack because we're tired of watching engineering teams waste hours in planning meetings that produce nothing but fragile commitments and carryover debt.

If your team treats sprint planning as a negotiation rather than a calculation, you're leaking velocity. This pack installs a validated, scriptable workflow that forces alignment between capacity, backlog readiness, and sprint goals. You get YAML templates that catch structural errors before they hit the board, Python and TypeScript scripts that talk directly to Jira and Linear, and bash validators that refuse to let a sprint start without a risk register.

Stop guessing. Start shipping.

The Planning Poker Trap and the Backlog Black Hole

Sprint planning is a Scrum event where teams define what can be delivered in the upcoming sprint and how the work will be achieved ^[1]. In practice, too many teams skip the hard work of preparation and dive straight into "how long will this take?". The result is a planning meeting that drags on for hours, fueled by optimistic guesses and political pressure.

The root cause is almost always poor backlog refinement. Refinement of the Product Backlog may happen many times during the Sprint, but if the top items aren't sufficiently refined, the planning meeting becomes a guessing game ^[3]. Teams pull in items that lack acceptance criteria, ignore dependencies, or underestimate the complexity of legacy code. The Scrum Guide confirms that product backlog refinement is the act of breaking down and further defining items into smaller, more precise items ^[4]. Without this discipline, your sprint plan is just a hope.

We've seen teams commit to 40 story points based on a backlog where half the items are essentially "TBD". They spend the first three days of the sprint doing discovery work that should have happened weeks ago. This isn't an Agile problem; it's a workflow problem. You need a system that enforces readiness before commitment.

If you're looking for a broader toolkit to fix your Agile process, check out the Agile Scrum Master Pack, which covers the full lifecycle from planning to retrospectives.

What Missed Sprints Cost Your Team and Your Credibility

When you ignore the planning workflow, the costs compound fast. Let's talk numbers.

A typical two-week sprint with six engineers represents 480 hours of capacity. If your planning is off by just 20%, you're misallocating 96 hours. That's four full workweeks wasted on work that can't be done. Over a year, that's nearly a month of salary burned on carryover, context switching, and re-planning.

Meetings themselves are a drain. Effective refinement requires structure. Tips for Product Backlog Refinement suggest meeting at least three hours per sprint and following the 15/5 rule of discussion to keep meetings focused ^[5]. If your refinement is unstructured, you're likely spending those hours arguing about estimates rather than clarifying scope.

Story points are a relative estimation method in Agile that helps teams assess effort, complexity, and risk for backlog items ^[2]. When you use story points without a calibrated reference set, you're not estimating; you're voting. A "5" for one team might be a "3" for another. Without a shared definition of done and a clear sprint goal, your velocity becomes noise.

The downstream impact hits harder than just missed dates. When stakeholders see consistent carryover, trust erodes. Engineering loses credibility. Product managers start micromanaging. And the team? They burn out. You end up in the Retrospective Pack cycle, trying to fix symptoms instead of the root cause. Worse, poor planning leads to rushed code and missed testing windows, which directly feeds into Incident Management Pack fires. A bad sprint plan is the precursor to a production outage.

How a Platform Team Went from 40% Carryover to Predictable Velocity

Imagine a platform engineering team of eight developers working on a microservices migration. They were using Jira, but their sprint planning was chaotic. Backlog items were a mix of features, bugs, and tech debt with no clear priority. The planning meeting took three hours. They committed to 60 story points. By day eight, they had completed 24 points. The remaining 36 points went back to the backlog, breaking the sprint goal.

The Sprint Goal is an objective set for the Sprint that can be met through the implementation of Product Backlog ^[6]. In this team's case, they didn't have a goal. They had a list. The goal of Product Backlog refinement is to work with the Scrum Team and stakeholders to get Product Backlog items in a 'ready state' ^[7]. Without that ready state, the team was pulling in work they couldn't finish.

The team installed the Sprint Planning Pack and changed their workflow. They used the templates/sprint-plan.yaml to structure their planning artifacts. Before the meeting, they ran scripts/calculate_velocity.py against the last four sprints to get a data-driven velocity baseline instead of a gut feeling. The script calculated average velocity, standard deviation, and predicted capacity based on actual team availability.

During planning, they used the validators/validate_sprint_plan.sh to check their YAML plan. The validator caught three critical errors: a missing risk register, a dependency on a team that wasn't available, and a story point total that exceeded capacity. The plan was rejected before it ever hit the board. The team refined the backlog, removed the risky items, and re-estimated. This time, they committed to 42 points with a clear sprint goal: "Migrate the user service to the new event bus."

The result? They hit the goal. Velocity stabilized. Stakeholders saw a predictable delivery pattern. This isn't magic; it's structure. By automating the validation and calculation steps, the team removed the human errors that kill sprints. If you need to manage the scope within the sprint once committed, the Feature Flag Management Pack helps you control rollouts and kill switches without derailing the plan.

What Changes When You Install the Sprint Planning Pack

Once the Sprint Planning Pack is installed, your workflow shifts from ad-hoc meetings to a repeatable, validated process. Here's what the after-state looks like:

Backlog Refinement Enforced by Structure

The skill.md orchestrator guides your AI agent through the end-to-end workflow. It references the canonical Scrum knowledge in references/scrum-framework.md, ensuring that every planning decision aligns with the Scrum Guide. You no longer debate what "refinement" means; the pack defines the criteria.

Capacity Calculation That Actually Works scripts/calculate_velocity.py ingests historical sprint JSON data and outputs a velocity prediction with standard deviation. You can pass team availability (PTO, holidays) to the script, and it adjusts the capacity accordingly. No more guessing if you have enough hours for the sprint. Direct Integration with Jira and Linear scripts/commit_sprint.py uses the Jira SDK to fetch prioritized backlog items, validate capacity against velocity, and commit issues to a new sprint. It handles authentication errors with exponential backoff, so you don't have to debug connection issues mid-planning. If you're using Linear, scripts/track_linear_issues.ts lists team issues, updates story point estimates, adds planning comments, and archives completed items with pagination support. Validation Before Commitment

The validators/validate_sprint_plan.sh parses your sprint-plan.yaml and checks for required fields: goal, capacity, stories, risks. It validates that story point totals don't exceed capacity. If the plan fails, the script exits non-zero. You can't ship a broken plan. This validator is the gatekeeper that keeps your team honest.

Automation Without Friction

The pack integrates seamlessly with your existing tooling. You can trigger the validation script as a pre-commit hook or a CI check. The templates/jira-sprint-config.json defines JQL filters, workflow states, and sprint naming conventions, ensuring your board is configured for Scrum best practices from day one. For broader automation needs, see the Task Automation Pack to wire these scripts into your CI/CD pipeline.

Risk Management Built-In

The examples/worked-example.yaml demonstrates realistic risk mitigation strategies. You'll see how to map dependencies, allocate buffer capacity, and document assumptions. This isn't just a template; it's a pattern for de-risking your sprints.

What's in the Sprint Planning Pack

• skill.md — Orchestrator skill that defines the end-to-end sprint planning workflow, references all templates, scripts, validators, and references by relative path, and guides the AI agent through backlog refinement, capacity estimation, story pointing, and sprint commitment.
• references/scrum-framework.md — Canonical Scrum knowledge covering Sprint Planning events, backlog refinement techniques, velocity calculation methods, story point estimation scales, and sprint goal definition per the Scrum Guide.
• references/jira-linear-apis.md — Curated API reference excerpts from Context7 docs for Jira Python SDK and Linear TypeScript SDK, focusing on sprint updates, backlog search, issue transitions, worklogging, and velocity tracking.
• templates/sprint-plan.yaml — Production-grade YAML template for structuring sprint planning artifacts including sprint goals, team capacity, story point estimates, dependency mapping, risk register, and commitment tracking.
• templates/jira-sprint-config.json — Jira board and sprint configuration template defining JQL filters, workflow states, priority schemes, and sprint naming conventions aligned with Scrum best practices.
• scripts/calculate_velocity.py — Executable Python script that ingests historical sprint JSON data, calculates average velocity, standard deviation, and predicts capacity for upcoming sprints based on team availability.
• scripts/commit_sprint.py — Executable Python script using the Jira SDK to fetch prioritized backlog items, validate capacity against velocity, commit issues to a new sprint, and handle authentication errors with exponential backoff.
• scripts/track_linear_issues.ts — Executable TypeScript script using the Linear SDK to list team issues, update story point estimates, add planning comments, and archive completed items with pagination support.
• validators/validate_sprint_plan.sh — Bash validator that parses sprint-plan.yaml, checks for required fields (goal, capacity, stories, risks), validates story point totals against capacity, and exits non-zero on structural or logical failures.
• examples/worked-example.yaml — Fully populated worked example of a sprint plan demonstrating realistic story points, capacity allocation, dependency tracking, and risk mitigation strategies.

Upgrade to Pro and Lock Your Next Sprint

Stop the planning poker circus. Start shipping commitments you can actually hit.

The Sprint Planning Pack gives you the structure, scripts, and validation to turn sprint planning from a source of anxiety into a competitive advantage. You get a workflow that catches errors before they cost you, calculates capacity with math instead of guesswork, and integrates directly with the tools your team already uses.

Upgrade to Pro to install the Sprint Planning Pack. Your next sprint deserves better than a hope.