Mini-App Spec

    1

    Generate executable HTML5 specifications that reconcile PRDs, Figma designs, and code into a single source of truth.

    Free

    2 usesSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Mini-App Spec

    Example session with this skill installed

    Start a new spec for the 'Checkout' feature. Title it 'Secure Checkout Flow'. Use the current PRD in docs/prd.md and the Figma link for the UI layout.

    • Read your context and instructions
    • Compiled the mini-app spec

    I have initialized the specification for the Secure Checkout Flow. I've registered the PRD and Figma link as sources and decomposed the requirement into three core vertical flows for alignment.

    Specification Status: Secure Checkout Flow

    Flow IDDescriptionRisk TierCoreStatus
    flow-01Guest Checkout with Stripe IntegrationHighYespending
    flow-02Registered User Saved-Card PaymentMedYespending
    flow-03Address Validation and Tax CalculationMedNopending

    Source Mapping

    • src-01: docs/prd.md (Version: v2.1) - Mapped to all flows.
    • src-02: figma://file/checkout-v4 - Mapped to UI layout for flow-01 and flow-02.

    Next steps

    1. Review the decomposed flow list above and confirm the risk tiering.
    2. I will then execute save --gate gate1 to anchor these requirements in git.
    3. We will begin per-flow alignment starting with flow-01.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Software requirements often drift from implementation, leading to broken acceptance criteria and "stale" documentation. This skill enforces a Single Source of Truth (SSOT) by generating a self-contained, executable HTML5 specification that acts as a machine contract, operable prototype, and BDD test suite. It bridges the gap between Figma designs and code, ensuring every feature is verified against a frozen behavioral fingerprint before acceptance.

    What it does

    • Executable Contract Generation produces a mini-app-spec.html containing state machines, BDD scenarios, and embedded prototypes.
    • Automated Verification Gate freezes commands and collects evidence per scenario to prevent hand-waived passing status.
    • Multi-Source Reconciliation maps requirements from PRDs, Figma (via MCP), and code into unified vertical user flows.
    • Interactive Review Sessions launches a local browser session where users annotate the UI directly to generate structured change tickets.
    • Mechanical Rule Enforcement blocks acceptance unless specific preconditions, like zero proposed annotations and valid source batches, are met.

    How it works

    1. Resume or Initialize: Use status to recover context or new to create a fresh artifact from the stateless engine template.
    2. Decompose and Map: Register sources and decompose requirements into tiered flows, followed by a mandatory confirmation gate.
    3. Align and Prototype: Fill in states and transitions, then open the artifact for visual alignment and fingerprint freezing.
    4. Reconcile and Accept: Run record-run to collect evidence, then accept with verbatim user confirmation to stamp the final gate.

    Frameworks & tools

    The system uses a Node.js CLI spec.mjs for all contract writes and a stateless HTML5/CSS/JS engine. It integrates with Git for replay anchors and recovery, supports Figma via MCP, and enforces CSP-compliant, zero-dependency templates.

    Why this beats prompting it yourself

    Generic prompts fail to maintain state across long implementation cycles and allow "status cheating" where AI claims success without evidence. This skill uses a mechanically enforced validator and git-anchored replay anchors to ensure the spec and implementation never diverge.

    Use cases

    • Documenting complex multi-state UI components that require high-fidelity prototyping.
    • Auditing legacy codebases by reconciling existing behavior against new BDD requirements.
    • Managing stakeholder sign-off with an operable, annotated "live" specification.
    • Generating verifiable evidence for compliance-heavy features where manual testing is insufficient.

    Known limitations

    Requires a Git repository environment to function. The engine forbids external CDNs or heavyweight frameworks; all visual interactions must be self-contained within the HTML artifact.

    Requires a local Git repository for replay anchors. Execution is restricted to Node.js environments. External CDNs and heavyweight JS frameworks are forbidden in templates.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    2 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Node.js
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill generates a self-contained HTML5 file that functions as a live prototype, a BDD test suite, and a machine-readable contract, ensuring your code always matches your design and requirements.

    The skill requires a Git repository environment and a Node.js runtime to execute the `spec.mjs` CLI, which manages the contract writes and state transitions.

    Unlike standard prompting, this skill uses a 'Mechanical Rule Enforcement' system that blocks feature acceptance until specific preconditions and behavioral fingerprints are verified with evidence.

    Yes, it integrates with Figma via MCP (Model Context Protocol) to map design elements directly into unified user flows within the executable specification.

    You receive the core `spec.mjs` CLI tool, the stateless HTML5 engine template, and the full workflow logic for initializing, mapping, and accepting specifications.

    Yes, the skill includes a 'resume' function that uses Git-anchored replay anchors to recover context and continue building even after long breaks or context window resets.

    New in Agents & Orchestration