audit-skills

Language- and framework-agnostic audit checklists for AI coding agents —
security, correctness, and operability. Works with Claude Code, GitHub
Copilot, Cursor, Codex CLI, OpenCode, and any agent that can read files.

Every checklist is written as invariants and detection smells, not
framework APIs, so the same content audits a Rails app, a Spring service,
or an Express API — the agent supplies the framework-specific translation.

Works with any language or framework. Each checklist names eight
common ecosystems in its concept glossary (Rails, Laravel, Django, Spring,
Node, Vapor, .NET, Go) — those are recognition shortcuts, not a
support list. The invariants and detection smells are framework-free, so
the audits apply equally to Phoenix, FastAPI, Ktor, or your in-house
stack: the agent supplies the translation.

What's inside

• AGENTS.md — a one-page digest of all 35 invariants; copy its content
  into your project's AGENTS.md so every agent has it in context.
• .agents/skills/audit/ — the router skill, with all 35 checklists and
  remediation patterns bundled under references/ (four categories: access
  & data security, input/API, correctness, operability), plus shared
  methodology files (scoping, adversarial verification, severity rubric).
• .agents/skills/audit-* — thin per-topic wrapper skills so each checklist
  is individually invocable (/audit-idor, /audit-injection,
  /audit-fix-authz, …). They are command-only
  (disable-model-invocation: true): audit is the one auto-triggered
  entry point, which keeps 38 descriptions out of every session's context. Everything this package installs starts with
  audit, so it stays grouped among your other skills.

The audits

/audit runs the full audit — it identifies what the code does and applies
every matching checklist below. Each topic is also individually invocable
(click through to read the checklist itself).

Access & data security

Input & API

Correctness

Operability

Fixes

Install

Clone this repo once, next to your projects, and symlink each skill into
your project's skills folder. Nothing is copied, so updating the clone
updates every linked project.

git clone https://github.com/danygiguere/audit-skills ~/WebDevelopment/audit-skills
cd your-project && mkdir -p .agents/skills
for s in ~/WebDevelopment/audit-skills/.agents/skills/audit*; do
  ln -s "$s" .agents/skills/
done

Link every audit* folder: the topic skills read their checklists from the
audit skill's references/. If you commit the links, prefer relative ones
(e.g. ../../../audit-skills/.agents/skills/audit) so they resolve on any
machine with the same folder layout.

Add to your AGENTS.md

This repo's AGENTS.md is the one-page digest of all 35
invariants. Copy its content into your project's AGENTS.md (append it if
you already have one — never replace yours): merged there, it gives every
agent ambient awareness of the invariants on every prompt; without it, the
skills only activate when triggered. It holds only the invariants; the
topic-to-checklist map lives in the audit skill, loaded when an audit runs.

Claude Code note: Claude Code does not yet read .agents/skills/
(anthropics/claude-code#31005).
Bridge it with:

mkdir -p .claude && ln -s ../.agents/skills .claude/skills
echo '@AGENTS.md' > CLAUDE.md          # if you don't already have a CLAUDE.md

Use

• Automatic — ask your agent to "review this endpoint" / "audit this
  diff"; audit triggers on its description and loads the matching
  checklists. The per-topic and fix skills only run by command.
• By command — /audit for a full audit, or per topic:
  /audit-idor, /audit-injection, /audit-atomicity, … All of them
  audit your current diff by default; name a file, folder, or branch to
  audit something else.
• By name — "run the idempotency checklist on this webhook handler".
• Fixes — after findings are confirmed: /audit-fix-authz,
  /audit-fix-async, /audit-fix-observability (see "How fixes work").

How fixes work

Audits and fixes are deliberately separate steps. /audit and the
audit-* checklists only find and report — they never change code.
Fixing happens when you ask for it: say "fix those" after a report, or run
an audit-fix-* command.

Every finding has a fix available; what differs is where it lives:

Most topics — the fix is in the checklist itself. Each checklist's
Example section shows the vulnerable shape next to the fixed shape. For
topics like injection, secrets, output encoding, or N+1 queries, the fix is
mechanical and has one right answer (parameterize the query, move the secret
to the environment, bulk-load before the loop). When you say "fix it", the
agent applies that fixed shape — no extra command needed.

Eight topics — the fix is an architectural choice. Some findings have
several valid fixes with real trade-offs (an idempotency bug: dedupe table,
idempotency key, UPSERT, or an absolute-state write?). Those topics point to
a remediation playbook that walks the agent through choosing:

Either way, the flow is the same: audit → confirmed findings → ask for the
fix. Fixes follow the same rules everywhere: the smallest change that
restores the invariant, matching the surrounding code style, with a test
demonstrating the fix — and never mixed with unrelated refactoring.

Updating

Releases are git tags.
Run git pull in your clone (or git checkout <tag> to pin a release);
every linked project picks up the change. The digest in your AGENTS.md is
a copy — re-paste it when a release changes AGENTS.md.

License

MIT