Twelve general-purpose skills that encode ways of thinking (audit, debug, estimate, name, handoff, stress-test) — not file-format helpers. Same SKILL.md format works in Claude Code, Cursor, OpenAI Codex, and Claude.ai.
One folder per skill (name/SKILL.md). Copy them into the path your tool reads:
| Tool | Project path | Global path |
|---|---|---|
| Claude Code | .claude/skills/ |
~/.claude/skills/ |
| Cursor | .cursor/skills/ (also reads .claude/skills/ and .agents/skills/) |
~/.cursor/skills/ |
| Codex (GPT) | .codex/skills/ or .agents/skills/ |
~/.codex/skills/ / ~/.agents/skills/ |
| Claude.ai | Zip a folder → Customize → Skills | — |
# from this repo:
chmod +x scripts/install-skills.sh
./scripts/install-skills.sh claude /path/to/your-project
./scripts/install-skills.sh cursor /path/to/your-project
./scripts/install-skills.sh codex /path/to/your-project
./scripts/install-skills.sh agents /path/to/your-project # shared Cursor+Codex path
./scripts/install-skills.sh claude --global # → ~/.claude/skillsmkdir -p your-project/.claude/skills
cp -R assumption-audit socratic-debugger failure-forecast spec-compiler \
magnitude-check cognitive-load-review naming-forge api-breakage-scan \
skeptical-customer code-archaeology bus-factor-audit context-handoff \
your-project/.claude/skills/Invoke with /assumption-audit or natural language ("use the assumption-audit skill on this spec").
zip -r assumption-audit.skill assumption-audit
# Upload via Customize → Skills (archive root must be the skill folder)Extracts every assumption hiding in a plan, spec, or business idea — stated, implied, and inherited — scores each by impact-if-false × confidence, and designs the cheapest possible test for the dangerous ones.
Use it when: you're about to commit weeks of work to a plan; someone hands you a PRD; you catch yourself saying "this should work." Example: "Audit the assumptions in this migration plan before we start" → a ranked table of the guesses that could kill the project, each with a <1-day verification.
A rigorous premortem: simulates 5–7 concrete ways the project dies ("It is October. The project has failed. Here's what happened."), then converts each obituary into a dated tripwire, a prevention, and pre-committed kill criteria.
Use it when: starting any project, launch, migration, or hire — especially when you're excited and your plan has no risk section. Example: "Premortem my SaaS launch" → obituaries like "Death by silent launch," each with a "by March 15, if fewer than X signups → this is happening" tripwire.
Treats a vague request like source code: it either compiles into an unambiguous, testable Task Spec, or fails with named ambiguity errors ("unquantified quality: 'fast'"). Never silently guesses. Great for delegating to humans or to AI agents — an ambiguous prompt wastes an entire agent session.
Use it when: turning a Slack thread into a ticket; before a long agentic coding run; whenever "handle", "support", or "simple" appear in a requirement. Example: "Compile this feature idea into a spec" → a FROZEN spec with acceptance criteria, explicit out-of-scope list, and a decisions log — or a DRAFT with the 5 questions that must be answered first.
Fermi-estimation and reference-class sanity checking for any load-bearing number: market sizes, cost projections, "we'll reach 10k users", API bills, capacity plans. Rebuilds each number from two independent directions and flags anything 10x off.
Use it when: reviewing a business plan, budget, benchmark claim, or your own optimistic spreadsheet. Example: "Check the numbers in this pitch" → "Claimed 50k users year 1; top-down rebuild says 3k; the fantasy lives in the 10% conversion factor — the base rate is 0.5%."
Debugs by interrogation instead of guessed fixes: one question at a time, each designed to cut the hypothesis space in half and expose the wrong belief you don't know you hold. Keeps a visible eliminated/possible list. Has an escape hatch when you just want the answer.
Use it when: you've been stuck for hours; "this makes no sense"; the bug only happens on a device/env Claude can't see. Example: "Rubber-duck me, this API returns stale data only in prod" → "What did you literally see in the response headers, versus what you concluded?" ...and 4 questions later you find the CDN nobody remembered.
A completely different code-review lens: measures how much a reader must hold in working memory (>4 concurrent items = overload), counts comprehension jumps across files, and inventories "surprises" where code violates the expectations its own names set. Distinguishes intrinsic complexity (isolate it) from extraneous complexity (delete it).
Use it when: "will juniors understand this?"; a codebase feels exhausting; after any big refactor; designing an API other humans must learn.
Example: "Review this module for cognitive load" → "At line 87 the reader tracks 7 things; getUser mutates state (a lie with syntax highlighting); 3 renames under 15 minutes fix 60% of it."
Systematic name generation for products, features, functions, tables, and companies: defines the load the name must bear, generates along structured axes (literal / metaphor / coined / verb-honesty / specificity ladder), then kills candidates with stress tests — the grep test, the lie test, the sibling test, the collision sweep.
Use it when: "what should I call this?"; torn between names; a codebase where inconsistent naming causes confusion.
Example: "Name this function that creates the user if missing and returns it" → ensureUser (verb-honesty: ensure = idempotent create), with getOrCreateUser killed for namespace asymmetry.
Diffs two versions of any interface (REST, library API, JSON schema, CLI flags, webhook payloads) against a full breakage taxonomy — including the semantic breaks compilers never catch: unit changes, null-meaning shifts, enum expansion, default changes, error-contract changes. Built on Hyrum's Law: every observable behavior is depended on by somebody.
Use it when: releasing a version; "is this change breaking?"; any code review touching a public surface.
Example: "Scan this diff for breaking changes" → "Field shape unchanged, but duration moved from seconds to ms — silent, high blast radius, outranks your deleted endpoint (which at least fails loudly). Migration shim included."
Reviews any customer-facing artifact through the eyes of a specific, jaded, time-poor buyer looking for a reason to close the tab. Reports what they think the product is after 5 seconds (usually wrong), the exact element where they leave, a verbatim objection table in the buyer's voice, and rewrites of the 3 highest-impact elements.
Use it when: before any landing page, pitch, README, pricing page, or cold email ships; "why isn't this converting?" Example: "Review my pricing page as a skeptical buyer" → "Mira compares your €19/month to her paper notebook: €0. The belief that flips the verdict: 'no-shows cost me more than €19.' Your page never says it."
Reconstructs the buried history of a legacy codebase from git history, blame, scar-tissue commits ("hotfix", "revert"), ancient TODOs, and pinned dependencies. Produces a Dig Report: artifacts with recovered stories, landmines that look deletable but aren't, and a safe demolition list. Chesterton's Fence, industrialized.
Use it when: inheriting a codebase; onboarding; "why is this code like this?"; before deleting anything old and weird. Example: "Dig into this repo before I refactor the payments module" → "This weird retry loop = incident from commit a3f21 (2022 outage), no test covers it — live ordnance. These two files, however, are safe to demolish, and here's the evidence."
Measures knowledge concentration from git data (sole-author + high-churn + no-docs = critical) or via a 5-question interview when there's no repo. Outputs a risk map, the "invisible inventory" of knowledge living only in someone's head, and a cheapest-first remediation plan. Solo dev? It pivots to "future-you is the second developer."
Use it when: before vacations, handovers, reorgs; "what if X leaves?"; assessing project health. Example: "Run a bus factor audit on this repo" → "Bus factor: 1 (Elena, the billing engine). The 2-hour fix this week: her 'if I vanish' doc for the reconciliation job."
Generates a high-fidelity HANDOFF.md that preserves the 90% a normal summary drops: decisions with reasons, rejected paths (so nobody re-enters the dead end), unverified suspicions, tripwires learned ("if you see EACCES → it's the pnpm store"), and a literal first action so the resumer is productive in 2 minutes. Works for handing off to tomorrow-you, a teammate, or the next AI agent session.
Use it when: ending any substantial work session; context window filling up; delegating mid-task; going on leave.
Example: "Write a handoff, I'm stopping for today" → a 3-minute-read memo starting with "Resume here: run npm test -- --grep cache; the fix direction is in src/cache.ts:114."
These skills are designed to chain:
- New project:
assumption-audit→magnitude-check(on the numbers) →failure-forecast→spec-compiler(first milestone) → build. - Inherited codebase:
code-archaeology→bus-factor-audit→cognitive-load-reviewon the worst area. - Shipping a release:
api-breakage-scan→skeptical-customer(on the changelog/announcement) →context-handoff. - Stuck at 2am:
socratic-debugger, thencontext-handoffbefore you sleep so 9am-you doesn't start from zero.
- Every skill produces a fixed output template, so results are consistent and skimmable.
- Descriptions are written to trigger proactively (Claude tends to under-trigger skills; these push back).
- All are stack-agnostic and domain-agnostic — nothing here assumes a particular language, framework, or business.
- Each SKILL.md is self-contained (no bundled scripts to break), so they survive copy-paste anywhere.
MIT — see LICENSE.