What qualifies as a gap?

Any missing decision, unaddressed scenario, dependency, persona blind spot, phase-transition prerequisite, or unasked question identified while grounding in the project docs.

How should gaps be documented?

As an action list: for each gap, state what's missing, where it should be addressed (file/section/identifier), and the proposed resolution or the question that needs answering.

Why segment gaps and state total count?

Segmenting by risk helps prioritize high-impact omissions and communicates traceability. Stating the total count provides scope and ensures all gaps are addressed across sessions.

gaps

Scanned

npx machina-cli add skill rana/yogananda-skills/gaps --openclaw

Files (1)

SKILL.md

2.1 KB

Read all project markdown documents to ground in the project's actual state.

Gap Analysis

Systematically search for:

Missing decisions — Areas where the design implies a choice but no ADR or explicit decision exists. Implicit assumptions that should be explicit.
Unaddressed scenarios — Edge cases, failure modes, or user journeys not covered. What happens when things go wrong?
Dependency gaps — Technologies, services, or capabilities assumed but not specified. Integration points without defined contracts.
Persona blind spots — Users, roles, or contexts not considered. Who is underserved?
Phase transition gaps — What's needed to move between phases that isn't specified? Prerequisites assumed but not documented.
The unasked questions — What questions would benefit from being asked? What isn't being asked?
Spatial gaps — Negative space (what's conspicuously absent from the whole), orthogonal space (what reframings reveal hidden gaps), adjacent space (what's one step beyond current scope that matters).

Focus area: $ARGUMENTS

For every gap found:

What's missing (specific, not vague)
Where it should be addressed (file, section, identifier)
Proposed resolution or the question that needs answering

Present as an action list. No changes to files — document only.

Output Management

Hard constraints:

Segment output into groups of up to 8 gaps, ordered by risk of the omission.
Write each segment incrementally. Do not accumulate a single large response.
After completing each segment, continue immediately to the next. Do not wait for user input.
Continue until ALL gaps are reported. State the total count when complete.
If the analysis surface is too large to complete in one session, state what was covered and what remains.

What questions would I benefit from asking?

What am I not asking?

Source

git clone https://github.com/rana/yogananda-skills/blob/main/skills/gaps/SKILL.mdView on GitHub

Overview

Gap analysis systematically identifies missing decisions, unaddressed scenarios, and other blind spots by grounding in the project's actual state through all project Markdown documents. This focused exercise helps teams surface dependencies, risks, and questions early, ensuring a complete design before implementation. Focus area: ARGUMENTS.

How This Skill Works

Begin by reading all project Markdown documents to ground in the current state. Then perform a structured gap analysis across seven categories: Missing decisions, Unaddressed scenarios, Dependency gaps, Persona blind spots, Phase transition gaps, The unasked questions, and Spatial gaps. For each gap, document what’s missing, where it should be addressed (file/section/identifier), and a proposed resolution or the question that needs answering, presented as an actionable list.

When to Use It

Before starting implementation to ensure all decisions are explicit
After completing a design phase to validate coverage and assumptions
During design reviews to surface hidden risks and edge cases
In project handoffs to ensure continuity and clarity
When asking 'what am I not seeing?' to broaden scope

Quick Start

Step 1: Read all project Markdown documents to ground in the current state
Step 2: Identify gaps across the seven categories, noting where they occur
Step 3: For each gap, record what's missing, where to fix it, and the proposed resolution or question

Best Practices

Explicitly capture missing decisions with a traceable ADR or decision artifact
Annotate each gap with the exact file, section, or identifier it belongs to
Prioritize gaps by risk and potential impact on delivery
Require a concrete resolution or a clarified question for every gap
Group gaps into segments (up to 8 per segment) and document them iteratively

Example Use Cases

A design implies a data contract with an external API, but no explicit response schema or ADR exists.
Edge-case user journeys (e.g., payment failure) are not covered by any scenario.
A critical dependency (authentication service) is assumed but lacks integration details.
Admin roles are mentioned, but corresponding personas and access controls are not defined.
Phase transition prerequisites between design completion and implementation are undocumented.

Frequently Asked Questions

Add this skill to your agents