SpecTrace — Spec-Driven Development, Enforced

    1

    Spec-driven development with teeth: a versioned PRD, human-approved specs, and a CI checker that fails the PR when code drifts from what was approved.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    SpecTrace — Spec-Driven Development, Enforced

    Example session with this skill installed

    I need to add a new rate limiting requirement to the PRD for the API Gateway. The limit should be 100 requests per minute per user. Give it a new ID and update the version.

    • Read your context and instructions
    • Compiled the spectrace

    I have updated the PRD to include the new rate limiting requirement and bumped the version to 1.1.0.

    PRD Update: Rate Limiting

    The following changes were applied to docs/PRD.md:

    Requirement IDDescriptionSectionStatus
    SD-14The system must limit API requests to 100 per minute per authenticated user.4.2 SecurityNew
    NF-08Rate limit violations must return a 429 Too Many Requests status code.5.1 PerformanceNew

    Decision Log Entry

    • Decision: Implement per-user rate limiting.
    • Rationale: Prevent API abuse and ensure fair resource distribution among tenants.
    • Date: 2023-10-27
    • Version: 1.1.0

    Change Summary

    1. PRD Version: Bumped from 1.0.5 to 1.1.0.
    2. Traceability: Added IDs SD-14 and NF-08.
    3. Files Modified: docs/PRD.md, docs/decisions/004-rate-limiting.md.

    Next steps

    1. Review the PRD changes and the new version markers.
    2. Run /spec-new SD-14 NF-08 to generate the implementation specification.
    3. Commit these changes to a new branch named feat/SD-14-api-rate-limiting.

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

    About this skill

    Writing specs is the easy part. Keeping them true is the job.

    Most spec-driven tools (Spec Kit included) help an agent produce a spec, a plan and a task list — then nothing stops the next session from shipping behaviour nobody specified, renumbering the requirements, or quietly letting the spec rot. SpecTrace is the operating system that closes that loop, distilled from a real project that runs it in CI today.

    The chain

    PRD requirement (stable ID) → spec → code + tests → pull request. Every link names the one before it, so "why does this code exist?" is always one search away.

    What you get

    • The method (SKILL.md): eight rules, the spec lifecycle, and the three working loops — /spec-new (draft a spec from requirement IDs), /spec-change (record a requirement change across the PRD and every affected spec), /spec-implement (build an approved spec, tests traced to acceptance criteria).
    • A versioned PRD system: permanent requirement IDs that are never renumbered or reused, MINOR-bump discipline with three synced version markers, and a decision log that stops settled questions being re-litigated by every new agent session.
    • Human approval as a state machine: agents draft specs, only a human approves them (Draft → Approved → Implemented), and code for an ID merges only against an Approved spec — enforced, not etiquette.
    • The checker: a single stdlib-only Python script (read-only, no dependencies, no network) plus a GitHub Actions workflow. It fails the PR when version markers disagree, a spec references a requirement that doesn't exist, a changed PRD forgot its version bump, decision files move without the PRD, or code lands with no approved spec behind it.
    • Templates for everything: PRD skeleton, spec template, project rules file (AGENTS.md), pull-request template, and the three slash commands.
    • A Jira layer: pull a story or epic in, map it to requirement IDs, record the Jira key in the spec so every artefact carries both keys (PROJ-123 ↔ SD-9), and flow status back with human-approved writes only. Includes a change-radar step that flags specs whose linked story changed underneath them. Works with Jira Cloud and Data Center via Atlassian MCP (or the opencode-atlassian-extension on OpenCode); the same mapping works with GitHub Issues.

    Why this beats prompting it yourself

    A prompt can ask an agent to "follow the spec". It cannot make the PR fail when it doesn't. The discipline here lives in artefacts and a validator, not in a chat window — so it survives new sessions, new agents and new team members.

    Use cases

    • A team adopting AI coding agents that needs reviewable, auditable change.
    • A solo builder whose agent keeps adding unspecified features.
    • Replacing per-feature spec folders that drift out of sync with the product.
    • Bringing Jira-managed work under real requirements traceability.

    Known limitations

    The checker guards the chain's integrity; it does not judge code correctness or spec quality — that stays with human review, by design. The Jira layer needs Jira access inside your agent (MCP or API). Slash commands ship in Claude Code format; other agents follow the same steps as plain instructions.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Requires Python 3 for the validator. Jira integration requires an Atlassian MCP server. Manual labeling is needed for non-feature chores like dependency updates.

    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 17 days ago

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed17 days ago

    What's inside

    Frequently Asked Questions

    This skill enforces a mechanical link between your PRD and your code. It prevents 'feature drift' by using a Python-based CI checker that fails any pull request containing code changes that aren't mapped to a human-approved requirement ID.

    The workflow is language-agnostic and works with any agent capable of following project rules, such as Claude Code, Cursor, or GitHub Copilot. The validator script only requires Python 3 and can be integrated into your existing GitHub Actions or GitLab CI pipelines.

    You receive the full spec-driven folder structure, a PRD template, the 'spec_check.py' validator script, and a suite of slash commands for requirement management. It also includes the logic required to set up the 'Draft-to-Implemented' state machine for human-in-the-loop approvals.

    The skill uses a system of stable, non-reusable IDs and version markers within a single 'docs/PRD.md' file. Every time a requirement changes, the system forces an atomic update across the PRD, the feature spec, and the implementation to ensure your documentation never falls behind your code.

    While the workflow is designed for strict enforcement, you can use a 'spec-exempt' label for routine maintenance or infrastructure chores. This allows you to bypass the requirement check for tasks that don't involve functional product changes.

    New in Code Quality & Review