skill

agent-skills

Personal collection of agent skills for Claude

leek/agent-skillscommunitylistedunreviewed

Set up

Skills are installed by placing their folder where your agent loads skills.

Download ZIP from GitHub Open the repository

The download comes from github.com/leek/agent-skills itself, not from our server, so what you get is exactly what its author published.

Install instructions come from the README

Skills do not use an MCP config. Follow the steps in the README below.

README

synced Oct 17, 2026

Agent Skills

Personal collection of agent skills for coding agents (Claude Code, Cursor, Grok, and others).

Skills follow the Agent Skills format.

Available Skills

Skills marked user are user-invoked only (/name); the rest the agent can reach for on its own. Many are adapted from Matt Pocock's skills, tuned for Laravel/PHP repos.

The engineering pipeline is one straight line (decide → spec → tickets → build) over one directory per effort:

.scratch/<slug>/
  map.md        # /wayfinder: the decisions (skip it for small, clear work)
  decisions/    # /wayfinder: one file per decision ticket
  spec.md       # /to-spec: exactly one, written once
  tickets/      # /to-tickets: one file per build ticket

/implement then builds one file from tickets/ per fresh session. triage is the other on-ramp. There is no external issue tracker; every artifact is a markdown file.

Skill	Invocation	What it does
`architecture-satisfaction`	user	Run a bounded architectural refactor loop.
`autopilot`	user	Drive an existing wayfinder map, spec, or set of tickets to completion through fresh top-level Claude Code, Codex, or Grok sessions.
`browser-test`	user	Test a web app from a start URL and a plain-language prompt: a planner splits it into cases, cheap parallel browser workers run them, and one verdict table comes back. Read-only unless you confirm a write.
`chatter-scout`	user	Sweep the web for new chatter on a topic, skip what earlier runs saw, verify the rest in cheap parallel subagents, and write one ranked, cited findings file for a blog post or digest.
`code-review`	model	Review the changes since a fixed point (commit, branch, tag, or merge-base) along three axes: Correctness (would it break: bugs, failure modes, security, missing tests), Standards (does the diff follow this repo's documented conventions, including colocated CLAUDE.md rules?) and Spec (does it implement what the originating ticket/PRD asked?).
`code-smells-audit`	model	Audit a codebase, path, glob, or branch diff for classic code smells using the 56-smell Luzkan catalog, with detection heuristics tuned to PHP/Laravel and TS/React: sweep nine occurrence lenses, adversarially verify every candidate against the smell's card definition, emit a ranked markdown findings report.
`codebase-design`	model	Shared vocabulary for designing deep modules in any codebase.
`commit`	user	Commit the work done in this session, skipping files a parallel session also touched.
`dependency-audit`	user	Run a Composer or npm dependency audit and propose a safe upgrade plan.
`diagnosing-bugs`	model	Diagnosis loop for hard bugs and performance regressions.
`domain-modeling`	model	Build and sharpen a project's domain model: challenge terms against the glossary, resolve fuzzy language, stress-test concepts with concrete scenarios, and record GLOSSARY.md entries and ADRs the moment decisions land.
`fix-ci-failures`	user	Read a branch's latest failed CI runs, triage each failure from its existing logs, and fix the real ones.
`fix-github-issues`	user	Verify, triage, fix, and close review-bot GitHub issues one finding at a time.
`fix-nightwatch-issues`	user	Triage open Laravel Nightwatch production issues by root cause, fix the legit ones, and resolve them with evidence.
`fix-posthog-issues`	user	Triage active PostHog error-tracking issues by root cause, fix the legit ones, and resolve or suppress the rest.
`grill-me`	user	Run a grilling session: the user wants their plan, decision, or idea stress-tested one question at a time.
`grill-with-docs`	user	Run a grilling session with domain-modeling alongside, capturing terms in GLOSSARY.md and decisions as ADRs while they land.
`grilling`	model	Interview the user one decision at a time until reaching shared understanding, resolving each branch of the decision tree with recommended options and trade-offs.
`handoff`	user	Compact the current conversation into a handoff document for another agent to pick up.
`housekeeper`	user	Run a conservative code-project housekeeping pass.
`implement`	user	Implement one work item end to end: scope and claim it when trackable, TDD at agreed seams, commit, review, verify, and resolve it.
`implement-spec`	user	Build a whole spec fast: parallel implementer subagents work the ticket frontier, each in its own worktree, merging onto one integration branch; then one review, one verification pass, and one PR. Cuts the tickets first when the spec has none.
`improve-codebase-architecture`	user	Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.
`laravel-herd-worktrees`	model	Use when working with Laravel projects served by Laravel Herd alongside git worktrees on macOS.
`panel`	user	Convene a panel of agent CLIs (grok, claude, codex, agy) on a prompt or a code review, each in its own headless subagent, then report one consensus grouped by how much they agree.
`pr`	model	The pull request body format, built for fast human review: the smallest visual of the change, before/after evidence, and a one-way or two-way door call with its blast radius.
`prune-tests`	user	Delete low-signal tests one test area at a time, keeping coverage within 2%, and open one PR per area. Earlier runs' areas are excluded.
`prototype`	model	Build a throwaway prototype to answer a design question.
`release`	model	Commit this session's work, bump the version, tag, push, and publish a GitHub release with grouped notes.
`repository-cleanup`	user	Audit and clean Git repository state, including the local databases old worktrees left behind.
`research`	model	Investigate a question against high-trust primary sources and capture the findings as a cited Markdown file.
`retro`	user	Look back over AI-coding sessions (this one, or your recent Claude Code + OpenAI Codex logs) for corrections, errored or retried commands, rediscovered setup, and missing checks or information, then propose where each fix belongs (a deterministic check, a review rule, a CLAUDE.md/AGENTS.md pointer, a skill, a hook, a tool or config fix, or a content idea).
`resolve-review-comments`	model	Triage, fix or rebut, then reply-and-resolve every review comment on a PR (including AI-review bot findings).
`resolving-merge-conflicts`	model	"Use when you need to resolve an in-progress git merge/rebase conflict."
`scratch-cleanup`	user	Sweep a dusty .scratch/: file research into docs/, remove finished efforts, and report the work still open.
`scratch-status`	user	Report what is still open across `.scratch/`: every effort's open tickets and decisions, what blocks it, how stale it is, and the next skill to run. Read-only.
`setup`	user	Configure this repo for the engineering skills: the markdown issue tracker layout, triage label vocabulary, and domain doc layout.
`sweep`	user	Dig for one problem nobody has noticed yet, prove it, fix it, and open one PR per problem. Every run finds something new: earlier PRs (open, merged, or declined) are excluded, never a reason to stop.
`tdd`	model	The red → green loop for any stack: seams, what a good test is, and the anti-patterns to refuse.
`teach`	user	Teach the user a new skill or concept, within this workspace.
`to-questionnaire`	user	Turn a decision the user can't fully answer into a Markdown questionnaire for someone else to fill in, async or over a meeting.
`to-spec`	model	Turn the current conversation into a spec (PRD) and save it as markdown under .scratch/: no interview, just synthesis, with Laravel test seams chosen from the tdd ranking rules rather than asked about.
`to-tickets`	model	Break a spec into tracer-bullet vertical-slice tickets with explicit blocking edges, take one green light on the breakdown, and save one markdown file per ticket beside the spec.
`triage`	user	Move issues and external PRs through a state machine of triage roles: categorise, verify, grill if needed, and write agent-ready briefs.
`triage-github-pr`	user	Review and merge a pull request with up to two fix rounds, carrying later findings into a follow-up PR.
`upgrade-plan`	user	Plan a library or framework upgrade from the installed version to the latest: cheap parallel subagents read the changelogs and scan the code, and one plan sorts what breaks, which local patches and workarounds can go, and what to adopt into must do, should do, and do later. Follows the dependencies that have to move too.
`verify`	model	Exercise a change end to end in the running application (hit the route, run the command, click through the page) and report what actually happened.
`wait-what`	user	Stop; that last message did not land. Re-pitch it.
`wayfinder`	user	Plan work too big for one agent session as a map of decision tickets in markdown under .scratch/, then resolve them one per session until the route to the destination is clear.
`which-skill`	user	Not sure which skill to reach for? Name the situation and get routed to one.
`wizard`	model	Generate an interactive bash wizard that walks a human through steps only they can perform: provisioning, dashboard credentials, CI secrets, one-off migrations or cutovers.
`writing-for-agents`	model	Reference for writing documents an agent consumes: skills, AGENTS.md/CLAUDE.md, and reference docs reached by a pointer.

Subagents (Claude Code)

Installing the plugin also loads the subagents in agents/ as leek-skills:<name>. The skills dispatch them where they already fan out work: code-review → standards-reviewer + spec-reviewer, codebase-design (design-it-twice) → module-designer, improve-codebase-architecture → deepening-scout, retro → session-miner, panel → panelist, browser-test → browser-test-planner + browser-tester + browser-writer, chatter-scout → chatter-sweeper + chatter-verifier, code-smells-audit → smell-sweeper, prune-tests → test-auditor, fix-github-issues + triage-github-pr → finding-verifier, triage-github-pr → pr-reviewer, upgrade-plan → release-notes-collector + upgrade-impact-scout; research and dependency-audit fork into researcher and dependency-auditor. The one plugin hook, hooks/hooks.json, guards browser-tester and browser-test-planner so they can only run read-only browser commands. Other harnesses ignore the directory and the skills fall back to inline or generic sub-agents, as before. Conventions in AGENTS.md.

Mods (Claude Code)

The plugin also ships a mod (hooks/mods/), which loads with the plugin in the Claude Code terminal and Desktop Code tab:

/scratch [effort]: a live pane of every .scratch/ effort (open tickets, blockers, claims, staleness, next command), opened instantly, even mid-turn, and refreshed whenever a tool writes under .scratch/. scratch-status adds the commit checks.
Workers band: above the prompt, every subagent a fan-out skill dispatched (implement-spec, autopilot, browser-test, panel, chatter-scout, code-review, ...), with its tool count, latest tool, elapsed time, and outcome.

Other harnesses, and Claude Code surfaces that don't draw, run the same skills without it.

Installation

`npx skills` (any agent)

Install the whole collection:

npx skills add leek/agent-skills

Install a single skill:

npx skills add https://github.com/leek/agent-skills --skill code-review

Re-run either command to update.

This copies the skills only. The typed subagents in agents/ come with the Claude Code plugin below, so in a repo that has the skills from npx skills and no plugin, a dispatch to leek-skills:<name> fails with Agent type ... not found and the skill takes its general sub-agent path. Install the plugin as well to get the cheaper, read-only typed agents.

Claude Code (plugin marketplace)

/plugin marketplace add leek/agent-skills
/plugin install leek-skills@leek-agent-skills

Codex (plugin marketplace)

Codex reads the same .claude-plugin/marketplace.json:

codex plugin marketplace add leek/agent-skills
codex plugin add leek-skills@leek-agent-skills

Codex lists the model-invoked skills as leek-skills:<name> and loads the plugin's hooks/hooks.json. It does not load agents/ or the mod; the skills fall back to Codex's own sub-agents (spawn_agent) or run inline. Pick one route per machine: if you already installed with npx skills, the plugin lists those skills a second time.

Claude Code (manual copy)

cp -r skills/<skill-name> ~/.claude/skills/

claude.ai

Upload the skill folder via skill settings, or paste the SKILL.md contents into a project's knowledge.

Claude API

See the Skills API Quickstart.

Skill Structure

Each skill is a folder under skills/:

skills/
  <skill-name>/
    SKILL.md         # required: frontmatter + instructions
    scripts/         # optional: helper scripts
    references/      # optional: supporting docs

The SKILL.md frontmatter requires only two fields (Claude Code reads a few optional ones such as argument-hint and allowed-tools; other harnesses ignore them, see AGENTS.md):

---
name: my-skill
description: One sentence, what it does and when Claude should use it.
---

# My Skill

Instructions here.

See template/SKILL.md.example for a starting point and AGENTS.md for full conventions.

Creating a Skill

Copy template/SKILL.md.example to skills/<skill-name>/SKILL.md.
Fill in SKILL.md: follow the authoring principles in AGENTS.md and the writing-for-agents skill.
Add the skill to .claude-plugin/marketplace.json under the leek-skills plugin.
Update the Available Skills section above.
Open a PR.

License

MIT