specflow-simulate
/specflow-simulate
Simulates end-to-end usage of a Specflow story across multiple personas and divergent routes to discover gaps, edge cases, and unhandled branches BEFORE the story is built — then proposes each finding as a concrete story addition (new REQ, negative-path AC, Gherkin branch, or journey step). This is the high-value exploratory step run right after a story is created, distinct from the pre-flight compliance gate. This skill should be used when the user asks to "simulate this story", "simulate usage end to end", "find gaps and edges", "run personas through this", "stress-test this story", or invok
- Author
- hulupeep ↗
- Repository
- specflow ↗
- Licence
- MIT
- Last repository change
- 28.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 28.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Simulates end-to-end usage of a Specflow story across multiple personas and divergent routes to discover gaps, edge cases, and unhandled branches BEFORE the story is built — then proposes each finding as a concrete story addition (new REQ, negative-path AC, Gherkin branch, or journey step). This is the high-value exploratory step run right after a story is created, distinct from the pre-flight compliance gate. This skill should be used when the user asks to "simulate this story", "simulate usage end to end", "find gaps and edges", "run personas through this", "stress-test this story", or invok
Triggers from the description
Original author description
Simulates end-to-end usage of a Specflow story across multiple personas and divergent routes to discover gaps, edge cases, and unhandled branches BEFORE the story is built — then proposes each finding as a concrete story addition (new REQ, negative-path AC, Gherkin branch, or journey step). This is the high-value exploratory step run right after a story is created, distinct from the pre-flight compliance gate. This skill should be used when the user asks to "simulate this story", "simulate usage end to end", "find gaps and edges", "run personas through this", "stress-test this story", or invok
How it works
- Tier applicability before this procedure
- When to run
- The method
- Parallel personas (optional, for thorough runs)
- Output shape
- Reference
SKILL.md preview
--- name: specflow-simulate description: Simulates end-to-end usage of a Specflow story across multiple personas and divergent routes to discover gaps, edge cases, and unhandled branches BEFORE the story is built — then proposes each finding as a concrete story addition (new REQ, negative-path AC, Gherkin branch, or journey step). This is the high-value exploratory step run right after a story is created, distinct from the pre-flight compliance gate. This skill should be used when the user asks to "simulate this story", "simulate usage end to end", "find gaps and edges", "run personas through this", "stress-test this story", or invokes /specflow-simulate on a story file or GitHub issue. Scope is Specflow story exploration — it is generative (surfaces and proposes), not a build or a verification gate. --- # Specflow Simulate ## Tier applicability before this procedure Read `SPECIFICATION.md` (source kit: `templates/SPECIFICATION.md`). Before using the detailed procedure below, run `node scripts/specflow-tier.cjs inspect <record.json> specflow-simulate inspect`. Stop on exit 2 and report the returned blocker. Production work repeats the check with `resume` at re-entry and `finish` before claiming completion. A missing record cannot prove readiness; retrieve the current issue and scoped evidence. Labels alone never grant build-ready status. The detailed artifact/pre-flight requirements below apply to the selected build-ready slice and its relevant seams. Thin work reports planning state and the next justified decision without generating full schemas, fixture packages or simulations. Contracted work reviews applicable irreversible decisions and includes a paper persona walkthrough for UI flows. Reuse shared decisions; leave future siblings thin. Required privacy, permission, execution and release gates remain in force. Reconcile contradictory custom legacy instructions explicitly using the shared policy; do not claim they passed. Run a story through realistic usage — multiple personas, multiple routes — to find the gaps and edges a single happy-path reading misses. The output is not commentary; it is a set of concrete, proposed additions that make the story sharper before any code is written. ## When to run Trigger on: "simulate this story", "simulate usage end to end", "find gaps / edges", "run personas through this", "stress-test this story", or `/specflow-simulate <file-or-issue>`. Position in the Specflow flow — this runs *after create, before audit*: ``` create (specflow-writer) → SIMULATE (this skill) → audit/uplift (specflow-audit) → pre-flight gate ``` It is generative (discover + propose). It is NOT the pre-flight gate (that verifies and blocks). Do not conflate the two. ## The method Full method (persona archetypes, route taxonomy, gap→edit mapping, output format) is in `references/simulation-method.md`. Summary: 1. **Read the story** (issue via `gh issue view <n> --json title,body,comments`, or the file). Extract the intended outcome, the actors, and the surfaces. 2. **Derive 3–5 distinct personas** — not demographics; *behavioural archetypes* that route through the problem differently (e.g. power user, first-timer, adversarial/edge user, wrong-permissions user, interrupted/returning user). Pick the ones that stress *this* story. 3. **Walk each persona through the story end-to-end** — the happy path AND at least one divergent route per persona: where do they get confused, blocked, take an unanticipated branch, hit an empty/error/permission state, or make a decision the story didn't plan for? 4. **Collect gaps** — each gap is a concrete moment where the story is silent, ambiguous, or wrong for that persona/route. 5. **Map every gap to a story edit** — a new `REQ-NN`, a negative-path `AC`, a new Gherkin scenario/branch, a new journey step + `data-testid`, or a flagged open question. A gap with no proposed edit is incomplete. 6. **Propose, don't silently rewrite** — post the findings as ONE labelled block: a GitHub comment (`node scripts/specflow-publication.cjs <request.json>`) or an appended `## Simulation Findings (proposed)` section. The user (or the subsequent specflow-audit uplift) folds accepted items into the story body. Only edit the body directly if the user explicitly says to apply. ## Parallel personas (optional, for thorough runs) For a deep simulation, fan out one agent per persona so each route is explored independently and blind to the others — this surfaces more than one sequential reading. The `ux-critique` skill already runs parallel persona agents against a live screen; reuse that pattern here, scoped to the *story text* rather than a running UI. Then dedupe and synthesize into the single findings block. ## Output shape Report, and post as the findings block: - the personas chosen and why each stresses this story, - per persona: the route taken + the gaps found, - a consolidated **proposed-additions** list (REQ / AC / Gherkin / journey-step), each tagged with the persona/route that motivated it, - open questions that need a human decision (don't invent answers to product questions). ## Reference - `references/simulation-method.md` — persona archetypes, route taxonomy, gap→edit mapping table, and the `## Simulation Findings (proposed)` format. Scoped grading uses the shared `specflow-reviews.cjs` issue/tier ledger through Duo preparation (`specification.targetTier`). Continue while first-time verified evidence advances. Two no-progress reviews or three invalid responses require diagnosis. Further materially different recoveries need fresh stable executed observations not already used in the episode; a fixed recovery count does not end subscription work. Repeated facts, renamed notes or missing evidence retain their concrete diagnostic blocker. Do not reset history via host/run names. An ungraded fix remains ungraded until an independent current regrade passes. See duo-build for recover-review and optional execution checkpoints. Publication: save the sanitized proposed comment in `bodyFile`, then write a request JSON with `repo`, `issue`, `bodyFile`, and all `linkedFiles`. Run `node scripts/specflow-publication.cjs <request.json>` and stop on non-zero exit. It requires the project mechanical scanner and private-baseline canary where applicable. Never publish private sources or raw provider records. Preserve concurrent issue-body edits: publish proposals instead of replacing a fetched body.
Files in this package (2)
- SKILL.md 6 KB
- references/simulation-method.md 5 KB
Versions
The database has no other skills named specflow-simulate.
Database snapshot: 13.11.2026 · package version 97dbe76cef10 (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
- 90specflow-audit
Audits a Specflow story/ticket for spec-compliance and surgically uplifts it — adding only the missing executable contract sections (SQL/RLS, TypeScript interfaces, invariant codes, Gherkin, acceptance criteria, Definition of Done, data-testid coverage) — then runs a pre-flight… - 95specflow-skill
Generates SpecFlow BDD tests for C#/.NET with Gherkin feature files and step bindings. Use when user mentions "SpecFlow", "C# BDD", ".NET Gherkin", "[Binding]", "[Given]/[When]/[Then]". Triggers on: "SpecFlow", "C# BDD", ".NET BDD", "step bindings", "[Binding]". - 100specflow-loop-selector
Choose the lightest Specflow workflow that covers an ask’s size, uncertainty and risk, then select a loop only when needed. Use for work triage, proportionate verification, loop selection, or explicit spec-build, feature-build and Gate D requests. A lightweight decision does not start a loop. - 100reqnroll-testing
Configures Reqnroll (the canonical .NET BDD framework) - install via `dotnet add package Reqnroll`, author `.feature` files in Gherkin, write step bindings as `[Given/When/Then]`-decorated methods in any C# class, runs via `dotnet test`. Reqnroll is the SpecFlow successor… - 90specflow
Use when the user asks Claude Code to create, inspect, validate, run, dynamically review, patch, pause, continue, or resume Specflow/Aflow agent workflows in the current repository. - 90specflow
Use when the user asks Codex to create, inspect, validate, run, dynamically review, patch, pause, continue, or resume Specflow/Aflow agent workflows in the current repository.