Do the sprint planning work before the planning meeting
Most of what a planning meeting answers needs data, not a meeting. Agents split stories, map dependencies, order tasks, write evil user stories and check acceptance criteria before anyone sits down.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 8 January 2026 Updated: 3 min read
Most teams spend 3 hours per sprint in planning. We spend 45 minutes.
The difference: we moved the information-gathering to before anyone sits down.
Planning questions need data, not a meeting
Planning meetings exist to answer three questions. What can we commit to? What depends on what? Who’s available?
But most of that doesn’t need a meeting. It needs data. Here is what we do instead, in five steps. The first three shape the work. The last two close the gaps that kill sprints just as often: security gaps and test coverage surprises.
1. Story splitting
The hardest part of planning is breaking big stories into small, shippable tasks.
We feed the refined story to the agent together with our codebase, and it looks for:
- Natural code boundaries (where to cut)
- Independent deployability (what can ship alone)
- Value increments (the smallest useful chunk)
- Risk isolation (what could fail separately)
No more 5-point stories that turn into 13.
How to start: give the agent the story and codebase access. Ask: “How would you split this into tasks a developer can finish in a day?”
2. Dependency mapping
Once we have tasks, the agent traces their relationships:
- Technical dependencies in code
- Logical dependencies in features
- External dependencies (APIs, teams)
- Risk dependencies (what blocks what)
No more “we didn’t realize X needed Y.”
How to start: feed your tasks and architecture docs to the agent. Ask: “Which tasks have hidden dependencies?”
3. Task ordering
We used to grab the highest-value task first. It seemed logical. Then a hidden dependency on infrastructure work nobody had scoped cost us three days.
Now we order tasks before committing, by:
- Dependencies (what must come first)
- Risk (tackle unknowns early)
- Value (what moves metrics)
- Parallelization (what can happen at the same time)
4. Evil user stories
Security review used to happen after the code was written. Vulnerabilities turned up in penetration testing, and the rework was expensive.
Now the agent writes evil user stories alongside every feature.
User story: “As a user, I can reset my password via email.”
Evil user stories:
- “As an attacker, I can enumerate valid emails through the reset flow.”
- “As an attacker, I can brute-force reset tokens.”
- “As an attacker, I can intercept reset links on shared devices.”
Security requirements surface before the first line of code.
How to start: feed your user stories to the agent. Ask: “For each story, write 3-4 evil user stories from an attacker’s perspective. What could go wrong?”
5. Acceptance criteria completeness
“What happens when the list is empty?” used to come up in code review. Missing edge cases turned up after implementation, and scope creep came disguised as clarification.
Now the agent checks the acceptance criteria before coding starts:
- Edge cases covered (empty states, max limits, invalid inputs)
- Error scenarios defined (what fails, how it fails, what users see)
- Boundary conditions explicit (first item, last item, zero items)
- Integration touchpoints clear (which systems, what data format)
No more “we didn’t think of that” in code review.
How to start: give the agent your acceptance criteria. Ask: “What scenarios are missing? What edge cases would a QA engineer ask about? What’s ambiguous?”
The first attempts were wrong
The first time we tried story splitting, the agent split a story into 12 tasks. Half had the wrong boundaries. The first evil user stories were paranoid fiction. The first acceptance criteria review flagged 40 missing scenarios for a 2-day task.
What fixed it was feeding the agent your own codebase patterns, your own threat model and your own definition of “done”, not just the story text or a generic checklist.
What the meeting is left with
Planning goes from 3 hours to 45 minutes. Security and testing become planning inputs, not review surprises. Rework drops, PR reviews speed up, and production incidents from missed cases drop.
The remaining time is for human decisions: scope negotiations, team morale, and the edge cases only context can resolve. Everything else happens before anyone opens their calendar. The meeting stays 45 minutes, and the sprint actually finishes on time.
What catches your team by surprise most often: story sizing, hidden dependencies, security gaps, incomplete acceptance criteria, or something else entirely?
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Specification and review
- AI makes code easy, and only a spec keeps it simple Conversational coding piles every instruction onto the last until the code tangles. Rich Hickey's distinction between easy and simple explains why, and a research, plan, implement process is the fix.
- Do the refinement research before the refinement meeting Refinement meetings exist to clarify requirements and surface blockers. An agent with codebase access does most of that research and questioning before the meeting, so the team only decides.
- Breaking the Loop: Why agents never finish on their own Agents in a software factory always find another problem, another ticket, another improvement. Only a second, much slower loop can say when the work is finished: the one that reaches the market.
Scaling needs named owners
Coding agents scale across teams when named people own the platform, the team practice, the guardrails, and the measurement. Rollout & scale is where that ownership is built and handed to internal owners, in your stack.
Training on this topic: Agentic Engineering for Developers and QAWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check