cursor-kenji

Ready-made playbooks for your AI coding editor.
110 agent skills · 36 slash commands · 16 MCP servers · 12 Cursor skills · 6 subagents

You talk in plain English. The matching expert recipe runs itself.

Explain it like I'm five

Your AI editor is smart, but without a recipe it guesses. Sometimes that guess is great. Sometimes it invents a half-broken button and calls it done.

cursor-kenji is a big box of recipes (we call them skills). Install once. After that:

1. You type something normal — "check my security", "make this form nicer", "ship this feature".
2. Cursor picks the matching recipe.
3. The AI follows that recipe step by step, instead of freestyling.

You do not need to memorize skill names. Talking like a human is enough.

It ships 110 Cursor agent skills, 36 slash commands, and 6 subagents — tuned for React / Next.js / Supabase, useful on almost any stack. Works in Cursor, Claude Code, and (with a lighter install) Codex + Gemini CLI. Brand new? Read the plain-language guide →.

Install (30 seconds)

npx skills add kensaurus/cursor-kenji

Restart Cursor. Done.

No Cursor yet? Download it. No skills CLI? npm install -g skills, or see manual install.

What should I say? (use cases)

Full menu with every skill name → Every skill below.

The five toys in the box

Everything follows the Agent Skills spec and is checked on every commit (npm test covers all 122 installable skills). MCP templates pin exact versions against package-hallucination attacks.

How the recipes fit together (the loop)

You almost never run one skill alone. Think of a simple loop — look → change → prove → ship — with seatbelts on the whole time:

   Orient          Assess           Change           Prove            Ship
(get to know) → (measure first) → (build/fix) → (test for real) → (go live)
      │                                                                      │
      └──────────────────── findings loop back ←─────────────────────────────┘
                              ▲
                     Guardrails always on
              (rules · hooks · "are we actually done?")

Rule of thumb: assess before you change, prove before you ship, never skip a stage.

What's Inside

The whole kit, at a glance:

Every skill is listed below — first a family count table, then the full name + one-line summary for each. Trigger phrases → docs/CATALOG.md · quick lookup → docs/TRIGGER-CHEATSHEET.md.

Every skill, in plain English

Scroll the family counts, then the full list. You don't memorize names — describe the job in chat and Cursor matches. Want exact trigger phrases? docs/CATALOG.md.

Auto-generated from each skill's SKILL.md — run npm run gen:skill-index after adding a skill. 122 skills listed below.

Skill families at a glance

Full list (every skill)

🔍 Audit — look before you change (18)

📋 Plan — audit first, change only after you approve (17)

🎨 Enhance — improve what already exists (12)

✨ Design — build something new (10)

🧱 Backend — server & data patterns (5)

📱 Mobile — React Native / Capacitor (5)

📊 Data — charts & pipelines (2)

📚 Docs — write it down clearly (2)

🧹 Housekeeping — clean up design drift (1)

🔗 Workflows — multi-step recipes (17)

✅ Test & QA — prove it works (4)

🚀 Deploy — ship & verify (2)

🐛 Debug — find & fix what's broken (3)

🦟 Mushi Mushi — bug triage helpers (2)

🛡️ Protocols — session guardrails (1)

✍️ Authoring — build skills & MCP (2)

🤝 Third-party (upstream-maintained) (3)

🧩 Core & cross-cutting (4)

🖱️ Cursor IDE skills (12)

Quick Start

Pick whichever fits how you work. The first one covers most people.

npm installer modes:

npx @kensaurus/cursor-kenji            # merge — add/overwrite this repo's items (Cursor)
npx @kensaurus/cursor-kenji --auto     # detect installed tools and install to each
npx @kensaurus/cursor-kenji --claude   # install for Claude Code (~/.claude/) instead
npx @kensaurus/cursor-kenji --codex    # install for Codex CLI (~/.codex/AGENTS.md + prompts)
npx @kensaurus/cursor-kenji --gemini   # install for Gemini CLI (~/.gemini/GEMINI.md + commands)
npx @kensaurus/cursor-kenji --all      # install for all four supported tools in one run
npx @kensaurus/cursor-kenji --clean    # mirror ~/.cursor to match this repo (backup first)
npx @kensaurus/cursor-kenji --dry-run  # preview
npx @kensaurus/cursor-kenji --skill audit-ux   # single skill
npx @kensaurus/cursor-kenji --link     # dev: symlink for live skill authoring

Use more than one AI tool? Reach for --auto. It checks ~/.cursor, ~/.claude, ~/.codex, and ~/.gemini, then installs the right files to each one it finds. Running the bare command stays Cursor-only, so nothing changes for existing setups.

From a clone: npm run install:cursor · npm test validates skills + count + install smoke test.

Optional — Mushi Mushi bug-report triage + AI draft PRs (pairs with mushi-health, test-playwright):

npx skills add kensaurus/mushi-mushi

After install: (1) Restart Cursor (2) Copy mcp/mcp.json.template → ~/.cursor/mcp.json, fill YOUR_* keys (3) Describe any task — skills match on keywords.

Authoring skills? Each skill must pass Agent Skills spec validation (npm run validate:skills): name matches directory, description ≤ 1024 chars, body < 500 lines.

Claude Code

One-click, no clone needed (works on Windows too):

npx @kensaurus/cursor-kenji --claude   # Claude Code only
npx @kensaurus/cursor-kenji --all      # all four supported tools

All skills, commands, agents, and rules install to Claude Code (~/.claude/), with .mdc rules installed as .md. Skills appear as /slash-commands — type / inside any claude session.

From a clone, the bash installer does the same:

# Install for Claude Code only
./install.sh --claude

# Install for both Cursor and Claude Code (default)
./install.sh

# Inside Claude Code — use skills as slash commands
/workflow-build-feature
/debug-error the login endpoint returns 401
/plan-security-audit
/docs-writer

Skills are read from ~/.claude/skills/<name>/SKILL.md. No restart required when you re-run the installer — Claude Code picks up file changes at the start of each new session.

Codex CLI & Gemini CLI

Codex CLI and Gemini CLI don't have a skills system yet. Each reads a single global context file instead, so cursor-kenji maps to exactly what they load:

npx @kensaurus/cursor-kenji --codex    # Codex CLI
npx @kensaurus/cursor-kenji --gemini   # Gemini CLI

Your rules/ get merged into that one auto-loaded file (the skill-routing index is skipped, since nothing here would load it). Three standalone playbooks — plan, research, and fix-issue — ship as native prompts/commands. Skills and subagents aren't written out, because neither tool can load them, so they'd only be dead files. Any existing AGENTS.md or GEMINI.md is backed up as .bak-<stamp> first, and re-running the installer is always safe.

The bash install.sh --codex/--gemini delegates to the Node installer (needs Node ≥ 18) so the merge/port logic has a single source of truth.

Manual install

git clone https://github.com/kensaurus/cursor-kenji.git && cd cursor-kenji && ./install.sh

curl -sSL https://raw.githubusercontent.com/kensaurus/cursor-kenji/main/install.sh | bash

Keep fresh: npx skills add kensaurus/cursor-kenji or git pull && ./install.sh

Workflows

You rarely run just one skill. You chain them. The picture at the top (How the recipes fit together) is the whole idea — this section is the same loop with more detail.

Stage cheat-sheet

Specialist audits worth knowing:

• audit-realworld — full-stack feature parity
• audit-resilience — timeouts, retries, idempotency, PII (the stuff agents skip)
• audit-backend-architecture — which distributed pattern to adopt vs skip as over-engineering
• audit-payment-system — double-charge, ledgers, webhooks, PCI
• audit-ux-journeys — can users actually find things and finish their stories? (IA + task completion)

Start here, by situation

Find the row that sounds like your day, then follow the chain:

Bundled workflows

Say the phrase, and the whole sequence runs for you:

Plan loops (audit only — approve before execution)

These 17 plan-* skills come in grouped loops. Each one audits, then hands you a plan — nothing changes until you approve it. See docs/PLAN-LOOPS.md for diagrams, slash aliases (/uiux-plan, /capacitor-plan, …), and how each maps to execution.

One-shot (six-skill plan only):

Run the six-skill plan loop — no changes until I approve each phase:
plan-uiux-unification → plan-stub-checker → plan-test-coverage →
plan-perf-audit + plan-security-audit (parallel) → plan-docs-sync.

More copy-paste recipes (adopt repo, de-slop a page, pre-launch sweep, split PRs) → docs/CATALOG.md#skill-composition-patterns · New to Cursor? → docs/GETTING-STARTED.md

How to Use

Four kinds of building blocks, four ways to reach them:

Force a skill: "use enhance-web-ux on /dashboard"

Skill taxonomy

Every skill has two labels: a family (its <prefix>-<topic> name) and a lifecycle stage (from the loop above). The table below shows which stage each family lives in. For the full entries with trigger phrases, see docs/CATALOG.md.

housekeep-design (design-system consolidation) is the execution arm of plan-uiux-unification; it lives in the 🛠️ Change stage alongside enhance-*.

Third-party skills: prefixed thirdparty-* with ATTRIBUTION.md — do not add Kenji-specific sections to upstream bodies. Full guide → docs/THIRD-PARTY-SKILLS.md.

Note: Anthropic file-docx/pdf/pptx/xlsx skills are not in this public repo. Keep personal copies in ~/.cursor/skills/ if needed.

Cursor-specific skills (12): babysit, canvas, create-hook, create-rule, create-skill, split-to-prs, … — see CATALOG.md.

Commands (36)

Commands are shortcuts for the things you do constantly. Type / in chat to see them all.

RN monorepo bundle: copy commands/native-rn-monorepo/ + rules/native-rn-monorepo/ into your project (iOS builds on CI, not locally).

Subagents (6)

Subagents are focused helpers that peel off to handle one job and report back. Just mention what you need and the right one steps in.

Beyond the prompt itself, complete-everything leans on two safety nets: a packaged Cursor stop hook that auto-continues any unfinished work, and completion-judge, which independently rejects stale or premature "done" claims. On Claude Code 2.1.139+ you can kick off the same run with /goal (see the skill for details).

MCP servers (16)

MCP servers connect your editor to the outside world — your database, GitHub, a browser, and more. Copy a template and drop in your keys:

cp ~/cursor-kenji/mcp/mcp.json.template ~/.cursor/mcp.json      # essential 5
cp ~/cursor-kenji/mcp/mcp-full.json.template ~/.cursor/mcp.json  # all 16

Replace YOUR_* placeholders with real keys. Setup details → mcp/README.md

Project rules

Rules are always-on conventions your editor follows inside a project. Copy the starters into any repo:

cp ~/cursor-kenji/rules/project-starter/*.mdc your-project/.cursor/rules/

Global rules in this repo: full-stack-ship-discipline.mdc, composer-2.5-execution.mdc, skill-workflows.mdc.

Plan with a strong model, execute with Composer 2.5. The 17 plan-* skills are authored/reviewed with a stronger reasoning model; composer-2.5-execution.mdc constrains how approved plans are implemented.

Project constitution: copy docs/AGENTS.template.md to your app repo as AGENTS.md for always-on agent discipline.

Shell helpers

If you live in the terminal, these bash aliases speed up authoring and syncing:

source ~/cursor-kenji/shell-aliases/cursor-helpers.sh

Full definitions in shell-aliases/cursor-helpers.sh (clone-only; not in npm tarball).

Repository layout

Where everything lives:

cursor-kenji/
├── skills/           # 110 Agent Skills (SKILL.md each)
├── skills-cursor/    # 12 Cursor-specific skills
├── commands/         # 36 slash commands
├── agents/           # 6 subagents
├── hooks/            # opt-in completion stop gate
├── rules/            # Global + project-starter rules
├── mcp/              # MCP templates
├── docs/             # CATALOG, PLAN-LOOPS, GETTING-STARTED, …
├── notepads/         # Context templates (clone-only)
├── shell-aliases/    # Bash helpers (clone-only)
├── scripts/          # validate-skills, check-skill-count, install tests
└── bin/install.mjs   # npm installer

Design principles

A few opinions this project keeps coming back to — and what keeps them honest:

Contributing

Adding your own skill is two steps — write it, then let the checks confirm it's valid:

mkdir -p skills/my-skill && vim skills/my-skill/SKILL.md
npm run test   # validate + count + install smoke

See CONTRIBUTING.md, docs/README.md, docs/DISTRIBUTION.md, llms.txt, docs/CATALOG.md, docs/TRIGGER-CHEATSHEET.md.

FAQ

What is cursor-kenji?
A box of ready-made recipes for your AI editor (Agent Skills format) — plus slash commands, subagents, and MCP templates for Cursor. One command installs them into ~/.cursor/ and ~/.agents/skills/.

How do I install?
npx skills add kensaurus/cursor-kenji (recommended) or npx @kensaurus/cursor-kenji. Restart Cursor after install.

How many skills?
110 agent skills in skills/ plus 12 Cursor-specific skills in skills-cursor/ (122 total). Counts come from the filesystem and stay synced via npm run check:skills. See the family counts table.

How do skills trigger?
You talk normally. Cursor matches your words to each skill's YAML description. To force one: "use `audit-security` on this repo". Full trigger list: docs/CATALOG.md.

What's the difference between audit-* and plan-*?
audit-* looks around and may fix things. plan-* only writes a plan-{name}.md burndown — you approve each phase before any code changes. See docs/PLAN-LOOPS.md.

Where do MCP API keys go?
Copy mcp/mcp.json.template to ~/.cursor/mcp.json and fill YOUR_* placeholders — never commit real keys. See SECURITY.md and mcp/README.md.

Is there machine-readable docs for AI crawlers?
Yes — llms.txt at the repo root links to canonical docs surfaces.

Alternatives

Not quite what you're after? A few good neighbors:

• awesome-cursorrules — curated rules collections
• skills.sh — skills registry (npx skills add kensaurus/cursor-kenji)
• agentskills.io — Agent Skills spec + index
• npm · Cursor Marketplace · cursor.directory

cursor-kenji ships executable skills, MCP configs, commands, and subagents in one installable package — not static rules alone. Full listing status → docs/DISTRIBUTION.md.

Wanna code in the mountains?

Tired of the same desk, same coffee shop, same fluorescent lights?

Tsumagoi Work&Camp is a coworking camp at 1,444 m in Gunma, Japan — real fiber internet, ten camp sites, an open lounge, starlit campfires, and onsen towns (Kusatsu / Manza / Shima) down the road. Bring your laptop. Ship features from a highland ranch. Go for a walk when the build finishes.

→ Visit tsumagoi.kensaur.us — peek at the live ranch, sensors, and booking
_{Built with a stack a lot like what these skills are tuned for. Come say hi.}

Also by @kensaurus

Mushi Mushi — shake-to-report bugs, AI triage, optional draft PR. npx mushi-mushi · pairs with mushi-health, debug-sentry-monitor, test-playwright.

MIT License · Apache-2.0 portions noted in NOTICE
@kensaurus · Changelog · Discussions