Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Concept Exploration & Design Gate

    1

    Turns every request into an approved, documented design before a line of code is written, eliminating rework caused by hidden assumptions and scope drift.

    Free

    2 uses2.0 (1 review)
    Concept Exploration & Design Gate

    Concept Exploration & Design Gate

    Example session with this skill installed

    I want to add a bulk invoice export feature to our billing app (Rails 7, Postgres, in /home/me/billing). Customers keep asking to download invoices as PDF and CSV, and I imagine an Export button on the invoices page. The repo has a README, some half-finished reports code, and recent commits around payment webhooks. Before anyone writes code, run the full concept exploration on this: inspect the project context, interview me one question at a time about what actually matters, compare the realistic approaches with trade-offs and a recommendation, get my sign-off section by section, write the final design doc under docs/designs/, and then move into implementation planning.

    • Read your context and instructions
    • Compiled the concept exploration

    Summary

    Concept exploration for the bulk invoice export feature is complete. Requirements were locked through six sequential questions, three approaches were compared, and the approved design is committed to docs/designs/2026-09-14-invoice-export.md. No code was written — implementation is ready to plan.

    ItemBeforeAfter
    Scope'add PDF export'CSV + PDF, up to 10k rows, async job
    Open questions7 unresolved0 — all answered
    Approachesnone3 compared, 1 recommended
    Design recordnonedocs/designs/2026-09-14-invoice-export.md (commit a41f9c2)

    Key decisions

    • Async background job chosen over synchronous download: p95 for 10k rows exceeds request timeout
    • Reuses the existing ReportService queue instead of introducing Celery
    • YAGNI: email-delivery option dropped; users download from the UI

    Next steps

    • Invoke writing-plans to convert the approved design into a phased roadmap
    • Review the committed design doc before the plan starts
    • Revisit success criteria (export under 45s per 1k rows) at acceptance testing

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

    About this skill

    Stop wasting hours on rework caused by misunderstood requirements and scope drift. This skill enforces a design-first workflow, ensuring every feature, refactor, or component is fully architected and approved before a single line of code is written. It transforms vague requests into structured technical documentation through systematic inquiry.

    What it does

    • Intent clarification by asking sequential, focused questions to uncover hidden constraints and success criteria.
    • Approach exploration by generating 2-3 distinct solution paths with analyzed trade-offs and expert recommendations.
    • Incremental validation through section-by-section design presentations that require explicit user sign-off.
    • Automated documentation by generating and committing design specs to docs/designs/ for permanent record.
    • Implementation handoff by preparing the context needed to transition directly into detailed planning skills.

    How it works

    1. Context discovery scans your current codebase and recent commits to understand the existing state.
    2. Clarification loops use structured, often multiple-choice questions to define the "why" and "what" without ambiguity.
    3. Design drafting presents the architecture, data flow, and error handling for your review.
    4. Final approval triggers the creation of a dated design markdown file and its commit to your repository.

    Frameworks & tools

    This skill is platform-agnostic and works with any tech stack. It utilizes Mermaid.js for flowcharts and follows YAGNI principles to ensure lean architecture.

    Why this beats prompting it yourself

    Generic prompts often jump straight to code, missing edge cases and integration impacts. This skill enforces a strict gate, preventing the AI from "hallucinating" an implementation plan before you have agreed on the fundamental architecture.

    Use cases

    • Defining the architecture for a new microservice or API endpoint.
    • Mapping out complex state management changes in a frontend application.
    • Evaluating trade-offs between different third-party library integrations.
    • Establishing a shared source of truth for a feature before team execution.

    Known limitations

    Does not perform the actual coding or implementation; it is strictly a design and alignment gate. Requires the writing-plans skill for the subsequent implementation roadmap.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Workflow Automation.

    Requires an interactive session — the approval gate stalls in fully unattended or cron runs. The handoff step assumes a writing-plans-style planning skill exists; without it the flow ends at the committed design doc.

    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 buying a skill.

    Reviews

    2.0
    1 review
    5
    0
    4
    0
    3
    0
    2
    1
    1
    0

    This skill has been used 2 times.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    docs/designs/**
    src/**
    *.md

    Needs read access across the project for context discovery, plus write access to docs/designs/ and git to commit the approved design.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill acts as a mandatory checkpoint that prevents your AI agent from writing code until the architecture is approved. It solves the problem of 'scope drift' and wasted compute time by forcing a structured design phase, uncovering hidden constraints before implementation begins.

    The skill is platform-agnostic and works with any programming language or framework. It generates standard Markdown documentation and Mermaid.js diagrams, ensuring your design specs are readable by both humans and other AI planning tools.

    You receive the full Concept Exploration & Design Gate skill definition, ready to be imported into your AI agent's environment. It includes the logic for the multi-stage discovery loop, design template structures, and the automated documentation workflow.

    No, this is a dedicated 'design gate' focused on alignment and architecture. Once a design is approved and committed to your repo, you should hand the resulting specs over to an implementation-focused skill like 'writing-plans' or a standard coding agent.

    Setup is minimal; once added to your agent's library, you simply trigger it when starting a new feature. It automatically begins by scanning your current codebase and recent commits to ensure any new design exploration is contextually aware of your existing architecture.

    New in Workflow Automation

    Free