Matched to how you actually work.
Human reviewed
Every item, before it ships.
Policy linted
No shell preprocessing or hidden fetches.
Measured after install
Your coaching report shows whether it stuck.
30 validated picks
Reviewed for Claude Code · Cursor · Codex CLI
Plan-then-execute — a working procedure for non-trivial tasks
A skill your agent invokes when a task is non-trivial: write the spec and acceptance check, produce a step-ordered plan, get it approved, then execute one step at a time with a checkpoint after each. The procedure form of the plan-first rule.
Verify-after-accept — close the loop on accepted changes
A skill that runs after you accept a change: it re-derives what the change claims to do, runs the narrowest real check that could falsify it, and reports what remains unverified — so acceptance and verification stop drifting apart.
Edge-case hunter — find the test you didn't write
A skill that inspects a change and its tests, enumerates the boundary conditions the tests do not cover — empty inputs, nulls, ordering, concurrency, unicode, limits — and drafts the two highest-value missing tests.
Explain-this-change — comprehension as a deliverable
A skill that turns any diff into a structured explanation: what changed, why this approach, what could break, and one question to test your own understanding — so comprehension keeps pace with acceptance.
Scope-cutter — ship the smallest version that counts
A skill that takes a ballooning task and splits it into the smallest landable slice plus an explicit later-list — so sessions end in commits instead of half-finished threads.
Context-primer — keep the file every agent reads first current
A skill that audits your project-instructions file (CLAUDE.md / AGENTS.md / rules) against the repo as it exists today: stale commands, missing conventions, gotchas discovered since — and drafts the minimal update.
Migration-check — verify the least reversible change first
A backend skill invoked on any schema or migration change: confirms reversibility or an explicit one-way call, checks defaults and nullability against live-row reality, and verifies a test exercises the new shape before it ships.
Study-recap — end each session with recall, not just code
A student skill that closes a working session by turning what was built into understanding: the concepts used, one re-implementation exercise, and the question you should be able to answer cold tomorrow.
Automation leverage — turn repeated work into agents
An /automate slash command (rule form for Cursor/Codex) that reviews each session for repeated manual work and proposes the smallest useful skill, command, or subagent to own it. For builders who want each session to compound.
Learning mode — ask for explanations, not just solutions
An always-on rule that puts your assistant in learning mode: explain the reasoning before the answer, prefer the smallest change that teaches the concept, and point at the underlying pattern so the skill transfers to you.
API contract tester — verify the integration boundary
A verification subagent (rule form for Cursor/Codex) that runs your integration and contract tests after any route, schema, or migration change — and checks that request/response shapes still match their consumers.
Ship fast, watch churn — velocity with a guardrail
A rule that keeps founder velocity honest: land small same-day commits, and treat a 14-day churn spike as a signal to rethink the approach instead of piling on more code.
Plan-first workflow — spec before you generate
A plan-first rule for every tool: spec, plan, implement, verify — with the model producing and getting approval on the plan before it edits anything.
Context-engineering starter — give agents real context
A context-engineering starter block for CLAUDE.md / AGENTS.md / Cursor rules: what the project is, how to run it, the conventions to imitate, and the gotchas — the file every agent reads first.
Tester setup — verify every accepted change
A Tester subagent for Claude Code (rule form for Cursor/Codex) that runs the project's test suite after accepted changes and reports honestly on what it could not verify.
Explain-before-accept — keep comprehension with acceptance
An /explain slash command (rule form for Cursor/Codex): what the change does, why this approach, what could break, and the one thing to verify yourself — before you accept it.
Test-alongside rule — tests ship with the change
A test-alongside rule: tests ship in the same change as the code they cover, run in-session, and bug fixes start from a failing reproduction.
Finish-the-thread — land each session as a commit
A /wrap-up slash command (rule form for Cursor/Codex) that closes each session cleanly: summarize, confirm tests, draft the commit, and flag half-done work that should not land yet.
GitHub MCP — issues, PRs, and CI from inside the session
GitHub's official MCP server: read and manage issues, pull requests, and workflow runs without leaving the agent session — the difference between 'draft me a PR description' and the agent actually opening the PR.
Supabase MCP — your database, schema, and logs
The official Supabase server: inspect schema, run queries, and read logs against your project — so backend debugging happens against the real database shape instead of guesses.
Playwright MCP — let the agent drive a real browser
Microsoft's Playwright server gives the agent a real browser: navigate, click, fill forms, and read the accessibility tree — which turns 'it should work' into 'I opened the page and it works'.
Filesystem MCP — scoped file access outside the repo
The reference filesystem server: read/write access confined to directories you list explicitly — the clean way to give an agent a docs folder or a data directory without handing over your home directory.
Linear MCP — plan against the real backlog
Linear's official server: read, create, and update issues from the session — so 'what should this task actually cover' is answered from the tracker, and finished work updates its own ticket.
Sentry MCP — debug from real errors, not guesses
Sentry's official server: pull real production errors, stack traces, and event context into the session — so a fix targets the actual failure and 'is it fixed' is checkable against the issue stream.
Figma Dev Mode MCP — build from the actual design
Figma's Dev Mode server (runs locally from the desktop app): the agent reads the selected frame's structure, variables, and components — so UI work starts from the real spec instead of a screenshot description.
Stripe MCP — billing questions answered from the source
Stripe's official server: query customers, subscriptions, and payments, and search Stripe's docs from the session — so billing integration work runs against real API state in test mode.
Context7 MCP — current library docs in context
Pulls version-accurate, current documentation for the library you're using into the session — the antidote to the model confidently writing against an API that changed two majors ago.
Notion MCP — specs and docs where they actually live
Notion's official server: read and update the workspace pages where your specs, decisions, and runbooks live — so the session frames work from the written source of truth.
Vercel MCP — deployments and logs in the loop
Vercel's official server: inspect deployments, read build/runtime logs, and check project state — so 'did the deploy actually work' is answered inside the session that shipped it.
Memory MCP — a knowledge graph that survives the session
The reference memory server: a local knowledge graph the agent can write facts to and recall across sessions — useful for a learner building a picture of a codebase or a domain over weeks.