spec-flow-analyzer

Analyze product specs to map user flows, permutations, and gaps.

12|2|Updated Jan 27, 2026
One-click install
npx skills add https://github.com/jikig-ai/soleur --skill spec-flow-analyzer-jikig-ai
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: spec-flow-analyzer
Source: https://github.com/jikig-ai/soleur/tree/main/.openhands/skills/spec-flow-analyzer
Command: npx skills add https://github.com/jikig-ai/soleur --skill spec-flow-analyzer-jikig-ai

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The spec-flow-analyzer converts ambiguous specifications and feature descriptions into exhaustive, developer-ready user flow maps and a prioritized list of missing requirements so implementations don't break or get reworked later.

Core Features & Use Cases

  • Comprehensive Flow Mapping: Enumerates all distinct user journeys, decision points, state transitions, and integration touchpoints.
  • Permutation & Edge Case Discovery: Systematically generates permutations for first-time vs returning users, device and network contexts, concurrent actions, and error/recovery paths.
  • Gap Identification & Question Generation: Produces categorized gaps (validation, error handling, security, accessibility) and formulates prioritized, actionable clarifying questions for product and engineering handoff.
  • Use Case: Given a PRD for a new onboarding flow, deliver numbered flow diagrams, a permutations matrix for mobile/desktop and offline scenarios, and a prioritized list of missing specs with exact questions for the PM and API owners.

Quick Start

Ask the agent to analyze the provided specification for complete user flows, edge cases, and missing requirements.

Frequently Asked Questions about spec-flow-analyzer

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

FAQPage Schema
How do I find missing requirements and edge cases in a PRD before implementation?

To find missing requirements in a PRD, you analyze specifications to map complete user flows and identify gaps. This process systematically enumerates journeys, decision points, and permutations to produce categorized gap lists and prioritized clarifying questions for developer handoff.

What is user flow gap analysis and when do I need it for feature planning?

User flow gap analysis is the process of converting ambiguous feature descriptions into exhaustive flow maps to identify missing specifications. You need it during feature planning to prevent implementation breaks and rework by discovering edge cases across different user states and device contexts.

How do I generate clarifying questions for product specs and technical designs?

You generate clarifying questions for product specs by applying flow analysis to enumerate all possible user journeys and state transitions. This produces a prioritized, actionable list of categorized gaps regarding validation, error handling, security, and accessibility for engineering handoff.

Can I use flow analysis to map permutations for first-time vs returning users?

Yes, flow analysis systematically generates permutations for first-time versus returning users. It maps distinct user journeys, device and network contexts, concurrent actions, and error recovery paths to deliver detailed permutation matrices for developer-ready specifications.

What is the best way to analyze technical designs for unhandled user journeys?

The best way to analyze technical designs for unhandled journeys is to systematically enumerate all state transitions and integration touchpoints. This approach outputs detailed flow diagrams and categorized gap lists, ensuring complete coverage of validation and error recovery paths.

Does spec flow analysis work for offline scenarios and concurrent user actions?

Yes, spec flow analysis works for offline scenarios and concurrent actions by systematically generating permutations for varying network contexts. It identifies error and recovery paths within the user flow, ensuring the specification handles these edge cases before implementation begins.