Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Claims Ledger: Docs vs Code Audit with a CI Gate

    2

    Audit project documentation against code and tests to generate a verified honesty registry and prevent doc drift.

    $19

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Claims Ledger: Docs vs Code Audit with a CI Gate

    Claims Ledger: Docs vs Code Audit with a CI Gate

    Example session with this skill installed

    Audit the README.md and src/auth.ts to ensure our 'AES-256 encrypted' and 'Zero-knowledge' promises are actually implemented and tested. Use anchors, don't edit source files.

    • Read your context and instructions
    • Compiled the claims ledger

    I have audited the authentication claims against the current implementation. I identified two atomic claims and traced them to the encryption logic and unit tests.

    Claims Registry Audit

    IDStatementStateLabelEvidenceGap
    C-01AES-256 encryptedenforcedPROVENauth.ts#L42, auth_test.ts#L12None
    C-02Zero-knowledgepartialPROVENauth.ts#L88No negative test for server-side key leakage

    Headline Findings

    C-02 (Zero-knowledge) is marked partial. While the implementation uses client-side hashing, there is no test case verifying that the raw secret never reaches the POST /login payload.

    • No literal overclaims (static badges) were found in the scanned files.

    Wording Notes

    • The README statement "Military-grade security" was dropped as it is pure opinion and non-falsifiable.

    Next steps

    1. Review the claims.json file created at the root to verify the anchors are correct.
    2. Add a test case in auth_test.ts to exercise the zero-knowledge failure state to move C-02 to enforced.
    3. Run python3 scripts/claims_ledger.py render to update the public CLAIMS.md file.

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

    About this skill

    Document drift and marketing overreach create technical debt that erases user trust. This skill audits your project promises against the actual implementation, generating a machine-checked registry that links every claim to specific code and test files.

    What it does

    • Atomic claim extraction breaks down complex marketing copy or specs into individual, falsifiable statements.
    • Evidence tracing maps every promise to its implementation mechanism and the specific tests that verify it.
    • Epistemic labeling categorizes claims as proven, lemmas, or proposals to distinguish current reality from future roadmap.
    • Overclaim detection scans UI and docs for literal verdicts like "PASS" or "secure" badges that aren't backed by computed logic.
    • Gap reporting generates a structured registry of enforced, partial, and absent features with actionable fix instructions.

    How it works

    1. Source analysis identifies promises in whitepapers, READMEs, landing pages, and UI text.
    2. Registry generation creates a claims.json file linking statements to source code anchors or trace comments.
    3. Automated verification runs a checker script to validate that implementation files and passing tests exist for every enforced claim.
    4. Honesty rendering produces a CLAIMS.md table that displays the gap for every partially implemented or absent feature.

    Frameworks & tools

    The skill uses a Python-based auditing script and a JSON registry schema. It integrates with standard testing suites by checking for test files and CI output.

    Why this beats prompting it yourself

    Generic prompts often miss the "fail-closed" logic required for real audits, leading to false positives. This skill enforces a strict evidence chain where a claim is marked absent by default unless specific code and passing tests are identified.

    Use cases

    • Due diligence preparing a technical implementation report for investors or auditors.
    • Launch readiness ensuring that the landing page doesn't promise features that haven't merged yet.
    • Compliance checking verifying that security badges shown in the UI are actually tied to backend checks.
    • Drift prevention using a CI gate to fail builds when documentation changes without matching code updates.

    Known limitations

    Requires Python 3 to run the checker script. It cannot verify external third-party claims without local documentation and does not perform live runtime monitoring.

    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. Verification is limited to static analysis of local code, tests, and documents. Cannot verify runtime performance without existing benchmark files.

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

    Software
    Python 3.8+

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed14 days ago

    What's inside

    Frequently Asked Questions

    The skill generates a `claims.json` registry that maps every promise in your documentation to specific implementation code and test files, ensuring your outward-facing claims match your actual code.

    You will receive the core Python-based auditing script, the JSON registry schema for claim mapping, and templates for generating the `CLAIMS.md` honesty report.

    Yes, you can integrate the auditor into your CI/CD pipeline to act as a gate, automatically failing builds if a documentation update introduces a claim that isn't backed by verified code or tests.

    The tool is framework-agnostic and works by scanning for local code anchors and test outputs; however, it does require a Python 3 environment to execute the auditing and verification scripts.

    Unlike standard LLM prompts that might hallucinate success, this skill uses "fail-closed" logic, meaning a claim is marked as 'absent' unless it finds a direct, verifiable evidence chain in your repository.

    New in Code Quality & Review