Prompt Contract Audit

    1

    Static checks for SKILL.md before you publish: paths that do not exist, fields the platform parser cannot read, and a claim of "read-only" the code contradicts.

    $12

    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

    Prompt Contract Audit

    Example session with this skill installed

    I keep getting my skill packs rejected on the marketplace and the rejection notice never
    tells me which line is wrong. Last round it named five problems -- dangerous code patterns,
    network access, a curl call -- and I grepped the pack for all of them and found nothing that
    matched. The review says security score 100/100 in the same message that says Failed
    Security. I have rewritten the description three times now and I am guessing each time.

    • Read your context and instructions
    • Compiled the prompt contract audit

    Guessing is the actual problem here: the notice is a template, and a template cannot point
    at a line. So stop reading the notice and start auditing the pack against the criteria the
    notice is generated from.

    Run the auditor on the pack directory first:

    python scripts/audit.py ./my-skill --platform agensi
    

    It returns findings, not a score. Each one has a rule id, a file, a line, the exact string it
    matched, and the reason. The reason matters more than the severity: a finding you cannot
    argue with is a finding you can fix.

    Then separate the two things the rejection notice has merged into one. "Dangerous code
    patterns" and "Failed Security" are one finding class. "Network access" is a different one,
    and it fires on a URL that appears in your documentation as an example -- the scanner reads
    the string, not the intent. Rewriting that sentence is not a code change and it is not a
    lie; you are not removing a capability you never had.

    Three passes worth running before the next submission:

    1. Reference integrity. Every path the prose mentions must exist in the pack. A renamed
      helper that is still described in a table is exactly the kind of thing a template notice
      would call "potential data exfiltration" without ever saying which file.

    2. Parser compatibility, per platform. Folded YAML blocks are legal and the Agensi renderer
      shows them correctly -- so do not flatten your description to satisfy a parser that is
      not the one reading it. Check the platform profile first, then the field.

    3. Claim versus behaviour. If SECURITY.md says "no network access", a curl example in
      references/ contradicts it, and the scanner will find the contradiction even if a human
      reviewer would understand the intent. Either the claim or the example has to go. Fixing
      the example is usually correct and usually cheaper.

    The order matters: fix the real findings, then the wording risks, then resubmit. Mixing them
    means you cannot tell which change made the difference, and the next rejection teaches you
    nothing again.

    3. Claim versus behaviour. If SECURITY.md

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

    About this skill

    Skill packs fail in ways that do not show up locally. The SKILL.md references a file that was renamed. The frontmatter is valid YAML but the platform's parser reads a different value. The description says "read-only" and a script writes to disk. None of these throw an error. They produce a skill that loads, runs, and silently does less than it claims.

    Code has a compile step and a prompt has nothing. A missing semicolon or a call to a function that does not exist stops the build before the program runs; nothing equivalent stops a skill pack, so the same class of mistake reaches the user as a task that "completed" with nothing done. This is that missing compile step: a static auditor you point at a skill directory before you publish. Findings and an exit code come back, and the exit code works as a CI gate.

    WHAT IT CHECKS

    23 machine rules across six dimensions. The dimensions exist because they fail differently:

    D1 Reference integrity Every path and script named in the prose must exist in the pack. D2 Platform fields Required fields, their formats, and the platform's own regexes -- copied from the platform's CLI source, not from its documentation. D3 Parser compatibility Whether the frontmatter survives the parser that will actually read it. A folded block is legal YAML and reads as empty in a line-based parser. Same bytes, different value, no error anywhere. D4 Claim vs. behaviour If the docs say read-only / no network / no base64, the code is checked for the contradiction. D5 Trigger coverage Whether your description is hit by the way real users ask. This is the one dimension that cannot be judged from inside the pack -- the pack contains no questions. Point it at real ones and every question that shares no word with the description is reported; without them the report prints "not measured" instead of a green blank. D6 Determinism Two runs must produce the same report. Timestamps and randomness in the output break that, and break your CI diff with it.

    Read that list as a compiler: D1 is the symbol table, D3 is the parser, D4 is the type check, D6 is the reproducible build. D2 exists only because the marketplace is part of the target. D5 exists because the entry point is a sentence in a catalogue, and no compiler was ever invoked by a sentence.

    Each finding carries a rule id, severity, file, line, the evidence string it matched, why it matters, and what to change. FAIL exits 2, WARN exits 1, INFO exits 0 -- so audit.py . in a pre-commit hook blocks the bad ones and logs the rest.

    WHAT MAKES IT DIFFERENT

    Most linters check whether the file is well-formed. This one checks whether the file is true. That is the difference between a formatter and a compiler. The D4 pass is the one that keeps finding real problems: a pack that promises "never writes" while a helper function writes a cache file looks perfect to every structural check.

    Platform profiles are separate (SkillHub, Agensi, Claude Skills, Expert Center, generic), because a rule is only valid once its premise is valid. The SkillHub CLI parses frontmatter line by line; Agensi and Claude parse real YAML. Running one parser's rules against another platform does not produce a stricter report, it produces a wrong one.

    The report also states what it could not verify. Where a platform's behaviour has not been measured, the rule is downgraded and tagged [unverified] instead of being reported as a failure. A rule that guesses is worse than a rule that is absent.

    MEASURED ON REAL PACKS

    Six of our own published skill packs were the test set. The first version reported 49 findings on them. 42 were false positives -- 86 percent -- and every one came from the same mistake: the rule was correct, its premise was not (SkillHub's parser applied to Agensi packages, a template path treated as a broken reference, a report file written by --json treated as a violation of "read-only").

    The current version reports 5 on the same six packs, and each one is documented. That work is in the changelog, with the counts, because a linter's only asset is that its findings can be trusted -- one confident false positive costs more than ten missed ones.

    The rule set is covered by 20 regression fixtures, including five that exist only to prove a false positive does not come back. Each of those five was mutation-tested: remove the exemption, the fixture must go red. Gate: recall 1.000, precision 1.000.

    Two of the twenty exist because a rule with one fixture proves nothing. A fixture that must go red cannot distinguish "detects the fault" from "always fires"; a fixture that must stay green cannot distinguish "detects" from "never fires". So tests/_mutate.py breaks the rule in both directions on purpose and asserts each fixture reddens for its own break. Run it yourself: it is one command, and it is in the package.

    WHAT ITS OWN NUMBERS SAY ABOUT IT

    The tool was run on a corpus of 766 real user utterances from one author's machine. Two results are worth more than the marketing: 0 of 766 are in English (so the English edition ships no D5 baseline and prints "not measured" -- inventing twenty English questions to earn a green line is the exact failure this tool exists to catch), and exactly 1 of 766 mentions prompt or skill vocabulary at all. That second number is not a defect in the tool. It is what the corpus says about this product, written down where the next person will find it.

    WHAT IT DOES NOT DO

    It does not rewrite your skill. It reports; you edit. It does not execute your skill. It reads the files and compares them. There is no sandbox, no runtime and no trace, so a permission problem that appears only when the code runs is outside what this tool can see. It does not upload, publish, or contact any platform. No network calls at all. It does not judge whether your prose is good, or whether the idea is worth building. It does not read for meaning. Two sections that contradict each other -- "answer in three sentences" here, "list 100 points" there -- are not detected; that needs semantics, not shape. Rules in that class are marked [manual] and the tool will not report them, rather than guess. That is where the compiler comparison stops, on purpose. It does not audit code quality, dependencies, or security beyond the specific claims your own documentation makes. It cannot distinguish randomness that a protocol requires (a DNS transaction id) from randomness that leaks into the output. Both are reported and you decide. This is a known limitation, written into the rules file rather than hidden. Rules marked [manual] are not automated and the tool will not report them.

    REQUIREMENTS

    Python 3.8 or newer. Standard library only, nothing to install. Runs offline. The audited directory is never modified; the only file it writes is the report you ask for with --json or --md.

    SHIPPED WITH

    SKILL.md, README, DESIGN notes, CHANGELOG, SECURITY notes, five reference documents (the rule table, the platform constraint table, the six-dimension contract, the incident log, and the MCP companion notes), two scripts, and two test tools (the fixture generator and the mutation runner). Fourteen files, no dependencies.

    SECURITY notes lists every pattern an automated marketplace scanner will flag in this package -- the command names it looks up, the one directory it deletes, the paths it writes -- with the file and line number for each, and why that instance is not a risk. The same standard the tool applies to other packages is applied here to itself.

    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.

    No semantic analysis of meaning. Does not perform live network/URL checks. D5 trigger coverage requires a manual triggers.txt file. Fixes are suggested, not auto-applied to source.

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

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Read Files - the audit opens only the directory you name, and only files inside it: .md, .txt, .json, .yaml, .yml, .sh, .py, .ps1 plus the frontmatter of the main document. Nothing is written back to your skill, and the audited tree is never modified. Write Files - exactly one file is ever written: the report you name yourself with --json or --md. Pass neither and the run writes nothing at all. The only other writer in the package is tests/_make_cases.py, which rebuilds tests/cases/ (the regression fixtures) and only when you run it yourself; scripts/audit.py and scripts/baseline.py work without it. Terminal - what is ticked here is usage, not behaviour. This is a script skill: the operator runs python scripts/audit.py ./my-skill --platform agensi in their own shell. No file in the package starts a process, opens a shell, or evaluates a string: there is no subprocess, no os.system, no eval and no exec anywhere in scripts/ or tests/. The destructive-looking strings you will see are regex literals used to detect those very patterns in other people's packages (R401), which is the product. Browser - off. Nothing in the package opens a page, drives a browser, or imports a browser library, and no browser-related path text appears anywhere in the fourteen files. Network Access - the scanner ticks this from a literal string, not from a capability. The word curl occurs once in the package, at scripts/audit.py:164, as a member of KNOWN_CMDS: a list of command names passed to shutil.which() to answer "does the command this skill's documentation tells the user to run actually exist on this machine". Nothing in the list is executed or imported, and removing the string would remove the check. There is no socket, no HTTP client, no DNS, no telemetry and no update check anywhere in the fourteen files - SECURITY.md section 1 names that line and gives the one grep that confirms it. If this box appears ticked, it is that string: read it as "contains a network-shaped word", not "connects to anything". Environment Variables - the scanner ticks this from the literal tokens os.environ and getenv, not from a read. Neither is called anywhere in scripts/ or tests/; the only occurrences in the whole package are inside SECURITY.md - the bullet that denies the read, and the one-line reproduction command printed next to it (grep -rn "os.environ|getenv|process.env" scripts/ tests/ -> no matches). The other environment-shaped words are the [environment path] label the auditor prints on a finding, and the vocabulary inside the rules that detect environment harvesting in the packages being audited - the product, not a capability. If this box appears ticked, it is a string match on that one grep line.

    Listed21 days ago

    What's inside

    Frequently Asked Questions

    This skill acts as a linter for your AI agent configuration, catching hidden issues like broken file paths, parser-breaking syntax, and mismatches between your prompt's claims and the actual code before you deploy.

    The audit tool is optimized for Agensi and SkillHub, but it can be used for any agent framework that relies on structured markdown or configuration files by using the general validation mode.

    You will receive the core Python auditing engine, a set of standard validation rules, a template for report generation, and an optional MCP server for integrating audits directly into your agentic workflow.

    No, the skill is designed with zero mandatory external dependencies and skips network-based validation, making it safe to run in air-gapped or restricted CI/CD environments.

    By using the `--platform` flag, the auditor enforces the specific field limits and formatting requirements of your target marketplace, ensuring your submission doesn't fail due to silent parsing errors.

    Yes, the tool provides stable exit codes and generates a `findings.json` file, allowing you to automatically block builds or deployments if a prompt change introduces a contract violation.

    New in Code Quality & Review