Skip to content

About

Claude Code skills for keeping a Claude Code setup safe: review a third-party skill before installing it, lint and evaluate your own skill descriptions, audit the context budget, build least-privilege permissions, author and test hooks, find skill collisions and portability problems. Drives the author's gate, lock, simulator and hook tools.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

Claude Code skills for keeping your Claude Code setup safe and tidy: review third-party skills, lint and evaluate your own, audit context budget, build least-privilege permissions, review the sandbox, preflight unattended runs, scope subagent tools, read session transcripts for usage, shell slips and compaction loss, author hooks, find collisions and portability problems

Fourteen skills, each with an offline, standard-library Python script and tests: skill-supply-chain-review, skill-description-linter, skill-trigger-eval, context-budget-audit, permissions-builder, sandbox-config-review, unattended-run-preflight, subagent-tool-scope-review, session-usage-ledger, shell-slip-audit, compaction-loss-check, hook-author, skill-collision-check and skill-portability-check.

claude-code-tooling-skills is a Claude Code plugin for the upkeep of Claude Code itself. A setup grows by accretion: skills and plugins installed from other people's repositories, descriptions written once and never measured, memory files and MCP servers that fill the context before the first word, permission rules added one "always allow" at a time, a sandbox whose settings are spread over four scopes, hooks copied from examples, two skills with the same name, a script that works on one laptop only. Each skill here turns one of those into a check with a script that reads local files, applies stated rules, and reports what it found with the file and line, leaving the decision to you.

Who it is for: people who write or maintain Claude Code skills and plugins, teams that share a .claude/ folder in a repository, and anyone about to install a skill or plugin they did not write.

Why: skill and plugin supply chains are now an attack path, descriptions decide whether a skill is ever used, and the context window is shared by everything installed. The author already maintains command-line tools for parts of this (skill-scan-gate, cc-plugin-lock, claude-perm-sim, claude-mcp-allow, cc-hooks, mcp-tools-lint); these skills tell Claude when and how to run them, and add the offline checks they do not cover.

/plugin marketplace add basitalisandhu/claude-code-tooling-skills
/plugin install cc-setup-tooling@claude-code-tooling-skills

Quickstart: open Claude Code in a folder of skills and ask "will this skill work on Windows?" or "why is my context so full?". Or run a script directly from a clone of this repository:

printf 'allow Bash(*)\nallow mcp__*\nallow Bash(git * main)\ndeny Bash(rm -rf *)\n' > rules.txt
python3 scripts/cli.py perm-merge --source rules.txt

Real output, the findings part (exit code 1):

## Findings

- allow-glob-ignored (allow) `mcp__*`: from rules.txt; Claude Code skips an allow glob without a literal mcp__<server>__ prefix and approves nothing; dropped
- wildcard-before-subcommand (allow) `Bash(git * main)`: the * stands in for the subcommand, so every git subcommand and option matches
- broad-allow (allow) `Bash(*)`: covers a whole tool or server (from rules.txt)

Then point the other checks at your own setup: python3 scripts/cli.py portability path/to/my-skill, python3 scripts/cli.py context-budget . --home ~, python3 scripts/cli.py sandbox-review --project . --user ~/.claude/settings.json.

Questions, bugs and ideas: open an issue on this repository. Security reports: see SECURITY.md.

Install

  1. This marketplace (above): adds the plugin, named cc-setup-tooling because Claude Code reserves plugin names that start with claude-, with its skills and keeps the ${CLAUDE_PLUGIN_ROOT} script paths working.

  2. Through the claude-skills aggregator, which collects every pack the author maintains in one marketplace: /plugin marketplace add basitalisandhu/claude-skills, then /plugin install cc-setup-tooling@claude-skills. The aggregator copies packs on its own sync schedule, so check its catalog for this plugin before relying on that route; its install.py can also copy skills into ~/.claude/skills without the plugin system.

  3. Without Claude Code: run the scripts from a clone (python3 scripts/cli.py <subcommand>), build the Python package with pip install . (it installs the claude-code-tooling command; it is not on PyPI), or use the container image ghcr.io/basitalisandhu/claude-code-tooling-skills, which publish-github-packages.yml builds for linux/amd64 and linux/arm64 when a version tag is pushed, signed with cosign (keyless), with a build provenance attestation and an SPDX SBOM on the GitHub Release:

    docker run --rm -v "$PWD:/work:ro" ghcr.io/basitalisandhu/claude-code-tooling-skills:0.5.0 portability /work/skills

After a copy install, each SKILL.md says where its script is relative to the skill folder.

Subcommand Script (skill)
inventory skill_inventory.py (skill-supply-chain-review)
desc-lint description_lint.py (skill-description-linter)
trigger-eval trigger_eval.py (skill-trigger-eval)
context-budget context_budget.py (context-budget-audit)
perm-merge perm_merge.py (permissions-builder)
hook-scaffold hook_scaffold.py (hook-author)
collisions skill_collisions.py (skill-collision-check)
portability portability_check.py (skill-portability-check)
sandbox-review sandbox_review.py (sandbox-config-review)
unattended-preflight unattended_preflight.py (unattended-run-preflight)
subagent-scope subagent_scope.py (subagent-tool-scope-review)
usage-ledger usage_ledger.py (session-usage-ledger)
shell-slips shell_slips.py (shell-slip-audit)
compaction-check compaction_check.py (compaction-loss-check)

When to use this

  • You are about to install a skill or plugin from someone else's repository, or a plugin you locked has changed. skill-supply-chain-review
  • A skill you wrote is not picked when it should be, or a strict YAML parser rejects its front matter. skill-description-linter
  • You rewrote a description and want to know whether it now triggers on more of the right requests and fewer of the wrong ones. skill-trigger-eval
  • Sessions compact early, or you are about to add another MCP server or skill pack. context-budget-audit
  • You keep approving the same prompts, or /permissions shows a wildcard nobody remembers adding. permissions-builder
  • You turned on the sandbox and want to know what it actually enforces, or cloned a repository whose .claude/settings.json has a sandbox block. sandbox-config-review
  • A scheduled task, routine, CI job or claude -p run stalls on a permission prompt, or you are about to move a prompt into one. unattended-run-preflight
  • You are adding an MCP server or installing a plugin with agents, and want to know which subagents get its tools. subagent-tool-scope-review
  • A usage limit fills faster than the work you did, or cache writes look like 5 minutes when you expected 1 hour. session-usage-ledger
  • Bash commands keep failing under zsh, or half-work on Windows, without anyone noticing. shell-slip-audit
  • A long session stopped following a rule you gave earlier, or came back from an idle compaction without its context. compaction-loss-check
  • A team rule ("never read .env", "summarise before stopping") should run every time, not depend on memory. hook-author
  • The wrong skill ran, or a new plugin arrived with a skill name you already use. skill-collision-check
  • A skill works on your Mac and fails for a colleague on Windows or in Linux CI. skill-portability-check

Skills

Skill Triggers on Script Drives
skill-supply-chain-review "is this skill safe to install?" skill_inventory.py skill-scan-gate, cc-plugin-lock
skill-description-linter "why does my skill not trigger?" description_lint.py none
skill-trigger-eval "will this description trigger?" trigger_eval.py none
context-budget-audit "why is my context so full?" context_budget.py mcp-tools-lint input files
permissions-builder "set up permissions for this repo" perm_merge.py claude-mcp-allow, claude-perm-sim
sandbox-config-review "is my sandbox actually locked down?" sandbox_review.py none
unattended-run-preflight "why does my scheduled task stall on permission prompts?" unattended_preflight.py none
subagent-tool-scope-review "which of my subagents can use the GitHub MCP tools?" subagent_scope.py none
session-usage-ledger "why did my usage jump this week?" usage_ledger.py none
shell-slip-audit "why do my Bash commands keep failing under zsh?" shell_slips.py none
compaction-loss-check "what did compaction forget?" compaction_check.py none
hook-author "add a hook that blocks this command" hook_scaffold.py cc-hooks
skill-collision-check "why did the wrong skill run?" skill_collisions.py none
skill-portability-check "will this skill work on Windows?" portability_check.py none

skill-supply-chain-review

Reads a cloned skill, plugin or marketplace folder
Does runs skill-scan-gate scan and cc-plugin-lock scan, lists every file with its SHA-256, each script's imports and network, process, dynamic-code and environment use, URLs and domains, shell patterns, credential-store paths, hidden Unicode, hooks, MCP servers, permission rules, symlinks and binaries; locks the reviewed version with cc-plugin-lock lock
Produces a one-page verdict: install, install with changes, or do not install, each reason tied to a file and line

skill-description-linter

Reads SKILL.md files or folders of them
Does checks double quoting, length (600 by default), verb start, a quoted trigger phrase, "Use when", "Not for", name equal to folder, strict-YAML safety and a ## Limits section; --fix rewrites quoting in place, --diff previews it
Produces a per-skill table with listing cost (characters and tokens estimated as characters / 4) and findings with line numbers

skill-trigger-eval

Reads a YAML or JSON prompt set of should-trigger and should-not-trigger prompts per skill, and the descriptions
Does scores each prompt with coverage, bigram, quoted-phrase and "Not for" components (formula in the skill), reports precision and recall, compares two versions, and with --cross counts sibling skills' prompts as negatives
Produces a precision and recall table and every misjudged prompt with its score parts; a lexical proxy, not the host's choice

context-budget-audit

Reads the project, optionally ~/.claude, and saved MCP tools/list results
Does adds up memory files and @ imports, rules without paths:, skill listing entries (capped at 1,536 characters), and MCP tool names, descriptions and schemas; lists on-demand, conditional and not-loaded items separately
Produces totals by category, the largest items, and duplicate, stale-path, stale-date, missing-import, truncated-description, large-item and over-budget findings

permissions-builder

Reads settings files, the block claude-mcp-allow prints, and text files of deny, ask and allow rules
Does merges and de-duplicates, keeps the stricter list on a conflict, flags broad allows and malformed rules, orders deny before ask before allow, diffs against the current file; the skill then tests the result with claude-perm-sim explain, bypass and lint
Produces a report, or with --emit settings the whole settings file with the merged permissions and every other key kept

sandbox-config-review

Reads .claude/settings.json and .claude/settings.local.json of a project, and the user and managed settings files you name
Does merges the sandbox keys and the WebFetch(domain:...), Read(...) and Bash(dangerouslyDisableSandbox:true) permission rules the way https://code.claude.com/docs/en/sandboxing says (managed Boolean keys win, arrays merge, keys a repository cannot set, admin-required and strict-allowlist locks), keeping the scope of every value
Produces the effective values with their source, the allowed and denied domains, findings (sandbox off, fail-open, escape hatch, broad excludedCommands and domain wildcards, readable credentials, filesystem isolation off, all Unix sockets, weaker isolation, proxy ports, repository loosening, strictAllowlist in a scope that ignores it) and a printed list of curl checks to run as sandboxed commands

Sample run on a synthetic project (output trimmed):

mkdir -p demo/.claude && printf '{"sandbox": {"enabled": true, "excludedCommands": ["bash *"], "network": {"allowedDomains": ["registry.npmjs.org", "*.ngrok.io"]}}}\n' > demo/.claude/settings.json
python3 scripts/cli.py sandbox-review --project demo --platform linux
## Findings

- high excluded-command-broad (project) `bash *`: runs a shell (bash) outside the sandbox with your full access
- high repo-loosens (project) `allowedDomains: *.ngrok.io`: set in the committed .claude/settings.json, so anyone who clones the repository gets it
- high repo-loosens (project) `excludedCommands: bash *`: set in the committed .claude/settings.json, so anyone who clones the repository gets it
- medium credentials-readable (default) `.env`: .env files in the project: reads of most of the machine are allowed by default and nothing denies this path
...
- medium domain-wildcard-broad (project) `*.ngrok.io (allowedDomains)`: covers hosts anyone can publish to (ngrok.io, in the default list)
- medium escape-hatch-open (default) `sandbox.allowUnsandboxedCommands`: Claude can retry a failed command unsandboxed (no prompt in bypassPermissions mode, or when an allow rule matches); set it to false, or add the ask rule Bash(dangerouslyDisableSandbox:true)
- medium fail-open (default) `sandbox.failIfUnavailable`: if the sandbox cannot start (missing dependency, unsupported platform) commands run unsandboxed

## Verify enforcement
...
curl -sS -o /dev/null -w "%{http_code}" https://registry.npmjs.org  # connects (any HTTP status from the server, not a proxy 403)
curl -sS -o /dev/null -w "%{http_code}" https://<a host under ngrok.io>  # connects (any HTTP status from the server, not a proxy 403)
curl -sS -o /dev/null -w "%{http_code}" https://example.com  # refused: a 403 from the sandbox proxy or a network prompt (decline it)

The exit code is 1 (high findings). Permission rules are not this layer: they match the text of a call, while the sandbox is enforced on the running process, so the two skills are used together.

unattended-run-preflight

Reads a session log of a previous run (~/.claude/projects/<dir>/<session>.jsonl) or a JSON list of calls, and the settings files the run loads
Does replays each distinct tool call against deny, ask and allow rules from every scope the way https://code.claude.com/docs/en/permissions describes (compound commands split, wrappers stripped, redirects checked as edits, read-only commands and working-directory reads need no approval), and marks calls the recorded run was refused
Produces the calls that would stall the run (or be refused in dontAsk mode), the calls a deny rule blocks, the narrowest allow rule for each, and a separate list of rules a person should decide on; --emit-rules prints the permissions block

Sample run on a synthetic project and call list:

mkdir -p nightly/.claude && printf '{"permissions": {"allow": ["Bash(npm run *)"], "deny": ["Read(./.env)"]}}\n' > nightly/.claude/settings.json
printf '[{"tool": "Bash", "input": {"command": "git status && npm run report"}}, {"tool": "Bash", "input": {"command": "gh issue list --label bug"}}, {"tool": "mcp__github__create_issue", "input": {}}, {"tool": "Write", "input": {"file_path": "reports/nightly.md"}}]\n' > calls.json
python3 scripts/cli.py unattended-preflight --project nightly --cwd nightly --calls calls.json
## Calls that would stop the run

- **needs-approval** `Bash: gh issue list --label bug` (x1, calls.json[1]): `gh issue list --label bug`: no allow rule covers.
- **needs-approval** `mcp__github__create_issue` (x1, calls.json[2]): no allow rule; the name says it changes something.
- **needs-approval** `Write: ./reports/nightly.md` (x1, calls.json[3]): edit of ./reports/nightly.md inside the working directories, no allow rule.

## Proposed allow rules

- `Bash(gh issue list *)`
- `Edit(./reports/**)`

Decide before allowing (they change, publish or run arbitrary code, or an ask rule exists):

- `mcp__github__create_issue`

## Calls that run

- `Bash: git status && npm run report`: every part is allowed

The exit code is 1 until every call runs. It approximates the documented matching and leans towards "needs approval" when unsure, so confirm with one supervised run in the same mode.

subagent-tool-scope-review

Reads .claude/agents/**/*.md, user agent folders, plugin agents/ folders, and .mcp.json or ~/.claude.json for server names
Does applies the field rules on https://code.claude.com/docs/en/sub-agents (no tools line inherits every tool and every MCP server, disallowedTools removes tools, fields a plugin agent ignores, unknown fields ignored) and compares each agent's reach with its own description
Produces one row per agent (tools, MCP servers, write, shell, web) and findings: inherits-all-tools, lookalike-field (allowed-tools in an agent file), read-only-job-with-write-tools, bypass-mode, server-wide-mcp-grant, inline-mcp-server and front matter problems, with a narrower tools line for readers

Sample run on two synthetic agents:

mkdir -p demo-agents/.claude/agents
printf -- '---\nname: code-reviewer\ndescription: Reviews diffs for bugs.\n---\nBody.\n' > demo-agents/.claude/agents/code-reviewer.md
printf -- '---\nname: explorer\ndescription: Explores the codebase.\ntools: Read, Grep, Glob\n---\nBody.\n' > demo-agents/.claude/agents/explorer.md
python3 scripts/cli.py subagent-scope --project demo-agents
| Agent | Scope | Tools | MCP | Writes | Shell | Web |
|---|---|---|---|---|---|---|
| `code-reviewer` | project | all (inherited) | all connected | yes | yes | yes |
| `explorer` | project | Glob, Grep, Read | none | no | no | no |

## Findings

- high inherits-all-tools `project:.claude/agents/code-reviewer.md`: no `tools` line, so it inherits every built-in tool and every MCP tool the session connects. Fix: add a `tools` line with only what the job needs, for example `tools: Read, Grep, Glob`.

The exit code is 1. Pass --mcp .mcp.json to see the server names an inheriting agent reaches.

session-usage-ledger

Reads Claude Code session transcripts (~/.claude/projects/**/*.jsonl, subagent transcripts included)
Does merges the assistant lines of one API response by message id and request id, then adds up input, output, cache read and 5-minute and 1-hour cache write tokens per day, session, model and project; compares two periods by calls, context per call, cache-hit ratio, 5-minute share of writes and first-call size
Produces the ledger tables, "What moved" between the periods, and findings: cache-ttl-5m (with --expect-ttl 1h), low-cache-hit, first-call-overhead, period-jump; prices only from a --rates file you give

Sample run on the synthetic fixture in this repository (four sessions over two weeks, one with a subagent):

python3 scripts/cli.py usage-ledger tests/fixtures/transcripts/usage --compare-weeks --expect-ttl 1h
- API calls: 14 in 4 session(s); subagent calls 2 (4.9% of tokens)
- Input (uncached) 41, output 6,590, cache read 159,000, cache write 354,800 (5m 287,800, 1h 67,000, unsplit 0)
- Cache-hit ratio 30.9%; 5-minute share of split writes 81.1%
- First call per session: median 41,506 tokens, largest 53,004

What moved
----------

- Tokens per day changed +120%; calls per day changed +33% and tokens per call +65%, so about 36% of the change is the number of calls and 64% the size of each call.
- Cache-hit ratio fell from 58.1% to 18.6%.
- 5-minute cache writes went from 0.0% to 100.0% of split writes: 1-hour writes turned into 5-minute writes, which expire sooner and are written again.
- Median first-call size changed +72% (30,504 to 52,505 tokens).

Findings
--------

- cache-ttl-5m: 81.1% of split cache writes used the 5-minute lifetime while 1 hour was expected (threshold 50.0%). Days affected: 2026-10-13, 2026-10-15.
- low-cache-hit: cache-hit ratio 30.9% is below 80.0%. Days below: 4 of 4.
- period-jump: tokens per day rose +120% from the baseline (threshold +50%). See 'What moved'.

The exit code is 1. Plan quotas and weekly percentages are not in the transcript, so the ledger shows what the API responses reported, never what a meter counted.

shell-slip-audit

Reads Claude Code session transcripts: every Bash and PowerShell call and its result
Does classifies failures that come from the shell: zsh no matches found on a flag value or a path glob, = word expansion, bad pattern, parse error, bad substitution, bash-only builtins, glob qualifiers, a heredoc or && sent to PowerShell, a Windows command near the 8,186-character limit, a sandbox that cannot start the shell; marks a slip silent when the result was not flagged as an error
Produces slips per 1,000 shell calls, the silent share and the repeat rate, a table per pattern and per session with an example and a fix, and --emit-rule for a CLAUDE.md block

Sample run on the synthetic fixture (a zsh session and a Windows session):

python3 scripts/cli.py shell-slips tests/fixtures/transcripts/shell
- Shell calls: 14 (Bash 12, PowerShell 2) in 2 session(s)
- Slips: 9 call(s), 642.9 per 1,000 shell calls
- Silent (result not marked as an error): 3 (33%)
- Repeat rate (same pattern again in the same session): 11%
- Interrupted or timed out: 1

Patterns
--------

Pattern                    Kind  Calls  Per 1,000  Silent  Repeats
-------------------------  ----  -----  ---------  ------  -------
glob-in-flag-value         slip  2      142.9      2       1
bad-substitution           slip  1      71.4       0       0
bash-only-builtin          slip  1      71.4       0       0
bash-syntax-in-powershell  slip  1      71.4       0       0
equals-expansion           slip  1      71.4       0       0
heredoc-in-powershell      slip  1      71.4       0       0
unmatched-glob             slip  1      71.4       0       0
windows-command-length     slip  1      71.4       1       0
timed-out                  stop  1      71.4       0       0

The exit code is 1. It sees only failures the shell reported, so the rate is a floor.

compaction-loss-check

Reads Claude Code session transcripts: compact_boundary lines, the summary after each, and what came before
Does reports each compaction's trigger, tokens before and after and the time since the last user message (idle compactions), and checks the summary for the standing rules the user gave, the files edited, branches and pull requests created and open to-dos
Produces a "re-state these" list per compaction and, with --emit-recap, a block to paste back into the session

Sample run on the synthetic fixture (one session, an auto compaction and an idle one):

python3 scripts/cli.py compaction-check tests/fixtures/transcripts/compaction
- Compactions: 2 in 1 transcript(s); triggers: auto 1, idle 1
- Idle compactions (a trigger other than auto or manual, or auto at least 30 minutes after the last user message): 1
- Summaries not found after the boundary: 0
- Items missing from a summary, counted per compaction: 12 (standing rules 4, edited files 4)

Session 7c2e9a4b at 2026-10-22 09:06 (7c2e9a4b-3f1d-4b6c-a0e5-9d8f1b3c2a77.jsonl:12)
------------------------------------------------------------------------------------

Trigger auto, 167,000 to 9,800 tokens, 6 min after the last user message.
Checked 7 item(s): 4 kept, 0 partly, 3 to re-state.

Re-state these:
- rule (missing): Always run npm test before you commit.
- file (missing): /srv/demo-shop/src/checkout/total.ts
- todo (missing): Update the order confirmation email

The exit code is 1. Matching is by substring and word overlap, so it misses paraphrase and can over-report; read the summary before re-stating.

hook-author

Reads a short spec: name, event, matcher, action (block, warn, allow or modify), pattern, message and two examples
Does checks the action is valid for the event, that the pattern separates the examples and that the message references no environment variables, then writes the hook in the cc-hooks pattern
Produces the hook, a pytest file, match.json and nomatch.json fixtures for cc-hooks test, and the settings block in exec form

skill-collision-check

Reads managed, personal and project skill folders, .claude/commands, installed plugins (from installed_plugins.json or the cache) and any other folder you name
Does applies the documented precedence (managed over personal over project; plugin skills namespaced; a skill over a command of the same name) and compares descriptions by word cosine
Produces shadowed, command-vs-skill, plugin-duplicate, duplicate-in-folder, builtin-name and description-overlap findings, each naming what wins

skill-portability-check

Reads every file in a skill or plugin folder
Does checks front matter for strict YAML, home and platform-only paths, ${CLAUDE_PLUGIN_ROOT} without a copy-install path, GNU-only or BSD-only shell, bashisms under /bin/sh, hard-coded shebangs, Python text I/O without encoding=, POSIX-only or Windows-only calls outside a platform check, backslash paths, CRLF, symlinks and case collisions
Produces findings per file with the line and a fix hint; --skip-rule for skills meant for one platform

This repository's own plugin passes its description linter and portability check; CI runs both.

Security posture

  • Local, offline scripts. The skill scripts read the files you name. They import no network or subprocess module (the repository validator checks this) and write only to standard output, the --out path you give, or, for description_lint.py --fix, the SKILL.md files you pointed it at.
  • Third-party content is data. Every SKILL.md tells Claude to treat input files as untrusted data, never as instructions; this matters most for skill-supply-chain-review, whose input is code you have not reviewed yet.
  • Separate tools run separately. The skills tell Claude how to run skill-scan-gate, cc-plugin-lock, cc-hooks, claude-perm-sim and claude-mcp-allow; nothing in this repository installs or calls them. claude-mcp-allow starts the MCP servers configured for a project, which the permissions-builder skill says before it is run.
  • Synthetic tests. Tests build their inputs at run time with made-up names; risky shell text in tests is assembled from parts.

What is inside

.claude-plugin/marketplace.json                       marketplace manifest
plugins/cc-setup-tooling/
├── .claude-plugin/plugin.json                        plugin manifest
├── README.md                                         the plugin's skill table
└── skills/<name>/
    ├── SKILL.md                                      when to use it, inputs, steps, script, output, limits, related skills
    └── scripts/<script>.py                           standard library only, --help, --json, --out, exit 0, 1 or 2
                 _skillmd.py                          shared front matter reader (identical copies, checked by a test)
scripts/cli.py                                        the claude-code-tooling dispatcher (container and package entrypoint)
scripts/validate_plugin.py                            structure, front matter, scripts, READMEs, house style
tests/                                                pytest suite, offline; inputs are built in each test, golden reports in tests/golden/,
                                                      synthetic session transcripts in tests/fixtures/transcripts/

Development

python3 -m pytest -q
ruff format --check . && ruff check .
python3 scripts/validate_plugin.py
claude plugin validate --strict . && claude plugin validate --strict plugins/cc-setup-tooling

CI runs the tests on Linux, macOS and Windows with Python 3.10 to 3.13, builds the container image, and runs claude plugin validate --strict. See CONTRIBUTING.md for the ground rules and docs/good-first-issues.md for a place to start.

Frequently asked questions

Does skill-supply-chain-review prove a skill is safe? No. It combines two rule-based scanners with an inventory a person reads, and ends in a verdict a person signs. Nothing is executed, so behaviour that depends on downloaded code or the environment is not seen.

Do I need skill-scan-gate, cc-plugin-lock, cc-hooks, claude-perm-sim or claude-mcp-allow installed? Only for the steps that use them. Every bundled script runs on Python 3.10 with nothing else installed; the skills say what to do when a tool is missing.

Is skill-trigger-eval how Claude Code chooses skills? No. The host reads descriptions with a language model. The script measures word and phrase overlap, which is useful for comparing two wordings against the same prompts and spotting plain misses, and it says so in its output.

Are the token numbers exact? No for context-budget-audit and skill-description-linter, which estimate tokens as characters / 4 and say so. session-usage-ledger adds up the token counts the API responses reported in the transcripts; it cannot say how a plan meter weighs them.

Does sandbox-config-review prove the sandbox works? No. It reads settings files and applies the merge rules on the official page; it cannot see the --settings flag, server-managed settings or missing dependencies. It prints curl checks for you to run as sandboxed commands in a session, which is how you confirm enforcement.

Will permissions-builder edit my settings.json? No. It prints a report or a proposed settings file; copying it into place is your step, after testing it with claude-perm-sim.

Why does skill-portability-check flag ~/Library in my macOS skill? Because the path exists on one platform only. For a skill that is meant for macOS, pass --skip-rule platform-path and say so in the skill's Limits.

Can I run these in CI? Yes. Each script exits 1 when something needs a person and 2 on bad input, so desc-lint, portability and collisions work as CI gates.

Related repositories

Repository What it is
skill-scan-gate CI gate that scans skill and plugin repositories for unsafe instructions, hooks and MCP servers, with SARIF output
cc-plugin-lock Lock file that pins installed plugins and skills to content hashes, verifies them before a session and scans a folder before install
claude-perm-sim Permission rule simulator: which rule decides a call, and where an allow rule admits more than it names
claude-mcp-allow Least-privilege permission rules for MCP tools from their annotations, with drift checks
cc-hooks Typed Python SDK and offline test runner for Claude Code hooks
mcp-tools-lint Lint MCP tool schemas and annotations from a server or a saved tools/list result
claude-skills Every skill pack the author maintains, in one marketplace

More from the author: basitalisandhu.github.io.

Licence

MIT. See LICENSE.

About

Claude Code skills for keeping a Claude Code setup safe: review a third-party skill before installing it, lint and evaluate your own skill descriptions, audit the context budget, build least-privilege permissions, author and test hooks, find skill collisions and portability problems. Drives the author's gate, lock, simulator and hook tools.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages