agentleFS
skyfox675skyfox675/agents-skills/CLAUDE.md

agents-skills

CLAUDE.md11 starsChanged 6 days agoMITView on GitHub

A public, shareable collection of AI toolchains — Skills and Agents — meant to be consumed by others across multiple AI coding tools (Claude Code, GitHub Copilot, Cursor). It is a content/config repo: there is no application code, no build step, and no test runner. "Correctness" here means each artifact is valid for its target tool and works when dropped into a consumer's environment. Because it is public and reusable, every artifact must be clean of personal and prior-project data.…

The file

We split this CLAUDE.md into the rules it gives an agent

4 rules. About 0 are common, 2 are distinctive, and 2 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 2

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When adding the first artifacts, create these directories.

    line 22
  2. Very specific:

    When asked to add or rename a skill, treat the name as a public API: renaming breaks consumers who invoke it by name.

    line 31
  3. Distinctive:

    Write artifact bodies in plain, tool-neutral language.

    line 67
  4. Very specific:

    Keep frontmatter description action-oriented and specific — it is what each tool uses to decide when to trigger the skill/agent.

    line 68

≈ “Common” is an estimate: at least 1 in 5 of the 27,641 CLAUDE.md files we read have a rule of the same kind, not the same words. “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
CLAUDE.md

CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

What this repository is

A public, shareable collection of AI toolchains — Skills and Agents — meant to be consumed by others across multiple AI coding tools (Claude Code, GitHub Copilot, Cursor). It is a content/config repo: there is no application code, no build step, and no test runner. "Correctness" here means each artifact is valid for its target tool and works when dropped into a consumer's environment.

Because it is public and reusable, every artifact must be clean of personal and prior-project data. No employer names, internal URLs, ticket IDs, secrets, file paths from private repos, or learnings that only make sense inside one codebase. Keep learnings isolated — phrased generically so they apply anywhere.

Primary goal: extreme token savings at the highest practical accuracy. Every authored skill operates in caveman mode for terse working output, and model spend is tiered — the cheapest capable model per task, with mechanical work offloaded to a cheap-tier subagent and premium reserved for operator-gated hard reasoning. See MODEL-DEFAULTS.md.

Repository layout

Skills and Agents are the two primary artifact types. The canonical homes are the directories Claude Code auto-discovers:

  • .claude/skills/<skill-name>/SKILL.md — one directory per skill; SKILL.md holds YAML frontmatter (name, description) + the skill body. Supporting files (references/, scripts) live alongside it.
  • .claude/agents/<agent-name>.md — one file per agent; frontmatter (name, description, tools, optional model) + system prompt. Ships 18 tiered worker agents (scout on the cheap tier; builder, reviewer, implementer, pr-rescuer, diagnostician, verifier, spelunker, design-mapper on workhorse — these the commands dispatch — plus the pr-dispatcher, pr-comments, pr-checks, pr-cleanup single-lane PR watchers, the deploy-watcher deploy-health lane, and the ci-speed-hunter, ci-flake-hunter continuous CI lanes, the token-bleed-hunter token-efficiency lane and the branch-ff fast-forward lane, all run via /loop). Canonical agents live here; make sync-agents generates the Cursor (.cursor/agents/, model/readonly schema), Copilot (.github/agents/*.agent.md), Kiro (.kiro/agents/, tools category allowlist), OpenCode (.opencode/agents/, mode/permission) and Codex (.codex/agents/*.toml, developer_instructions) copies — never hand-edit those. .codex/config.toml is hand-maintained. Keep agents thin and point at the relevant skill for the protocol.
  • .claude-plugin/marketplace.json + plugins/agents-skills/ (Claude Code) and .cursor-plugin/marketplace.json + plugins/agents-skills-cursor/ (Cursor) and .agents/plugins/marketplace.json + plugins/agents-skills-codex/ (Codex/ChatGPT; plugin.json at the plugin root) — this repo doubles as its own plugin marketplace for all three ecosystems. Same skills in each (the Agent Skills format is identical); agents and commands come from that tool's generated mirror, since their frontmatter differs. Codex plugins carry no agents or commands, so the Codex payload is skills only. The plugin payload is generated from .claude/{skills,agents,commands} by make build-plugin (real copies, not symlinks — Claude Code installs the plugin dir standalone, so a link escaping it would dangle); make check-plugin fails on drift. Never hand-edit plugins/. Releases are cut by .github/workflows/release-plugin.yml: CalVer YYYY.M.D.N (patch counter so same-day releases never collide), tag v<version>, assets = one zip per plugin + one zip per skill (the latter for Claude Desktop and ChatGPT upload). The workflow stamps versions — never bump them by hand.
  • .claude/settings.json — repo-level Claude Code config. Currently pins model: opus and includeCoAuthoredBy: false (commits authored without the Claude co-author trailer).

When adding the first artifacts, create these directories. Top-level README.md is the human entry point.

GLOSSARY.md defines the vocabulary the artifacts assume: slot, dispatcher, watcher, hunting, ci-speed, flake, token bleed, plus lane, tick, primary checkout, and singleton. The watcher/hunter and speed/flake distinctions are load-bearing: several skills refuse work on the strength of them, so keep new artifacts consistent with these definitions.

Two kinds of skill

  1. Self-contained skills — the full instructions live here.
  2. Pointer skills — a thin SKILL.md that points to an upstream project's skill (e.g. a plugin or another repo) so the latest version is always used. For these, the name defined here is the contract — keep it stable even when the upstream target moves. Document the upstream source and what the local name maps to inside the body; don't inline the upstream content (that defeats the point of pointing).

When asked to add or rename a skill, treat the name as a public API: renaming breaks consumers who invoke it by name.

Cross-tool consumability

The same artifact often needs to be reachable from six tools. Keep the content authored once (canonically under .claude/) and expose it to the others rather than forking copies:

  • Claude Code — reads CLAUDE.md, .claude/skills/, .claude/agents/ natively.
  • GitHub Copilot — reads .github/copilot-instructions.md (and AGENTS.md); agents in .github/agents/*.agent.md.
  • Cursor — reads AGENTS.md (and .cursor/rules/*.mdc if you add project rules); agents in .cursor/agents/.
  • Kiro — reads agents from .kiro/agents/<name>.md and skills from .kiro/skills/ (the Anthropic Agent Skills format, same as .claude/skills/).
  • OpenCode — reads agents from .opencode/agents/<name>.md and skills from .opencode/skills/ (same Agent Skills format).
  • OpenAI Codex (CLI, IDE extension, ChatGPT desktop app) — reads AGENTS.md; skills from .agents/skills/ (same Agent Skills format); custom agents from .codex/agents/<name>.toml (TOML: name, description, optional model, developer_instructions); custom prompts from ~/.codex/prompts/ only. The project .codex/ layer (agents + .codex/config.toml) loads only once the project is trusted. ChatGPT web/mobile runs skills only, via the Codex plugin or per-skill upload — no custom agents or commands.

Because Kiro, OpenCode and Codex read the identical skill format, .kiro/skills, .opencode/skills and .agents/skills are symlinks to .claude/skills (one source of truth) — make sync-skills creates/repairs them. Agents, whose frontmatter differs per tool, are generated copies (see below). Prefer a shared AGENTS.md (Copilot + Cursor both honor it) over maintaining divergent copies. If a new artifact only makes sense for one tool, say so in its body.

Slash commands don't share a home or format — each tool needs its own copy, so the canonical .claude/commands/*.md are mirrored:

  • Claude Code — .claude/commands/<name>.md (YAML frontmatter: description, argument-hint, allowed-tools; body uses $ARGUMENTS).
  • Cursor — .cursor/commands/<name>.md (plain markdown, no frontmatter; filename is the command; args = text typed after the command).
  • GitHub Copilot (VS Code) — .github/prompts/<name>.prompt.md (frontmatter description/argument-hint/agent; body uses ${input:args}). Copilot CLI does not support custom commands yet.
  • Codex — .codex/prompts/<name>.md (frontmatter description/argument-hint; $ARGUMENTS native; every other $ token escaped as $$). Users copy them to ~/.codex/prompts/ and run /prompts:<name>. OpenAI has deprecated custom prompts in favour of skills.

The Cursor, Copilot and Codex copies are generated from the Claude source — after editing any .claude/commands/*.md, run make sync-commands (or python3 scripts/sync-commands.py) to regenerate them; make check-commands exits non-zero if they've drifted (wire it into CI / a pre-commit hook). Never hand-edit the mirrors. The script also prunes mirrors whose source command was renamed or deleted.

Model selection policy

Model spend is tiered and Anthropic-first for reasoning. Full task→tier matrix + per-platform model IDs: MODEL-DEFAULTS.md.

  • Cheap / mechanical — ls/grep/git status, file lookups, listing, fixed-command runs. Haiku 4.5, or each platform's cheapest native model (Copilot Raptor Mini, Cursor's free Auto). Always offloaded to a cheap-tier subagent that returns a distilled, caveman-compressed answer — never run in the main session.
  • Workhorse (default) — the orchestration loop, verification, dev work, filing/grooming/recon. Sonnet 4.6.
  • Premium (operator-gated) — hard, cross-cutting reasoning only, never self-escalated. Opus 4.8.

Substitutes from other providers are acceptable only if they match on both axes: comparable context window (≈200K+, or 1M-class where the artifact needs it) and comparable reasoning tier — except the mechanical tier, which deliberately uses each platform's cheapest native model. State the substitution and why in the artifact when you make one.

Conventions

  • Write artifact bodies in plain, tool-neutral language. Avoid assuming a specific local environment.
  • Keep frontmatter description action-oriented and specific — it is what each tool uses to decide when to trigger the skill/agent.
  • Validate by structure (valid frontmatter, required keys present, name unique) since there is no test suite.
  • Token discipline for the orchestration family (dispatch, rescue, gh-issue-*/jira-issue-* commands and their skills): operate in caveman mode to conserve tokens across the high-volume loop, but write the durable prose a human reads — issue/ticket bodies and PR descriptions — through humanizer so it doesn't read AI-generated. Under both, machine-precise content (labels/fields, JQL, gh/MCP commands, lock markers, the RECON OK/RECON-ERROR contract, file:line refs, code blocks, acceptance-criteria checklists) stays byte-exact.

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.