spec-flow-analyzer

Analyzes specifications to map user flows, detect gaps, and output clarifying questions.

Updated Mar 14, 2026
One-click install
npx skills add https://github.com/Andreicr1/netz-analysis-engine --skill spec-flow-analyzer-andreicr1
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: spec-flow-analyzer
Source: https://github.com/Andreicr1/netz-analysis-engine/tree/main/.gemini/skills/spec-flow-analyzer
Command: npx skills add https://github.com/Andreicr1/netz-analysis-engine --skill spec-flow-analyzer-andreicr1

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Analyzes specifications and feature descriptions from the end-user perspective. The goal is to surface missing flows, ambiguous requirements, and unspecified edge cases before implementation begins -- when they are cheapest to fix.

Core Features & Use Cases

  • Ground in the Codebase: Before analyzing the spec in isolation, search the codebase for context to surface constraints and patterns that shape the analysis.
  • Map User Flows: Walk through the spec as a user, mapping entry points, decision points, happy paths, and terminal states.
  • Find What's Missing: Compare mapped flows against the spec to identify gaps such as unhappy paths, state transitions, permission boundaries, and integration seams.
  • Formulate Questions: For each gap, generate concrete, decision-ready questions with rationale and default assumptions.

Quick Start

Provide the spec or feature description to the analyzer and receive a structured flow map, gap report, and clarifying questions.

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 gaps and edge cases in product specifications?

To find gaps in product specifications, you analyze feature descriptions by mapping user flows, entry points, and decision points to surface missing paths and ambiguous requirements. This process generates a concise gaps report with actionable, decision-ready questions.

What is specification gap analysis from the end-user perspective?

Specification gap analysis is the process of walking through a feature spec as a user to identify missing flows, unhappy paths, and unspecified state transitions. It surfaces ambiguities before implementation begins, producing a structured flow map and clarifying questions.

How do I analyze user flows to surface missing paths before implementation?

You analyze user flows by mapping entry points, happy paths, and terminal states, then comparing these mapped flows against the original spec. This comparison detects missing paths, permission boundaries, and integration seams, resulting in formulated questions with rationale and default assumptions.

Can I analyze feature descriptions using existing codebase context?

Yes, you can ground the analysis in your codebase by searching for existing constraints and patterns before evaluating the spec. This contextual grounding shapes the flow mapping and gap detection process to reflect actual technical limitations.

When do I need to run a gap analysis on feature specifications?

You need to run a gap analysis on feature specifications before implementation begins, when fixing missing flows and edge cases is cheapest. It is necessary whenever you have plans or feature descriptions across product areas that require validation against end-user requirements.

What is the best way to generate clarifying questions for ambiguous requirements?

The best way to generate clarifying questions for ambiguous requirements is to map the user flows, identify specific gaps like unhappy paths and state transitions, and formulate concrete, decision-ready questions complete with rationale and default assumptions.