Injecting Deterministic Requirements, BDD Acceptance Criteria, and Automated Quality Gates Directly into Your Backlog
Skills Repository: https://github.com/alwyndsouza/agile-story-skills
Most “user stories” sitting in production backlogs are just vague tasks dressed up in Agile clothing. They have no testable outcome, no scope boundary, and no shared definition of done.
By building custom Copilot agent skills, we can inject deterministic engineering rigour directly into our product management workflow.
The agile-story-writer skill fixes backlogs by encoding BDD-style GIVEN/WHEN/THEN acceptance criteria, INVEST validation, and DoR/DoD checklists into a single slash command.
Paste a rough engineering or product idea; get a production-ready, sprint-plannable story in seconds.
If you retain one idea from this article, let it be this: every story that cannot be objectively verified is not a story — it’s a wish.
Overview
We have all been there: a product manager drops a half-sentence feature request in Slack, a production bug needs an immediate ticket, or an engineering spike lacks proper boundaries. The typical result is a backlog filled with ambiguous tickets that dissolve into lengthy debates during sprint grooming.
Instead of fighting the process, we can use the GitHub Copilot extensibility model to build dedicated Agent Skills — tailored, prompt-packaged capabilities that run locally or in the cloud.
This article walks through how the agile-story-writer Agent Skill encodes three foundational agile frameworks, the anatomy of the stories it generates, and how you can leverage agentic AI to build a deterministic, rock-solid backlog.
Core Concept: What Makes a Story “Good”?
Before looking at what the AI agent produces, we need to establish what it is optimising for. The agent relies on three core pillars to transform raw text into engineered requirements.
Framework 1 — INVEST: Your Quality Gate
Every single output generated by the Agent Skill is validated against the INVEST matrix. Coined by Bill Wake in 2003, this six-criterion quality heuristic remains the gold standard for requirement engineering:
- Independent: Can this story be developed and shipped without waiting on another in-progress story?
- Negotiable: Is the implementation approach open, leaving only the outcome fixed?
- Valuable: Does it deliver clear business or user value on its own?
- Estimable: Can the team size it in Fibonacci points with reasonable confidence?
- Small: Can it be comfortably completed within a single sprint?
- Testable: Can the acceptance criteria be objectively verified as pass or fail?
What’s happening under the hood: INVEST isn’t a rubric for post-hoc grading — it is an active gate.
The Copilot Agent Skill enforces it at Refinement time, not review time. If a story fails the Estimable or Small tests (for example, if it’s too ambiguous or massive), the agent automatically flags the blockages before they can derail sprint planning.
Framework 2 — BDD Acceptance Criteria: The GIVEN/WHEN/THEN Contract
The skill defaults to Behavior-Driven Development (BDD) format for acceptance criteria. This isn’t an aesthetic preference; it’s a shared language between product, engineering, and QA that makes criteria completely deterministic.
The GIVEN/WHEN/THEN structure maps directly to verifiable system states:
GIVEN the user is on the checkout page
AND their cart total exceeds $50
WHEN they click “Apply Free Shipping”
THEN the shipping cost is set to $0
AND a confirmation message appears within 500ms
Compare this to the standard alternative: “Free shipping should apply when eligible.” A developer and a QA engineer reading that phrase in isolation will almost always build and test two completely different implementations.
The Key Takeaway: BDD criteria are executable in your head. Anyone can read them and know exactly what "done" looks like, completely eliminating the interpretation gap at sprint reviews.
Framework 3 — Scope IN/OUT: The Boundary Fence
This is the most underrated section in modern project management, and the single most effective tool for preventing mid-sprint scope creep. Every story produced by the skill explicitly outlines its boundaries.
For an engineering or feature task, it looks like this:
- Scope IN: Guest checkout, credit card payment, email confirmation.
- Scope OUT: Refund logic, saved payment methods, admin reporting, multi-currency.
The Key Takeaway: Scope OUT is not a parking lot for future work. It is an explicit contract signed during refinement that protects engineering from well-intentioned, mid-sprint “add-ons.”
The Full Story Anatomy
The output generated by the agile-story-writer skill is highly structured and tool-agnostic. It is ready to copy-paste directly into Jira, GitHub Issues, Linear, or Azure DevOps:
- Title: Specific, action-oriented, estimable work item name.
- Type: Story / Bug / Spike (with a clear rationale for the classification).
- Priority: P1–P4 with explicit business justification.
- Story Points: Fibonacci estimate ($1, 2, 3, 5, 8, 13$) with architectural rationale.
- Context: Why this story matters right now and the core problem it solves.
- User Story: As a [role], I want [outcome] so that [measurable value].
- Scope IN: Explicit list of what this story covers.
- Scope OUT: An explicit list of what this story does not cover.
- Acceptance Criteria: 3–5 deterministic, BDD-formatted scenarios.
- Technical Notes: Implementation guidance, architectural dependencies, and data contracts.
- NFRs: Performance, security, and observability constraints (e.g., SLAs, logging).
- Definition of Ready (DoR): Checklist ensuring the team can actually start work.
- Definition of Done (DoD): Checklist ensuring the team can safely ship it.
Agent Architecture: How the Skill Thinks
INPUT: Rough description or HMW question
│
▼
[ Load Agent Skill Context ] ──► (SKILL.md, personas.md, templates)
│
▼
[ Stage 1: BDD AC Generation ]
│
▼
[ Stage 2: INVEST Validation Pass ]
│
▼
[ Stage 3: Fibonacci Estimation & Rationale ]
│
▼
[ Stage 4: Custom DoR/DoD Checklists ]
│
▼
OUTPUT: Tool-Agnostic Markdown Story
Because the custom agent loads these precise reference artifacts on every single invocation, the quality of the output remains entirely consistent — regardless of who on the team runs the command. There is zero dependency on individual prompt-engineering skills.
How to Use: Five Agent Invoke Modes
https://github.com/alwyndsouza/agile-story-skills#agile-story-writer
So What?
- Stop accepting bullet-point ACs. If your backlog contains statements like “should work on mobile", put them through Rewrite Mode. Agent skills allow you to institutionalise high-quality writing standards across the whole team.
- Write Scope OUT for everything. It takes ten seconds to write during grooming and saves hours of “wait, I thought this was included” arguments later.
- Validate against INVEST before planning — not during. Run the six INVEST questions in your head before a ticket makes it to the sprint board. If it’s a “no” to any vertex, send it back to the agent for another pass.
Alwyn D’Souza is working at the intersection of data mesh architectures, MLOps, and agentic AI systems. He writes about modern data engineering and practical AI implementations on Medium at @aradsouza and shares open-source tools at github.com/alwyndsouza.
References
- [1] Dan North: Introducing BDD — dannorth.net/introducing-bdd
- [2] Schwaber & Sutherland: The Scrum Guide — scrumguides.org
- [3] Bill Wake: INVEST in Good Stories, and SMART Tasks — xp123.com
- [4] Open Source Repository: github.com/alwyndsouza/agile-story-skills
Alwyn D’Souza is working at the intersection of data mesh architectures, MLOps, and agentic AI systems. He writes about modern data engineering and practical AI implementations on Medium at @aradsouza, shares open-source tools at github.com/alwyndsouza, and connects with the professional community on LinkedIn.
This article was originally published at https://aradsouza.medium.com/why-your-user-stories-are-broken-and-how-a-copilot-agent-skill-can-fix-them-14dd391d4dbb?source=rss-670f6306e3c0------2