More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Spec-Driven Development

    1

    Turn a vague request into an approved, testable spec before any code: assumptions up front, scope in and out, a human approval gate, then plan and tasks derived in order.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Spec-Driven Development

    Spec-Driven Development

    Example session with this skill installed

    Our sales team wants "team workspaces with roles and permissions" added to our project app this quarter. Nobody has written anything down. Spec it before we build the wrong thing.

    • Read your context and instructions
    • Compiled the spec-driven development

    SPEC EXCERPT — produced by the skill's workflow; assumptions went to the requester before drafting.

    Assumptions (sent first, two corrected): 1) A workspace contains projects; a user can belong to several workspaces. 2) Roles are fixed (owner / editor / viewer), not custom — CORRECTED by sales: one enterprise prospect needs custom roles; recorded as an open question, not silently assumed either way. 3) Existing users keep working unchanged until a workspace admin turns the feature on.

    Objective: a team can share projects under one workspace, with access controlled by role, and no change to the solo experience.

    In scope: workspace create/switch; invite by email; the three fixed roles enforced on project read/write/delete; an activity log of permission changes. Out of scope: billing per workspace (next quarter, separate spec), custom roles (pending the open question), cross-workspace search, guest access.

    Testable requirements: "A viewer who opens the project settings URL directly sees a read-only page with no editable controls — not a hidden menu they can POST around." "Removing a member takes effect on their next request: an already-open session loses write access within one request, verified by an automated test." "An owner inviting an email that already belongs to another workspace adds the person to this workspace; their other membership is untouched."

    Non-functional: permission check adds under 20 ms p95 per API request; every allow/deny decision for write actions is logged.

    Success criteria: two pilot teams migrated with zero permission-escalation reports in two weeks; solo-user regression suite green; an admin can remove a member and export the activity log without engineering help.

    Open questions: custom roles — owner: sales lead, needed before the plan (it changes the data model). Does the activity log need retention beyond 12 months? — owner: legal, needed before launch, not before building.

    The gate caught the custom-roles question while it was still a data-model decision, not a rewrite.

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

    About this skill

    Code without a spec is a guess about what was wanted, and the guess is discovered at demo time, when it's most expensive. This skill converts a request into a shared, checkable agreement before the expensive work starts. It begins where most specs don't: with an explicit assumptions list sent for correction before any drafting — because assumptions are the most dangerous form of misunderstanding precisely because they're invisible. A decision point splits multi-capability requests (identity, billing, notifications in one ask) into a capability map that gets approved on its own, so no downstream task has to reason about the whole initiative. The spec document itself is specified: problem and users in one paragraph, the objective stated as an outcome rather than an implementation, scope in AND out (non-goals named, since writing "out" is the cheapest scope control there is), functional requirements phrased as testable statements — "a user with an expired invite link sees an error explaining the link expired and offering re-invite," never "handle expired invites" — non-functional requirements as thresholds, interfaces and working boundaries (always / ask-first / never), stack and verify commands, success criteria, and open questions each with an owner. Then the gate: the spec is done when the human approves it, answering four named questions about targets, scope, approach, and open questions. Only then are the plan and tasks derived, each phase reviewed before the next. A worked example shows "add SSO" becoming a real spec — and two gate answers (enforcement out of scope, OIDC deferred without blocking SAML) changing the build before it started. The skill ships a fill-in spec template, a gate checklist, and a 0–2 quality rubric across testability, scope discipline, assumptions, boundaries, and liveness — approve at 8 of 10, never with a zero on testability or scope. It closes with keeping the spec alive (update the spec first, then the code; commit it; reference it in PRs), edge cases from absent approvers to mid-build discoveries, and anti-patterns like approval theater and vague-requirement laundering.

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

    • The gate needs a human who can actually approve. With no approver available, the skill produces a clearly marked unapproved draft and limits further work — it cannot manufacture agreement.
    • It prevents misunderstanding rework, not estimation error: a perfectly specified feature can still take longer than anyone hoped.
    • For genuinely exploratory work, the right move is a spike first and a spec after; the skill says when, but the learning itself is yours to run.

    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

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 24 days ago

    Permissions

    No special permissions declared or detected

    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    No — the spec covers the next capability, not the whole year, and it stays alive: decisions change the spec first, then the code. The waterfall failure mode (a 30-page spec that's wrong by page 10) is named in the skill as an anti-pattern to avoid, with spec size scaled to uncertainty, not code size.

    Two sentences is exactly where silent assumptions breed. The full ceremony scales down — assumptions plus testable acceptance criteria can be ten lines — but the gate still applies: someone with authority confirms those lines before building starts.

    Stop at the task boundary: update the spec first, re-derive the affected tasks, note the change in the PR. The skill treats the spec as the record of why, so the change becomes a visible decision instead of knowledge trapped in a chat thread.

    New in Technical Documentation