SkillAgentSearch skills...

solidity-auditor

Security audit of Solidity code while you develop. Trigger on "audit", "check this contract", "review for security", "loop mode", "run the auditor in loop mode", "run 3 passes". Modes - default (full repo) or a specific filename.

Install / Use

npx skills add pashov/skills --skill solidity-auditor

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

91/100

Category

Security

Supported Platforms

Zed

Our assessment of solidity-auditor

solidity-auditor scores 91/100 on our quality scale, 453rd of 1,111 Security skills we index (top 41%).

Its SKILL.md is 39 KB long, split into 5 sections with 11 code examples: a thorough specification that gives an agent plenty to work with.

With 1,194 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
18/20
Description
15/15
Adoption
13/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so solidity-auditor is actively maintained.
  • Our last check on 2026-10-29 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

solidity-auditor compared with similar skills

All 4 of these similar skills score higher than solidity-auditor; compare them before choosing.

SkillScoreStarsUpdatedFormat
solidity-auditor (this skill)by pashov911.2k54d agoSKILL.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md
pptxby anthropics100177.9k55d agoSKILL.md
designby nextlevelbuilder100149.0k6d agoSKILL.md

Frequently asked questions

How do I install solidity-auditor?
Run npx skills add pashov/skills --skill solidity-auditor. The install tabs above show the steps for each supported agent.
Which AI agents does solidity-auditor work with?
It is written for Zed, as a SKILL.md file. Other agents that read the same format can often use it too.
Is solidity-auditor safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is solidity-auditor still maintained?
The repository was last updated about 2 months ago, so solidity-auditor is actively maintained.

name: solidity-auditor description: Security audit of Solidity code while you develop. Trigger on "audit", "check this contract", "review for security", "loop mode", "run the auditor in loop mode", "run 3 passes". Modes - default (full repo) or a specific filename. Loop mode runs several passes in one scan, each pass told what the earlier ones found, and ends in one combined report; it remembers findings between scans in a ledger.

Smart Contract Security Audit

You are the orchestrator of a parallelized smart contract security audit.

Mode Selection

Exclude pattern: skip dependency and build directories — node_modules/, lib/, artifacts/, cache/, out/, broadcast/, coverage/, typechain*/ — and non-production code — interfaces/, mocks/, test/ and files matching *.t.sol, *Test*.sol or *Mock*.sol.

Deploy scripts stay in scope. script/, deploy/ and *.s.sol are audited like any other code: a deploy script sets constructor arguments, hands over ownership and seeds state, and it carries real bugs. Excluding a dependency is an argument about code you did not write; a deploy script is code you did write.

  • Default (no arguments): scan all .sol files using the exclude pattern. Use Bash find (not Glob), exactly this command:

    find . -type f -name '*.sol' \
      -not -path '*/node_modules/*' -not -path '*/lib/*' -not -path '*/artifacts/*' \
      -not -path '*/cache/*' -not -path '*/out/*' -not -path '*/broadcast/*' \
      -not -path '*/coverage/*' -not -path '*/typechain*/*' \
      -not -path '*/interfaces/*' -not -path '*/mocks/*' -not -path '*/test/*' \
      -not -name '*.t.sol' -not -name '*Test*.sol' -not -name '*Mock*.sol'
    

    -type f is required, not tidiness: Hardhat writes each build artifact into a directory named GatewayCrossChain.sol/, so a find without it matches directories as if they were source files and hands them to cat. Do not drop it, and do not re-derive this command — paste it.

  • $filename ...: scan the specified file(s) only. The exclude pattern does not apply here. A file named on the command line is always scanned, wherever it lives — naming node_modules/@openzeppelin/contracts/token/ERC20/ERC20.sol scans that file. The pattern chooses what a default scan discovers; it never overrides an explicit request.

Flags:

  • --file-output (off by default): copy the assembled report into the working directory (name per {resolved_path}/report-formatting.md). The flag never causes a report to be produced — every scan assembles .solidity-auditor/runs/{stamp}/full-report.md whether it is passed or not. It only decides whether a copy lands where the runner can see it.

    Line 33 used to read "Never write a report file unless explicitly passed", and that is now false. The rule was written to protect the runner's working directory, and that protection is unchanged: without the flag, nothing is written outside .solidity-auditor/. What changed is that the report is assembled by shell on every scan, so the flag can no longer collapse the report — nothing regenerates, it copies. A later editor must not read this as a mistake and revert it.

  • --memory (off by default): remember findings between scans in a ledger at .solidity-auditor/memory.tsv in the audited repo. Any pass count above 1 turns memory on by itself, whether or not the flag was passed.

  • --loop [N] (off by default): run N passes in one scan, each pass told what the earlier ones found, ending in one combined report. --loop with no number is 3 passes. --loop 1 is a 1-pass scan. The flag exists for runners who prefer flags; when it is passed the picker in Turn 1b does not ask, it obeys.

Vocabulary (used throughout this file):

  • run — one pass of the 12 agents.
  • scan — one invocation of this skill. A scan holds 1 or more runs.

The ledger's scans column counts scans. The report's seen in k/N runs counts runs inside one scan and is never written to the ledger. Two numbers, two names — do not mix them.

The pass count the scan runs is {passes} — settled in Turn 1b, 1 or more. The loop body is Turn 2 step 2c, Turn 2 step 3, Turn 3a, Turn 3b and Turn 4, and it runs once per pass. Everything before it runs once per scan, and Turn 5 closes the scan once, whatever {passes} is.

HARD RULE — the plain path must stay plain. A 1-pass scan with no flags reaches none of the memory steps: not Turn 1c, not Turn 2 step 2, not Turn 4 step 4, not Turn 4 step 6. It reads no ledger, writes no file anywhere, and prints exactly the report it printed before memory existed. Memory is on only when --memory was passed or the pass count is above 1. A later editor who is tempted to make any memory step unconditional is breaking this on purpose, not tidying up.

A 1-pass answer reaches none of the loop or memory machinery. No ledger is read or written. No Passes or Memory row in the Scope table. No seen in k/N runs. No KNOWN / NEW tag. No per-pass summary lines. The printed report is the report this skill printed before loop mode existed. The only trace of the picker is the question itself.

What it does write. Every scan writes .solidity-auditor/runs/{stamp}/ — one run-1.md, one scope.tsv, one full-report.md — because the report is assembled from those files at every pass count, and name, mode, files and threshold are needed by every report. This paragraph used to say a 1-pass answer creates no .solidity-auditor/ directory and no runs/ files; that is now false, and it was never what the rule was protecting.

What the rule protects, stated exactly: on the plain path the scan reads no ledger, writes no mem_ key, and prints a Scope table of exactly three rows — Mode, Files reviewed, Confidence threshold (1-100) — and no Passes row, no Memory row. Disk is not printed output. A later editor who makes a memory step unconditional is breaking this on purpose; writing the runs directory is not one of those steps.

--memory on a 1-pass run is the single exception: memory turns on, the loop machinery stays off.

Orchestration

Turn 1 — Discover. Print the banner, then make these parallel tool calls in one message:

a. Bash find for in-scope .sol files per mode selection b. Glob for **/references/hacking-agents/shared-rules.md — extract the references/ directory (two levels up) as {resolved_path} c. ToolSearch select:Agent d. Read the local VERSION file from the same directory as this skill e. Bash curl -sf https://raw.githubusercontent.com/pashov/skills/main/solidity-auditor/VERSION f. Bash mktemp -d ./.audit-XXXXXX → store as {bundle_dir} g. Bash date +%Y%m%d-%H%M%S → store as {stamp}, the scan-time stamp. One stamp per scan, computed once, here. The runs directory, the run files and any --file-output copy all carry it, so a report and the runs that produced it are tied together by eye.

Turn 1a — Open the scan directory. After the find returns, in one Bash command:

mkdir -p .solidity-auditor/runs/{stamp}
: > .solidity-auditor/runs/{stamp}/scope.tsv

Then write the three scope keys this turn knows. A scope key is written with one printf and never any other way:

printf '%s\t%s\n' name  "{project-name}" >> .solidity-auditor/runs/{stamp}/scope.tsv
printf '%s\t%s\n' mode  "{mode}"         >> .solidity-auditor/runs/{stamp}/scope.tsv
printf '%s\t%s\n' files "{file list}"    >> .solidity-auditor/runs/{stamp}/scope.tsv
  • {project-name} — the repo root basename, the same one report-formatting.md names.
  • {mode} — default or filename, as Mode Selection settled it.
  • {file list} — every in-scope path the find returned, space separated on one line, in find order. The assembler wraps them 3 per row; the order it prints is the order written here.

scope.tsv is key<TAB>value, append-only, last line per key wins. An absent key gives an absent table row — that is what keeps the plain scan's Scope table at three rows with no special case. A tab or a newline in a value breaks the row, so values are stripped, not escaped: no key here has any use for either character. Six writers across four turns append to this one file, and none of them ever rewrites or deletes a line.

name and mode are the only two keys a model types. Everything else is either shell knowledge or read by the assembler for itself: the threshold from the constant, N in seen in k/N runs from counting run files, the stamp from the directory's own name.

If the remote VERSION fetch succeeds, compare the two as numbers and warn only when the local one is lower: print ⚠️ You are not using the latest version. Please upgrade for best security coverage. See https://github.com/pashov/skills. If it fails, skip silently.

Lower, not different. A plain "differs" test warns the wrong person: somebody working on an unreleased version has a local VERSION above the published one, and gets told to upgrade to the version they are writing. Local equal to remote, or local above it, prints nothing.

Turn 1b — Model and pass count. This turn asks two questions in one AskUserQuestion call: which model the 12 agents use, and how many passes the scan runs. The runner is interrupted once, before any work starts.

The two questions do not fail the same way. On a runtime without AskUserQuestion and an Agent tool that takes a model parameter — Codex, Gemini, Cursor's native agent — the model question is skipped silently, {agent_model} is left unset, and no prose replaces it. The pass question is not skipped: it falls through to the printed block in Turn 1b-ii, which stops and waits. This turn as a whole is never skipped. A later editor must not restore a blanket "SKIP this turn entirely" rule: it was true when this turn asked one question, and it is false now.

Turn 1b-i — the AskUserQuestion call (Claude Code). Ask both questions in one call. Where the Agent tool takes no model parameter, ask the pass question alone.

Question 1 — model:

  1. Read your system prompt to detect your own model family (Opus, Sonnet, or Haiku). Ignore the version digits — the Agent tool's model parameter takes the family name ("opus" / "sonnet" / "haiku"), and the runtime resolves to the latest version in that family.

  2. Put this question in the call:

    • Question: "Which Claude model should the 12 audit agents use?"
    • Three single-select options. Mark the orchestrator's own family as (Recommended) and place it first.
    • On each option, set the description field to latest.
    • On each option, set the preview field verbatim (preserve all whitespace exactly — the box widths must stay equal across all three):

    Opus preview:

    ┌──────────────────────────────────────────────────────────┐
    │  opus  ·  highest reasoning  ·  most expensive           │
    └──────────────────────────────────────────────────────────┘
    

    Sonnet preview:

    ┌──────────────────────────────────────────────────────────┐
    │  sonnet  ·  balanced reasoning  ·  mid cost              │
    └──────────────────────────────────────────────────────────┘
    

    Haiku preview:

    ┌──────────────────────────────────────────────────────────┐
    │  haiku  ·  lowest reasoning  ·  cheapest                 │
    └──────────────────────────────────────────────────────────┘
    
  3. Store the runner's choice as {agent_model}. If no answer, default to the orchestrator's own model.

Question 2 — pass count. It goes in the same call, second:

  1. Question: "How many passes should this audit run? Each pass is a full 12-agent audit, and every pass after the first is told what the earlier ones found, so it hunts new ground. You get one combined report at the end."

    Three single-select

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars1.2k
CategorySecurity
Updated1mo ago
Forks218

Languages

JavaScript

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions