design-interaction-flows

Design feature flows, task flows, and wireflows with systematic edge-case and failure-path enumeration.

1|Updated Jul 13, 2026
One-click install
npx skills add https://github.com/dineshrevunuru/SuperSkills --skill design-interaction-flows-dineshrevunuru
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: design-interaction-flows
Source: https://github.com/dineshrevunuru/SuperSkills/tree/main/design-interaction-flows
Command: npx skills add https://github.com/dineshrevunuru/SuperSkills --skill design-interaction-flows-dineshrevunuru

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Product requirements describe system capabilities, not user paths, so teams ship features where edge cases, failure states, and alternate entry points were never designed. This Skill turns a PRD or brief into a complete interaction pathway — happy path, every branch, and every failure with a named cause and recovery — before any high-fidelity screen work begins. ## Core Features & Use Cases - Artifact decision tree: Chooses between task flow, user flow, and wireflow based on whether the path branches and whether screens exist yet, and routes research-time journey mapping elsewhere. - PRD-to-scenario translation: Converts every requirement sentence into scenarios, branches, and open questions, with a rule that PRD silence becomes a question for the PM rather than an invented assumption. - Eight-probe branch enumeration: Systematically surfaces user decisions, input variance, system failures, state variance, interruptions, concurrency, reversal, and slips vs mistakes at every step. - Use Case: Given a PRD line like "users can book an appointment with a stylist at an available slot," produce a flow spec with the happy path, a branch inventory, a failure-path table (e.g., "that 2:00 slot was just booked" with re-entry to slot selection), and a Mermaid diagram. ## Quick Start Ask the AI to map the end-to-end user flow for your feature from its PRD, including all edge cases and failure paths, and output a flow spec with a Mermaid diagram.

Frequently Asked Questions about design-interaction-flows

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I turn a PRD into user flows and scenarios?

Convert each requirement sentence into a scenario table with actor, trigger, happy path, and open questions. Every "should/must/can" spawns a scenario, every "when/if/unless" spawns a branch, and anything the PRD is silent on becomes an open question with an owner rather than an assumption.

What is the difference between a user flow, task flow, and wireflow?

A task flow is a single linear path with no decisions. A user flow adds branching logic with decision diamonds but no UI. A wireflow replaces boxes with low-fidelity wireframes once screens exist, which suits apps where one screen changes in place.

How do I find edge cases in a user flow before designing screens?

Run eight probes at every step: user decisions, input variance, system failure, state variance, interruption, concurrency, reversal, and slips vs mistakes. Each branch must end as goal reached, deliberate exit, or a designed failure with a named cause and re-entry point.

When should I use a journey map instead of a user flow?

Use a journey map when mapping what users experience across channels over time with emotions and phases — that is research-time work. Use a user flow for design-time pathways through a feature you are building, where decision diamonds and failure branches matter.

Why should error states name a specific cause instead of a generic message?

A generic "something went wrong" node cannot be recovered from because the user does not know what happened or what to do next. Each failure path needs a named cause in user language, like "that slot was just booked," plus a re-entry step with preserved state.

How do I measure whether a flow is too long?

Use interaction cost — mental plus physical effort — rather than click count. Compare happy-path step count against the current product or a competitor, cap meaningful options per decision point around five, and defer optional complexity with progressive disclosure.