create-intent
/create-intent
Use when turning Jira stories, tickets, or raw requirement notes into business intent documents (intent, functional and non-functional requirements, open questions) before a PRD or design, when requirements are unclear, conflicting, or incomplete and need questions for a PO, or when the user says "create intent", "summarize the stories", "what does business want", or answers earlier intent questions
- Author
- bmad-labs ↗
- Repository
- skills ↗
- Licence
- MIT
- Last repository change
- 22.10.2026
Assessment and security
- Files in this package
- 10
- Scripts
- 1
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 1 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/check_intent.py
What it does and when to use it
Use when turning Jira stories, tickets, or raw requirement notes into business intent documents (intent, functional and non-functional requirements, open questions) before a PRD or design, when requirements are unclear, conflicting, or incomplete and need questions for a PO, or when the user says "create intent", "summarize the stories", "what does business want", or answers earlier intent questions
Triggers from the description
Original author description
Use when turning Jira stories, tickets, or raw requirement notes into business intent documents (intent, functional and non-functional requirements, open questions) before a PRD or design, when requirements are unclear, conflicting, or incomplete and need questions for a PO, or when the user says "create intent", "summarize the stories", "what does business want", or answers earlier intent questions
How it works
- Overview
- The 70 / 30 rule
- When to use
- Phases
- Question craft
- Source tags
- Templates
- Checklist
- Common mistakes
SKILL.md preview
---
name: create-intent
description: Use when turning Jira stories, tickets, or raw requirement notes into business intent documents (intent, functional and non-functional requirements, open questions) before a PRD or design, when requirements are unclear, conflicting, or incomplete and need questions for a PO, or when the user says "create intent", "summarize the stories", "what does business want", or answers earlier intent questions
---
# Create Intent
## Overview
Turn a set of requirement sources into a small, traceable document set that says what business wants, and a question list that makes the unclear parts clear.
**Core principle:** never guess silently. Every statement carries its source. Every gap becomes a question with an ID, both sides quoted, and a proposal. Questions go to the right person: business items to the PO, technical items to the tech lead.
## The 70 / 30 rule
**Follow 70%. Adapt 30%.** Each use case is different.
| Fixed (70% — always do) | Flexible (30% — decide per case) |
| --- | --- |
| Phases below, in order | Feature grouping and F-numbering |
| Read each source in full, one at a time, update docs after each | Extra documents (for example `states.md`, a code reference, a glossary) |
| Core docs: `intent.md`, `fr.md`, `nfr.md`, `memlog.md` | Table columns beyond the template minimum |
| Question rules (see Question craft) | Which review lenses to run |
| Source tags S / D / P / ? on anything not from a story | When to trace code for "same as screen X" |
| Business → `confirm-po.md`, technical → `confirm-tech.md` | How to present results (web page, chat, file) |
| Verification script before "done" | Number of questions per round |
When you adapt, say what you changed and why in one line of the report.
## When to use
- A list of Jira story folders (for example from `jira-to-local`) or pasted requirements.
- The user wants the business view: features, requirements, acceptance criteria (AC).
- The user answers questions that an earlier run of this skill wrote.
Not for: technical design (`architecture-design`), PRD writing (`bmad-prd`), splitting into stories (`bmad-create-epics-and-stories`).
## Phases
1. **Setup.** Read project writing rules (for example CLAUDE.md style section) and memories. Check that every source exists and its size. Create the doc folder. Scope = business need, FR, NFR, AC. Out of scope = technical design, technical solution, subtasks, checklists.
2. **Read and record, one source at a time.** Read the whole file. Then update all four core docs before the next file. Per source: FR section with AC as written, feature row in `intent.md`, reading-log row and new questions in `memlog.md`, NFR rows (a block repeated in every story is written once).
3. **Follow the links.** Stories that other stories depend on ("same as AC3 of X", "clones", "Visibility scope in X") — ask to pull them (`jira-to-local`), then read them like phase 2. Read `comments.md` of every story: comments often change scope.
4. **Trace referenced behavior.** "Follow the behavior of screen X" → one read-only Explore agent traces the code. Verify its key claims yourself (`file:line`). Write a separate reference doc. Put only user-facing behavior into `fr.md`.
5. **Show the questions.** Group by feature. Put "blocks design" items first. Offer a page or file where the user can answer.
6. **Apply answers.** Answers arrive in chat, in `memlog.md` (`=>` lines), or in a confirm file. Move each answer into the question table (Answer + Status columns). Add a **Decision (Q#)** line under the story AC it changes; keep the story text above it. Log user clarifications as `C#` rows. Save lasting boundary facts as memories.
7. **Split for the audience.** Unanswered and "confirm" business items → `confirm-po.md` (self-contained: terms, AC change table "current text → new text", new rules, stories not built, gaps with proposals). Technical items → `confirm-tech.md`. Ask the user which person answers what if unclear.
8. **Review.** When the user asks, run review skills on the doc set in parallel (`bmad-review-adversarial-general`, `bmad-review-edge-case-hunter`, `bmad-editorial-review-structure`, `bmad-editorial-review-prose`). Verify findings that cite sources. Turn gaps into `G#` (business) or `T#` (technical) rows with a proposal. Do not treat a PRD or other downstream doc as a source unless the user says so.
9. **Verify.** Run `python3 <skill>/scripts/check_intent.py <doc-folder>` and fix every finding. Then report.
Build the documents yourself, in the main conversation. Subagents only for read-only work: code tracing, review lenses, skill tests.
## Question craft
The questions are the main value. Each question:
- Has a stable ID: `Q#` (story questions), `G#` (business gaps from review), `T#` (technical items). Never renumber an answered item.
- Cites the source: story key + AC, file, or clarification ID.
- States the problem concretely: quote both sides of a conflict, name the missing case. Never "please clarify X".
- Carries a proposal when one is reasonable ("Proposed rule: orders over 500 EUR need manager approval …").
- Asks one thing. Split compound questions. Avoid negative questions ("Can the user never …").
- Names its audience: business (PO) or technical (tech lead).
Where to find questions — check every source for: [references/question-craft.md](references/question-craft.md).
## Source tags
Anything not copied from a story gets a tag: **S** story text, **D** decision (answer or comment), **P** our proposal waiting for approval, **?** open. Never write an inferred rule as if a story said it. Never invent an AC; write it as a proposal or a question.
## Templates
`templates/` holds one skeleton per file: `intent.md`, `fr.md`, `nfr.md`, `memlog.md`, `confirm-po.md`, `confirm-tech.md`, `states.md`. Copy, then fill. Keep headings; add sections when the case needs them (30%).
## Checklist
- [ ] Every source read in full; reading-log row for each
- [ ] Every source key appears in `intent.md`, `fr.md`, `memlog.md`
- [ ] Every story AC kept; AC as `**ACn**` + bullets (Given / When / Then)
- [ ] Repeated DoD / NFR block written once
- [ ] Linked stories and `comments.md` read, or listed as not read
- [ ] Every open item has ID, source, both sides, proposal, audience
- [ ] No inferred rule without a tag; no invented AC
- [ ] Answers moved into tables; Decision lines under the AC they change
- [ ] `confirm-po.md` has no technical words; stands alone for a PO
- [ ] Every G# / T# defined once and linked from `fr.md`
- [ ] `check_intent.py` passes
## Common mistakes
| Mistake | Fix |
| --- | --- |
| Reading all sources, then writing at the end | One source → update all docs → next source |
| Skipping `comments.md` | Comments hold scope changes; read them |
| Filling a gap with a sensible guess | Write the guess as **P** proposal inside a question |
| Question without a proposal | Add the default you would pick, and why |
| Business and technical questions in one list | Split: PO gets business only |
| Deleting story text when a decision changes it | Keep it; add **Decision (Q#)** below |
| Copying the same NFR source to every row | One row, source "all stories" |
| Patch scripts that half-apply | Exact-match replacements with assert; re-run the whole script after a fix |
| History in docs | Docs hold latest state; `memlog.md` is the only log |
Files in this package (10)
- SKILL.md 7 KB
- references/question-craft.md 3 KB
- scripts/check_intent.py 5 KB
- templates/confirm-po.md 2 KB
- templates/confirm-tech.md 1 KB
- templates/fr.md 1 KB
- templates/intent.md 2 KB
- templates/memlog.md 1 KB
- templates/nfr.md 1 KB
- templates/states.md 1 KB
Versions
The database has no other skills named create-intent.
Database snapshot: 13.11.2026 · package version e0ead80502e2 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100document-feature
Create comprehensive feature requirement documents. Use when asked to document a feature, write feature requirements, or create feature specifications. Includes user stories, functional requirements, data model review, workflows, and edge cases. - 100requirements-writer
Step 2 of the requirements workflow — drafts requirements once the business need is understood, the step after requirements-start. Turns a feature idea, a business request, or notes from a discovery workshop into clear, testable, traceable requirements: functional requirements,… - 90product-prd
Use to write or refine a PRD after product demand is reasonably understood and before acceptance criteria, design handoff, engineering breakdown, or implementation planning. Use when the user asks for a PRD, product requirements document, scope definition, engineering-ready… - 95create-prd
Use this skill when the user says 'create PRD', 'product requirements', 'write requirements', 'epics and stories', 'acceptance criteria', or when docs/brief.md exists and needs expansion into a full Product Requirements Document. This skill reads the brief, generates 5-8 epics,… - 100requirement-architect
Converts high-level product intent into traceable PRDs and User Stories. Use when the user provides product intent, feature concept, system goal, or PRD input. - 100requirements-scoping
This skill should be used when the user needs to "clarify requirements", separate "functional vs non-functional requirements", "scope the problem", figure out "what questions should I ask", state the "requirements for <X>", or otherwise pin down a vague design prompt before…