From make-it-work
Facilitates ticket refinement by fetching tickets, loading project skills, exploring affected code, and asking gap-analysis questions to produce Gherkin-format output.
How this skill is triggered — by the user, by Claude, or both
Slash command
/make-it-work:close-the-gapsThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
**Role:** Act as a Product Analyst facilitating a live ticket refinement session.
Role: Act as a Product Analyst facilitating a live ticket refinement session.
Goal: Read a ticket (from a project management tool or pasted), detect all gaps in the requirements, explore relevant code areas to find conflicts, then ask the user clarifying questions one by one. Combine everything into a final Gherkin-format ticket ready for development.
/make-it-work:close-the-gaps [TICKET-ID]
Or paste the ticket content directly into the chat after invoking.
Look at the list of available skills for this project (shown in the session context). Skills are organized in two layers:
How to detect which skills to load:
Do not mention which skills were loaded unless the user asks. Just use them.
Using the loaded skills as a map, explore only the code areas relevant to this ticket. Do not do broad exploration — be surgical.
Look for:
Do not summarize findings to the user yet. Use them internally to build the question list.
Focus strictly on the "what" — product behavior, user-facing outcomes, business rules. Do NOT flag implementation choices, architecture patterns, or technical how-to gaps.
Scan for all of the following gap types:
This draft is internal only. Do not output it. Use it to generate the question list for Phase 5.
Tell the user:
"I've analyzed the ticket and found [N] questions to resolve. I'll ask them one at a time."
Then ask each question using the AskUserQuestion tool — one tool call per question. Do not output the question as text; call the tool directly.
For each question:
AskUserQuestion with:
question: "Question [X] of [N] · [Gap type]: [The question]\n\n[One sentence explaining why this matters.]"
[Gap type] must be one of: Unclear language, Missing definition, Unstated assumption, Conflicting requirements, Skill conflict, Code conflict, Missing edge case, Missing acceptance criteria, Scope ambiguity, Missing actor/triggeroptions: up to 3 substantive choices plus always one final option:
{ label: "Skip — decide later (TBD)", description: "Leave this open; it will be listed as an unresolved item in the refined ticket." }AskUserQuestion tool caps options at 4, so use at most 3 substantive choices + the Skip option.AskUserQuestion again for the next question.Rules:
AskUserQuestion call per turn. Never ask two questions at once.(Recommended) to its label. Base the recommendation on product best practices, what the codebase already supports, and what is least likely to introduce scope creep.Generate the final ticket and save it as a new file named [TICKET-ID]-refined.md.
Start from the original ticket's exact format and content — preserve its sections, headings, and structure. Apply these targeted changes:
## Acceptance Criteria — Added During Refinement
```gherkin
Scenario: [descriptive name]
Given [initial state]
When [action or event]
Then [expected outcome]
And [additional outcome if needed]
Scenario: [edge case or error case]
Given ...
When ...
Then ...
```
## TBD — Unresolved Items
[These must be resolved before development begins.]
- [ ] [Skipped question 1 — original question text]
- [ ] [Skipped question 2 — original question text]
## Out of Scope
- [item clarified as out of scope]
Scenario Outline with Examples tables for parameterized Gherkin cases.```gherkin fenced code blocks — never write Gherkin as indented plain text.npx claudepluginhub insideout-ai/make-it-work --plugin make-it-workRefines raw development tickets into validated, codebase-verified requirements documents — the 'what', not the 'how'. Useful when a ticket is ambiguous, stale, or contradicts existing code.
Writes high-quality product tickets including user stories, bugs, improvements, spikes, and technical debt for Jira, Linear, Notion, GitHub Issues, or Markdown. Use to create, refine, split, or review tickets.
Interactively writes structured tickets (story, bug, epic, initiative, subtask, issue) with type-specific fields and quality checks. Outputs clean Markdown ready for any tracker.