Skip to content
Skills Library
Security · Review & audit

checks

/checks

This skill should be used when the user says "create a check", "write a check", "add a check", "apply checks", "run checks", "/checks", "vulnerability pattern", "detection check", "check for common bugs", "scan with checks", or wants to create, apply, or manage simple vulnerability pattern files that agents use to find flaws. Checks are the simplest unit of agentic vulnerability detection — markdown files describing what to look for and how to assess matches. This skill is NOT for general code review or ad-hoc vulnerability analysis.

Repository
grimoire ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
10
Scripts
2
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/index-checks.sh, scripts/validate-check.sh

What it does and when to use it

This skill should be used when the user says "create a check", "write a check", "add a check", "apply checks", "run checks", "/checks", "vulnerability pattern", "detection check", "check for common bugs", "scan with checks", or wants to create, apply, or manage simple vulnerability pattern files that agents use to find flaws. Checks are the simplest unit of agentic vulnerability detection — markdown files describing what to look for and how to assess matches. This skill is NOT for general code review or ad-hoc vulnerability analysis.

Triggers from the description

create a checkwrite a checkadd a checkapply checksrun checksvulnerability patterndetection checkcheck for common bugs
Original author description

This skill should be used when the user says "create a check", "write a check", "add a check", "apply checks", "run checks", "/checks", "vulnerability pattern", "detection check", "check for common bugs", "scan with checks", or wants to create, apply, or manage simple vulnerability pattern files that agents use to find flaws. Checks are the simplest unit of agentic vulnerability detection — markdown files describing what to look for and how to assess matches. This skill is NOT for general code review or ad-hoc vulnerability analysis.

How it works

  1. Philosophy
  2. Workflow
  3. Guidelines
Original SKILL.md headings · 190 lines, 1,134 words
SKILL.md preview
---
name: checks
description: >-
  This skill should be used when the user says "create a check", "write a check",
  "add a check", "apply checks", "run checks", "/checks", "vulnerability pattern",
  "detection check", "check for common bugs", "scan with checks", or wants to create,
  apply, or manage simple vulnerability pattern files that agents use to find flaws.
  Checks are the simplest unit of agentic vulnerability detection — markdown files
  describing what to look for and how to assess matches. This skill is NOT for
  general code review or ad-hoc vulnerability analysis.
user_invocable: true
---

# Checks

Create, apply, and manage vulnerability pattern checks — simple markdown files that describe
what to look for in a codebase and how to assess matches.

## Philosophy

**Many simple checks beat one complex check.** Checks are starting points based on common
mistakes and best practices, not comprehensive analyses. Each check hunts one pattern. Agent
attention is the scarcest resource — keep checks focused and short. When reasoning gets complex,
split into multiple checks. Consult `references/design-principles.md` for the full rationale.

## Workflow

When this skill is activated, create a todo list from the following steps. Mark each task
in_progress before starting it and completed when done.

```
- [ ] 1. Determine intent — create new check, apply existing checks, or manage collection
- [ ] 2. (Create) Identify the vulnerability pattern
- [ ] 3. (Create) Write the check file
- [ ] 4. (Create) Validate the check
- [ ] 5. (Apply) Select applicable checks
- [ ] 6. (Apply) Run checks against the codebase
- [ ] 7. Collect and present results
- [ ] 8. Suggest follow-ups
```

---

### 1. Determine Intent

Ask the user (or infer from context) which mode they need:

- **Create** (steps 2-4) — write a new check from a finding, domain knowledge, or research
- **Apply** (steps 5-7) — run existing checks against a codebase
- **Manage** — index the collection, validate files, reorganize. Use the scripts directly:
  - `bash skills/checks/scripts/index-checks.sh grimoire/spells/checks/` to list all checks
  - `bash skills/checks/scripts/validate-check.sh <file>` to validate a specific check

If unclear, ask the user. Then skip to the relevant step.

### 2. Identify the Vulnerability Pattern

Three sources for new checks:

**From a confirmed finding.** The user or an agent found a specific bug. Generalize the pattern:
what was the observable code pattern? What conditions made it exploitable? What would a grep
for similar instances look like?

**From domain knowledge.** The user knows a class of bugs to look for (e.g., "check for ERC-4626
vault issues"). Extract the specific patterns and assessment criteria.

**From external research.** Use the librarian agent to gather context on a
vulnerability class, then distill into grep-able patterns and assessment rules.

For any source, extract:
1. The observable code pattern (what to search for)
2. The conditions that make a match problematic vs benign
3. A reasonable default severity and confidence level

Consult `references/design-principles.md` to decide whether the pattern should be one check or
multiple. If the pattern involves multiple independent sub-patterns or the assessment requires
deep reasoning, split now rather than after writing.

Check in with the user before continuing.

### 3. Write the Check File

Create a file at `grimoire/spells/checks/<slug>.md` where `<slug>` is a lowercase, hyphenated
version of the check name.

Follow the format in `references/check-format.md`. The file has:

1. **Frontmatter** — `name`, `description`, `languages`, `severity-default`, `confidence`,
   `tools`. Optionally `tags`, `related-checks`, `attribution-name`, and `attribution-url`.
   Add `attribution-name` and `attribution-url` when the check is inspired by external
   research, a known registry (e.g., SWC), an audit report, or another person's work.
2. **Pattern section** — what to search for. Keep patterns grep-able where possible.
3. **Assessment section** — how to evaluate matches. Categories, severity adjustments, benign
   cases to dismiss.

Keep the body under ~30 lines. If it grows longer, split into multiple checks.

Consult `examples/` for worked examples at different complexity levels:
- `examples/debug-assertions.md` — simplest possible check (one pattern family)
- `examples/rounding-direction.md` — scanning check (identify pattern, defer assessment)
- `examples/rounding-inflation-attack.md` — assessment check (deep reasoning on known pattern)
- `examples/erc4626-vault.md` — checklist-style check (multiple items for one standard)
- `examples/unchecked-return-values.md` — cross-language check

If `grimoire/spells/checks/` does not exist, create it. This directory is part of the spellbook
structure created by [[summon]].

### 4. Validate the Check

Run the validation script:

```bash
bash skills/checks/scripts/validate-check.sh grimoire/spells/checks/<slug>.md
```

This verifies:
- All required frontmatter fields are present and non-empty
- Body content exists after the frontmatter
- Body length is within the recommended limit (warns if >30 lines)

Review the check against the simplicity principle: is this one pattern? Is the assessment
clear? Could an agent apply this in a single focused pass?

Check in with the user before continuing.

### 5. Select Applicable Checks

Run the indexing script to see available checks:

```bash
bash skills/checks/scripts/index-checks.sh grimoire/spells/checks/
```

This outputs a tab-separated list: name, description, languages, severity, confidence, filepath.

Filter by:
- **Language** — match the `languages` field against the target codebase
- **Tags** — if the user has a specific focus (e.g., "defi", "crypto", "error-handling")
- **User selection** — present the filtered list and let the user choose which to apply, or
  apply all matching checks

### 6. Run Checks Against the Codebase

For each selected check, spawn a subagent with:

1. The check file content as its instructions
2. The target codebase path
3. Only the tools listed in the check's `tools` field

Each subagent operates independently with minimal context — just the check and the code. This
isolation is critical for attention management. Do not bundle multiple checks into one agent.

Subagents report back for each match:
- File path and line number
- Which pattern matched
- Assessed severity (adjusted from default based on context)
- Confidence assessment
- Brief description of why this is or isn't a finding

Run subagents in parallel where possible.

### 7. Collect and Present Results

Aggregate results from all subagents. Present findings grouped by severity:

1. **Critical / High** — show first, with full context
2. **Medium** — show with summary
3. **Low / Informational** — list briefly

For each finding, include:
- Check name and file path
- Match location (file:line)
- Assessed severity and confidence
- Brief description

After presenting findings, suggest invoking the familiar agent to triage them. The familiar
independently verifies each finding and filters false positives before the user acts on them.

### 8. Suggest Follow-ups

Based on results, suggest:

- **[[write-poc]]** — for confirmed high-severity findings that need proof-of-concept
- **[[cartography]]** — for flows that surfaced during checking and are worth documenting
- **Create more checks** — if patterns suggest related issues not covered by existing checks
- **Scribe distill** — invoke `/scribe-distill` to encode validated patterns into detection
  modules for future audits

---

## Guidelines

- **One pattern per check file.** If a check covers multiple unrelated patterns, split it.
- **Subagents for application.** Never apply checks in the main context. Each check gets its
  own subagent with isolated context.
- **Checks are pointers, not analyses.** They describe where to look and how to assess, not
  what the vulnerability is in depth. Use the librarian agent for background.
- **When in doubt, split.** Two simple checks always beat one complex check.
- **Checks live in `grimoire/spells/checks/`.** This is part of the spellbook directory
  created by [[summon]].
- **Validate before committing.** Run the validation script on every new check.
Files in this package (10)
  • SKILL.md 8 KB
  • examples/debug-assertions.md 1 KB
  • examples/erc4626-vault.md 2 KB
  • examples/rounding-direction.md 2 KB
  • examples/rounding-inflation-attack.md 2 KB
  • examples/unchecked-return-values.md 2 KB
  • references/check-format.md 5 KB
  • references/design-principles.md 5 KB
  • scripts/index-checks.sh 3 KB
  • scripts/validate-check.sh 3 KB

Versions

RepositoryScoreLicence
This page · joranhonig/grimoire100MIT
finolabs/finolabs-vibecode100MIT
yuri-xyz/skills100MIT

Database snapshot: 13.11.2026 · package version 09024b3b8d14 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100trove-security-review
    Security review skill that checks code for common vulnerabilities. Covers OWASP Top 10, secret detection, and secure coding patterns. Use when: security review; owasp check; vulnerability audit.
  • 100sast-configuration
    Configure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning, implementing DevSecOps practices, or automating code vulnerability detection.
  • 100sast-configuration
    Configure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning, implementing DevSecOps practices, or automating code vulnerability detection.
  • 100sast-configuration
    Configure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning, implementing DevSecOps practices, or automating code vulnerability detection.
  • 100sast-configuration
    Configure Static Application Security Testing (SAST) tools for automated vulnerability detection in application code. Use when setting up security scanning, implementing DevSecOps practices, or automating code vulnerability detection.
  • 100security
    Security audits and secure coding. Use for vulnerability detection or auth implementation.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.