agentleFS
ajwannajwann/claim-verification/SKILL.md

claim-verification

Skill0 starsChanged 35 days agoMITView on GitHub

Check factual claims about external software against the version actually installed before stating them, and label every claim as verified, inferred, or recalled. Covers API signatures, function or method names, CLI flags and subcommands, config keys, env vars, default values, library behavior, deprecations, and version numbers. Use whenever you are about to tell the user how a library, tool, CLI, framework, or service works, write code that calls an API you have not opened in this session, answer "does X support Y" or "what's the flag for Z", or recommend a version or upgrade, even if the claim feels obvious. Recalled API details are the most common source of confident wrong answers. Not for claims about your own work's state (tests pass, bug fixed), which need a run of the verification command instead.

7 other projects use a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

6 rules. 0 are common, 6 are distinctive, and 0 are very specific to this project.

  • 0

    Common

    Most of the 5 edited versions we read keep these.

  • 6

    Distinctive

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Check before stating anything the user will act on that names a specific:

    line 16
  2. Distinctive:

    Latest docs or memory: Use these last, and say they are unpinned.

    line 44
  3. Distinctive:

    If the installed version and your memory disagree, the installed version wins.

    line 46
  4. Distinctive:

    When an answer contains specific claims, mark how you know each one.

    line 52
  5. Distinctive:

    Before writing a call to an API you haven't opened this session, look up its signature first.

    line 69
  6. Distinctive:

    No shell, the package isn't installed, or the docs are unreachable: say the claim is recalled.

    line 77

“Common” is measured: kept by at least 6 in 10 of the 5 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Claim verification

Training memory describes some version of a library, often a blend of several. The user's project runs one specific version. Most hallucinated APIs fall in the gap between the two: a renamed kwarg, a flag added in a later minor release, a default that changed, a function that moved modules. This skill closes that gap cheaply. Most checks take one command.

When a claim needs checking

Check before stating anything the user will act on that names a specific:

  • function, method, class, or import path
  • parameter or keyword name, its type, or its default
  • CLI flag, subcommand, or exit code
  • config key, env var, or file location
  • version number, a "since vX", or "deprecated in vX"
  • behavior claim ("X retries by default", "Y is thread-safe")

Skip checking for general concepts ("Postgres supports transactions") and for code you have already opened in this session.

Where the truth is, in order of authority

  1. The installed artifact itself. It's the version that will actually run.
    • CLI: <tool> --help, <tool> <sub> --help, man <tool>, <tool> --version
    • Python: python -c "import pkg, inspect; print(pkg.__version__); print(inspect.signature(pkg.fn))", or read the source at python -c "import pkg; print(pkg.__file__)"
    • Node: node_modules/<pkg>/package.json (version), its .d.ts types (signatures), and node -e "console.log(Object.keys(require('<pkg>')))"
    • Go: go doc <pkg>.<Symbol>. Rust: the source under ~/.cargo/registry/src/
    • Anything: grep the installed source for the symbol
  2. The lockfile or manifest, to find which version the project pins when nothing is installed yet (package-lock.json, uv.lock, poetry.lock, Cargo.lock, go.sum)
  3. Docs pinned to that version, such as versioned docs URLs, the tagged README, or the CHANGELOG entries between the version you recall and the pinned one
  4. Latest docs or memory. Use these last, and say they are unpinned.

If the installed version and your memory disagree, the installed version wins. Tell the user about the mismatch, because they may be reading the same outdated docs.

Label what you say

When an answer contains specific claims, mark how you know each one. Use plain words, not a badge on every sentence:

  • verified means you checked it this session against the installed version or a source you ran. Show what you ran when it's useful ("rg --help on 14.1 lists --pcre2").
  • inferred means it follows from something verified but you didn't test it directly. Say what it was inferred from.
  • recalled means it came from memory and wasn't checked. Say so, and give the one command that would check it if you can't run it yourself.

One sentence like "I checked these against requests 2.31 installed here; the retry default is from memory" is enough. The point is that the user can tell which claims are solid and which still need checking.

Writing code against an API

Before writing a call to an API you haven't opened this session, look up its signature first. That takes one command. Debugging a wrong kwarg costs a test run and a confused user. If the call compiles or imports cleanly in a quick check (python -c "from x import y", tsc --noEmit, go vet), that is verification. Say that you ran it.

When you can't check

No shell, the package isn't installed, or the docs are unreachable: say the claim is recalled. Name the version you believe it applies to, and give the user the exact command to confirm it. Don't hedge everything into mush. Be specific about which part is uncertain.

Example

User: "how do I set a timeout on httpx requests?"

Weak: "Pass timeout=10 to httpx.get." This is recalled and unlabeled.

Strong: runs python -c "import httpx, inspect; print(httpx.__version__); print(inspect.signature(httpx.get))", sees 0.27.0 and timeout: 'TimeoutTypes' = Timeout(timeout=5.0), then answers: "httpx.get(url, timeout=10). Verified against httpx 0.27 installed here. The default is 5 seconds, not unlimited like requests. For separate connect and read limits, use httpx.Timeout(10, connect=2). I recalled that form; it's in the same signature's Timeout class if you want to check."

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.