Write user story
Use when creating, writing, or refining a user story or ticket. Produces structured stories with purpose/overview, functional requirements, Given-When-Then acceptance criteria, and manual testing guidance. Also use when asked to define acceptance criteria, scope a feature, or prepare a story for development.From its SKILL.md
npx -y skills add folio-org/folio-eureka-ai-dev --skill write-user-storyAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
2 things to look at
- no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
- 3 stars3 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
What its file declares
Copied from the file, not written here
The file declares its own license as Apache-2.0. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.
SKILL.md
4.7 KB, as published. Nobody here has run it
Write User Story
User Story Structure
Every story must have these sections (in order):
- Purpose/Overview — What it achieves and why. Include business context, user persona, and links. Optionally add a Technical Details/Approach sub-section for architectural decisions without over-specifying implementation.
- Requirements/Scope — Functional requirements (specific, measurable). Non-functional requirements only when they have measurable impact. Out of Scope only when genuine ambiguity exists.
- Acceptance Criteria — Testable conditions in Given-When-Then format.
- Testing Guidance — Manual testing scenarios only. No unit/integration test specs.
Template
## Purpose/Overview
[High-level description of what this story achieves and why it's important.
Include business context, user persona, and links to related work.]
### Technical Details/Technical Approach (Optional)
[Architectural decisions or implementation strategy — don't over-specify.]
---
## Requirements/Scope
### Functional Requirements
1. [Specific functionality to implement]
2. [Input/output expectations]
3. [Business rules and constraints]
### Non-Functional Requirements (only if significant)
1. [Data integrity requirements]
2. [Performance — only if measurable impact]
3. [Security — only if specific requirements exist]
### Out of Scope (only if needed for clarity)
- [Include ONLY if there's genuine ambiguity about scope]
---
## Acceptance Criteria
**AC1: [Scenario name]**
- Given [initial context]
When [action occurs]
Then [expected outcome]
**AC2: [Error handling scenario]**
- Given [error condition]
When [action occurs]
Then [expected error behavior]
---
## Testing Guidance
### Manual Testing
**Scenario 1: [Primary user workflow]**
1. [Step-by-step instructions]
2. [Expected outcomes]
**Scenario 2: [Edge case]**
1. [Steps]
2. [Expected outcomes]
**Note:** Unit test specs, integration test code, and test data details belong in the implementation plan, not here.
---
## Additional Notes (optional)
[Risks, dependencies, or other considerations]
## Related Links (optional)
- [Design documents, API specs, related stories]
Writing Guidelines
Standard User Story Format
As a [user persona/role]
I want [goal/desire]
So that [benefit/value]
INVEST Principles
- Independent — deliverable separately
- Negotiable — details can be refined
- Valuable — delivers clear value
- Estimable — team can estimate effort
- Small — completable within one sprint
- Testable — clear verification criteria
Best Practices
Do's ✓
- Write from the user perspective — focus on value, not implementation
- Make acceptance criteria specific and testable
- Include error scenarios and edge cases
- Use consistent domain terminology
- Link dependencies and related stories
- Collaborate with developers, testers, and stakeholders
Don'ts ✗
- Don't write technical tasks as stories ("Refactor UserService" is a task, not a story)
- Don't be vague — "improve performance" needs metrics
- Don't skip acceptance criteria
- Don't add non-functional requirements unless they have measurable impact
- Don't add "Out of Scope" unless there's genuine ambiguity
- Don't include unit/integration test specs in Testing Guidance
- Don't over-specify implementation — leave the "how" to developers
Quick Reference Checklist
- Purpose clearly explains the value and context
- Requirements are specific and measurable
- Acceptance criteria are testable and unambiguous
- Error scenarios and edge cases are covered
- Testing guidance contains manual scenarios only
- Dependencies are identified and linked
- Story is sized for one sprint
- Technical approach is outlined if needed, but not over-specified
- Non-functional requirements included only if significant
- "Out of Scope" omitted unless genuinely needed
For deep-dive guidance on each section, see references/section-details.md. For common pitfalls with before/after examples, see references/pitfalls.md. For a complete example story, see references/example.md. For JIRA markup conversion, see references/jira.md.