jaequery-s-claude-skills-and-agents
My personal Claude Code arsenal, custom slash-command skills and a curated roster of 140+ specialist subagents, published as a single Claude
Open source Open in the app JSON README (API)
About
My personal Claude Code arsenal, custom slash-command skills and a curated roster of 140+ specialist subagents, published as a single Claude Code plugin marketplace. Built to turn Claude from a clever assistant into an opinionated team of domain experts.
Details
- Kind
- Plugins
- Topic
- No topic detected
- Publisher
- jaequery
- Origin
- marketplace
- Category
- ferramentas
- Last push
- 2026-05-28T02:20:31Z
- Repository state
- ativo
- Language
- Python
- License
- MIT
- Added
- 2026-08-30 01:48:58
- Updated
- 2026-08-30 01:48:58
- Origin id
jaequery/dot-claude/jaequery-s-claude-skills-and-agents
README
# dot-claude
My personal Claude Code arsenal — 21 custom slash-command skills published as a **Claude Code plugin marketplace**. Built to turn Claude from a clever assistant into an opinionated SOP runner: Paul Graham startup playbook, Deep Dive Analysis expert panel, next-feature tournament, evidence-gated code review, opinionated design/product taste critique, Shark Tank evaluation, git audit, SEO suite, market research, `/market` competitor + voice-of-customer pass, Reddit marketing, runtime debug-trace, `/finish` for shipping stuck 90%-done projects, `/narrate` for macOS text-to-speech summaries of Claude's responses with on-device personality rewrites (funny, serious, any tone — via Apple Intelligence), and more. The 161 specialist subagents live in the companion **[supabuild](https://github.com/jaequery/supabuild)** plugin.
## Install
This repo is a [Claude Code plugin marketplace](https://docs.claude.com/en/docs/claude-code/plugins). You install it from *inside* a Claude Code session — you do not `git clone` it.
### Prerequisites
- [Claude Code](https://docs.claude.com/en/docs/claude-code) installed and working (`claude --version`).
- Network access to GitHub from your Claude Code host.
### Steps
1. **Start Claude Code** in any directory: `claude`
2. **Add the marketplace:**
```
/plugin marketplace add jaequery/dot-claude
```
This registers the `jaequery` marketplace. It does *not* install anything yet.
3. **Install the plugin:**
```
/plugin install jaequery@jaequery
```
The syntax is `<plugin-name>@<marketplace-name>`. Both are `jaequery`.
4. **Verify:** type `/` and look for entries under `jaequery:*`. You should see `/jaequery:dda`, `/jaequery:shark-tank`, `/jaequery:code-review`, etc.
### Using it after install
Type the slash command, e.g. `/jaequery:shark-tank`, `/jaequery:code-review`, `/jaequery:seo audit https://example.com`. See the [Skill Guides](#skill-guides) below for every skill.
> **Pair with [`jaequery/supabuild`](https://github.com/jaequery/supabuild).** Several skills here (`/dda`, `/next-feature`, `/shark-tank`, `/code-review`) dispatch specialist subagents by name — Reality Checker, Code Reviewer, Brand Guardian, Sales Coach, etc. Those agents (161 of them) live in the supabuild plugin along with the multi-agent build / design-variants / Linear-burndown skills. Install both for the full experience:
>
> ```
> /plugin marketplace add jaequery/supabuild
> /plugin install supabuild@supabuild
> ```
### Updating
```
/plugin marketplace update jaequery
```
Fetches the latest skills and agents from this repo.
### Uninstall
```
/plugin uninstall jaequery@jaequery
/plugin marketplace remove jaequery
```
### Troubleshooting
- **`/plugin` command not found** — your Claude Code version is too old; update it.
- **Skills don't show up after install** — restart the Claude Code session so it re-scans plugins.
- **`marketplace add` fails on network error** — check you can reach `github.com` (the marketplace is served from this repo's default branch).
---
## Why this exists
Out-of-the-box Claude is a generalist. Real work needs codified workflows — a Shark Tank investor panel that grades your project, a tournament that picks your next feature, a Paul Graham–style pressure test before you build the wrong thing, a deep-dive analysis that pits experts against each other. This repo wires that in as slash commands you can invoke on demand. The specialist personas they dispatch live in the companion [supabuild](https://github.com/jaequery/supabuild) plugin.
---
## Custom Skills — quick index
Invoke any of these from the Claude Code prompt. Each one is a self-contained SOP — no setup required. See [Skill Guides](#skill-guides) below for the deep dive on each.
### Decision & review
- [`/next-feature`](#next-feature) — Pick the single best next feature to ship (tournament-judged).
- [`/dda`](#dda--deep-dive-analysis) — Deep Dive Analysis: expert panel scores a plan 0–10, separate Master Brain subagent issues a verdict.
- [`/code-review`](#code-review) — Evidence-gated review across Simple / Performant / Clean / Secure / Testable.
- [`/code-audit`](#code-audit) — 14-way code-level quality audit (organization, complexity, redundancy, security, performance).
- [`/taste`](#taste) — Opinionated design and product taste critique. Names generic AI-design tells; references taste-makers by name.
- [`/shark-tank`](#shark-tank) — Evaluate the current project as a Shark Tank episode.
- [`/git-audit`](#git-audit) — 13-way repo health and team-dynamics audit.
- [`/finish`](#finish) — Ship a stuck "90% done" side project. Names the avoidance pattern, cuts scope, picks a launch date, drafts the announcement.
### Startup playbooks (Paul Graham framework)
A sequenced, zero-to-one operating system:
1. [`/startup-pressure-test-idea`](#startup-pressure-test-idea)
2. [`/startup-validate-problem`](#startup-validate-problem)
3. [`/startup-map-competition`](#startup-map-competition)
4. [`/startup-build-mvp`](#startup-build-mvp)
5. [`/startup-find-customers`](#startup-find-customers)
6. [`/startup-growth-strategy`](#startup-growth-strategy)
### Marketing & growth
- [`/seo`](#seo) — Full SEO suite (audit, page, schema, GEO, plan).
- [`/market-research`](#market-research) — Keyword opportunities from real demand signals.
- [`/market`](#market) — Two-stage market intelligence: 5–7 competitor table + Reddit voice-of-customer.
- [`/marketing-reddit`](#marketing-reddit) — Find Reddit posts, leave comments, create threads.
### Utilities
- [`/cmux-diff`](#cmux-diff) — Sidebar diff viewer for the current repo.
- [`/debug-trace`](#debug-trace) — Cursor-style AI debug mode: injects fire-and-forget HTTP probes into source, captures runtime values via a local daemon, removes every probe before exit.
- [`/narrate`](#narrate) — macOS text-to-speech: reads a short summary of each completed turn aloud, optionally rewritten in a personality (funny/serious/any tone) by the on-device Apple model. Opt-in, self-installs a `Stop` hook into your own settings (macOS only).
---
## Skill Guides
### `/next-feature`
**What it does.** Plans the single most useful next feature for the current project by running a tournament of rival feature proposals.
**When to use.** When you want a grounded, judged decision on *what to ship next* — not a brainstorm list or a feature parade.
**How to invoke.** `/next-feature` from inside the project, or *"what should I build next"*, *"pick my next feature"*, *"plan the next feature"*. One clarifying question max about goal/audience.
**What you get.** Tournament bracket → each team's feature submission → weighted scoring table → one winner with a 9-point plan (name, description, strategic case, user story, scope, effort, risks, success metric, implementation sketch) → runner-up salvage → next actions.
**How it works.** Auto-scans `README`, `CLAUDE.md`, manifest, `git log`, `git shortlog`, and roadmap files. Fields 2–4 strategy-lensed teams (e.g. "User Value", "Growth", "Foundation", "Quick Win"). Runs the full tournament playbook with an independent eval gate — and refuses to ship a weak winner (reruns once or escalates).
**Example.**
```
/next-feature
```
*Run inside a year-old side project — the tournament fields "Retention", "Growth", and "Foundation" teams, then ships a single 9-point plan for the winner: "Weekly progress email with one-click streak recovery."*
---
### `/dda` — Deep Dive Analysis
**What it does.** Auto-assembles a 3–6 agent expert panel from the roster, scores your plan on a 0–10 anchored rubric across six metrics, then a **separate Master Brain subagent** (dispatched fresh, sees only the panel output) issues a GREEN / YELLOW / RED verdict with kill criteria.
**When to use.** You have a plan, spec, strategy, or pitch and want advisory-board-quality review in one command.
**How to invoke.** `/dda <plan>`, or paste a plan / pass a file path / point at prior discussion, then trigger with *"deep dive analysis"*, *"deep dive this plan"*, *"multi-agent expert review"*. One clarifying question allowed if ambiguous.
**What you get.** Panel roster (with rejected candidates and coverage gaps) → score matrix (6 metrics × agents, with means and spreads) → consensus strengths, risks, surfaced disagreements, open questions, must/should/nice edits → optional rebuttal round when panelists materially disagree → **Master Brain Verdict** (GREEN / YELLOW / RED) → **Top Risk-Flips** (HIGH→MED with effort + proof). Each run appends to `~/.claude/dda-calls.jsonl` for future calibration.
**How it works.** Orchestrator picks domain-fit subagents and *always* includes an adversarial voice (Reality Checker, Code Reviewer, Compliance Auditor, etc.) to prevent groupthink. Panel dispatches in parallel with a strict structured output contract that's schema-validated before aggregation (malformed panelists are re-dispatched once, missing cells marked `N/A` not zero). The Master Brain runs as its own subagent dispatch and never sees the Orchestrator's distillation or selection rationale — separating jury from judge.
**Example.**
```
/dda review this Q2 GTM plan: <paste plan>
```
*Panel assembles a GTM strategist, a CFO-style skeptic, a sales engineer, and Reality Checker. Master Brain returns a **YELLOW** verdict with three kill criteria and a Path-to-10 upgrade ladder.*
---
### `/code-review`
**What it does.** Surgical, evidence-gated code review across five dimensions — **Simple, Performant, Clean, Secure, Testable** — with a hard evidence gate that auto-downgrades speculation to `[needs-verification]`.
**When to use.** You want a rigorous, grounded review of a diff, PR, file, branch, or pasted snippet — one that distinguishes real findings from hand-waving.
**How to invoke.** `/code-review [target]`, or *"review this code"*, *"review my PR"*, *"audit these changes"*, *"security review"*, *"performance review"*, or simply paste a diff. Target auto-resolves via `gh pr`, staged diff, branch-vs-main, `git status`, or `HEAD`.
**What you get.** Quick Summary + verdict (APPROVE / APPROVE-WITH-NITS / REQUEST-CHANGES / BLOCK) → Dimension Coverage table → Findings with `path:line` evidence and severity → Expert-Review-Recommended table → Not-Reviewed list → cost footer.
**How it works.** Runs 77 grep-level checks, executes the project's own test / lint / typecheck commands (classifying infra-SKIP vs genuine-FAIL), caps nits at 10, and refuses to cite a finding without `path:line` evidence.
**Example.**
```
/code-review 247
```
*Resolves PR #247 via `gh pr`, runs the repo's own test + lint + typecheck, and returns a **REQUEST-CHANGES** verdict citing a SQL injection at `api/search.ts:84` and a missing index flagged as `[needs-verification]`.*
---
### `/code-audit`
**What it does.** Dashboard-style audit of a codebase at the code level — organization, complexity, redundancy, security, performance, design, dependency hygiene, and test coverage. Complements `/code-review` (diff-level, evidence-gated) and `/git-audit` (history-level).
**When to use.** You want a high-level signal read on code quality across the whole tree, not a focused diff review.
**How to invoke.** `/code-audit [path]`, or *"audit this code"*, *"code quality audit"*, *"codebase quality"*. Defaults to cwd.
**What you get.** Sectioned report covering footprint, file/function size outliers, duplication, debt markers, complexity, security smells, error handling, performance smells, dependency hygiene, test ratio, coupling/import hotspots, and naming hygiene → summary dashboard table (OK / WARN / CONCERN) → top findings with `path:line` → 3–5 prioritized recommendations.
**How it works.** Runs ~14 static analyses (grep / awk / wc patterns plus opportunistic `npm outdated` / `pip list --outdated` / `go list -m -u all`) over `git ls-files`, applies fixed thresholds (e.g. file >1000 LOC = CONCERN, test/source ratio <10% = CONCERN, any genuine secret hit = CONCERN). Read-only — never edits code.
**Example.**
```
/code-audit
```
*Surfaces `src/api/handlers.ts` at 1,243 LOC (CONCERN), 187 TODO/FIXME markers (CONCERN), 6 `await`-in-loop patterns, an empty `catch` in `src/payments/charge.ts:84`, and a 7% test/source ratio — verdict: refactor handlers, raise test floor before next feature.*
---
### `/taste`
**What it does.** Opinionated design and product taste critique. Judges a URL, screenshot, codebase, pasted UI code, or product decision against a high bar set by Linear, Stripe, Things, Arc, Raycast, Superhuman, Mercury, and Apple — and calls out generic AI-design tells by name.
**When to use.** You want a decisive read on whether something is tasteful or generic — not a balanced rubric, not committee feedback. Pair with `/shark-tank` (investor lens) and `/code-review` (engineering lens) for a full read.
**How to invoke.** `/taste [target]`, or *"is this tasteful"*, *"is this generic"*, *"make it less generic"*, *"elevate this"*, *"what would Linear do"*, *"give me taste feedback"*. Target can be a URL, a screenshot path, pasted UI code, a product decision in plain English, or no target (defaults to the current project).
**What you get.** A one-line verdict (TASTEFUL / COMPETENT / GENERIC / HOSTILE / CONFUSED) → The Tells (specific observations with evidence, anti-patterns named) → The Cuts (what to remove — subtraction first) → The Steals (real products that solved this well, by name and by specific decision) → The Lift (3–5 concrete changes ranked by impact) → The One Thing (single highest-leverage change) → Would I use it? (Yes/No, no hedging).
**How it works.** Detects input type and gathers just enough context (no over-research — taste is fast). Runs a named anti-pattern scan covering visual tells (centered-Tailwind-UI hero, glassmorphism overuse, generic gradients, 3×2 feature card grid, "Trusted by" logo theater, rounded-2xl everything), copy tells ("The platform for modern teams", "Effortlessly", "AI-powered", apology microcopy), interaction tells (cookie banner the size of a 747, smooth-scroll hijacking, parallax for the sake of parallax), and product anti-patterns (parity features, settings as design escape valve, "Pro" tiers with 11 "unlimited" bullets). References taste-makers by specific decision, never just by brand. No diplomacy theater, no hedged "could potentially," no "modernize the design" advice.
**Example.**
```
/taste https://acme.com
```
*Verdict: **GENERIC**. The Tells: Tailwind UI centered-hero template, pink-to-purple gradient doing nothing, six-card 3×2 feature grid, 14px Inter body on 1440px, "The modern platform for high-performing teams" tagline. The Cuts: kill the "Book a demo" CTA, replace the feature grid with one product screenshot and a paragraph, delete the gradient. The Steals: Linear's pricing page hierarchy (three plans, one paragraph each); Mercury's editorial typography on a B2B site; Vercel's monospaced numerals. The One Thing: cut the second CTA. Would I use it? Not unless you fix the hero in the next 48 hours.*
---
### `/shark-tank`
**What it does.** Evaluates the current project as a dramatic Shark Tank episode — pitch, Shark reactions, scorecard, verdict.
**When to use.** You want an entertaining-but-honest investor-framed evaluation of your project across problem, product, tech, traction, business model, moat, and team signal. No curve grading.
**How to invoke.** `/shark-tank`, or *"rate this project"*, *"would you invest"*, *"shark tank"*.
**What you get.** A full scripted episode — narrator intro → in-character founder pitch → Shark dialogue → scorecard (7 categories × /10, total /70) → The Good / Concerns / Hard Questions → per-Shark IN/OUT verdicts and The Deal.
**How it works.** Auto-scans `README`, manifest files, `git log -20`, `git shortlog`, top-level dirs, and the landing page/entry point. Plays all roles (narrator + founder + three distinct Shark personas). All claims must be grounded in observed code / docs / git history.
**Example.**
```
/shark-tank
```
*Scans the repo, pitches a side-project-to-SaaS story, Mr. Wonderful tears into the missing revenue model, Cuban sees scale potential, Greiner offers $50K for 20% — ends with The Deal and a 38/70 scorecard.*
---
### `/git-audit`
**What it does.** Dashboard-style health and team-dynamics audit of a git repository — the things `git log` won't tell you at a glance.
**When to use.** You want a high-level signal read on repo risk, ownership, bug clusters, velocity, and test discipline.
**How to invoke.** `/git-audit [path]`, or *"audit this repo"*, *"repo health"*, *"codebase audit"*, *"git analysis"*. Defaults to cwd.
**What you get.** Sectioned report covering churn hotspots, bus factor, bug clusters, velocity, stale files, and more → summary dashboard table (OK / WARN / CONCERN) → 3–5 prioritized recommendations.
**How it works.** Runs 13 specific `git log` / `shortlog` / `for-each-ref` analyses in parallel and applies fixed thresholds (e.g. bus factor CONCERN if top contributor >60%, test ratio CONCERN if <10%).
**Example.**
```
/git-audit
```
*Surfaces that one dev owns 72% of `src/billing/*` (CONCERN), test ratio dropped to 6% last quarter (CONCERN), three files haven't been touched in 14 months, and Friday-night deploys correlate with bug fix commits.*
---
### `/finish`
**What it does.** Pushes a stuck "90% done" side project across the finish line. Audits the actual state of the repo, names the *avoidance pattern* keeping it stalled (by name, like `/taste` does for generic design tells), brutally cuts scope to a minimum viable launch, walks a non-skippable "boring 10%" checklist, picks a launch date (not asks — picks), builds a day-by-day ship plan, and drafts the Day-1 launch post.
**When to use.** You have a project that's been "almost done" for weeks or months. The fun part is built; the unglamorous part (deploy, domain, landing copy, payment, signup, legal) isn't started. You can't tell whether it's procrastination, perfectionism, or scope creep — and you need someone to call it.
**How to invoke.** `/finish` from inside the stalled project, or *"help me finish this project"*, *"ship this"*, *"launch this"*, *"I can't finish"*, *"stuck at 90%"*, *"this project has been sitting forever"*. If you mention multiple stalled projects, picks one and ignores the others — trying to ship five at once is how zero ship.
**What you get.** Reality Check (what's actually built vs. what the user thinks) → **The Avoidance Pattern** — named (Boring 10% Avoidance, Perfectionism on a Pre-User Product, Scope-Creep-as-Procrastination, The Soft Launch Trap, Refactor-Before-Launch, Building the Tool to Build the Tool, Fear-of-Judgment-as-Polish, Domain-Bought–Nothing-Deployed, etc.) with evidence from your commits and TODOs → Minimum Viable Launch definition + "what gets cut" → Boring 10% status table (deploy, domain, HTTPS, signup, payment, privacy policy, launch post, friends list, analytics) → **Launch Date** (picked, not asked — usually 7 days out, 14 if genuinely needed) → day-by-day Ship Plan → **drafted launch post** (Show HN / Product Hunt / r/X / tweet — real text, not "write a launch post") → The One Thing for today → Day +1 plan.
**How it works.** Scans `README`, `git log`, last commit date, `git shortlog`, manifest, top-level dirs, TODO/FIXME markers, deployed URL, signup/payment routes, legal pages, and CI config. Diagnoses the avoidance pattern from a named catalog rather than handing back a generic checklist. Refuses "but I need —" objections in advance by pre-empting them in the scope cut. Drafts the actual launch announcement instead of asking the user to write it — half the avoidance is staring at a blank text box.
**Example.**
```
/finish
```
*Run inside a 4-month-old side project. Diagnosis: **Boring 10% Avoidance** — the dashboard component has been refactored twice this month, but `/signup` 500s because `STRIPE_SECRET_KEY` isn't in Vercel and there's no privacy policy. Launch date: **Tuesday, May 19**. The One Thing today: get signup → confirmation email → first-run screen working end-to-end. Drafts a 4-sentence Show HN post ready to publish on launch morning.*
---
### `/startup-pressure-test-idea`
**What it does.** YC-application-style brutal evaluation of a startup idea — finds every fatal flaw before you waste a week building.
**When to use.** Very early stage — you have an idea and want honest red-team analysis before investing time.
**How to invoke.** `/startup-pressure-test-idea`, or *"pressure test my idea"*, *"evaluate my startup idea"*, *"is this a good startup idea"*. Asks for the idea (what / who / how it makes money) if not supplied.
**What you get.** Core Assumption (falsifiable) + a $0, <1-week validation step → three mechanism-specific Fatal Flaws ranked by severity → Problem Validation (Painkiller / Vitamin / Placebo + current workaround + willingness to pay) → Founder-Market Fit read → **Brutal Verdict** (STRONG / WEAK / PIVOT REQUIRED) + "if I had to bet" one-liner.
**How it works.** PG YC-review framing. Refuses generic advice — every flaw must be specific to *this* idea. Verdict is direct: never "it has potential but."
**Example.**
```
/startup-pressure-test-idea an AI SOAP-note generator for solo therapists — $79/mo subscription
```
*Returns three fatal flaws specific to this idea (HIPAA BAA costs, insurance-coded note formats, therapist trust in AI for mental health) and a **WEAK** verdict with a $0 validation step.*
---
### `/startup-validate-problem`
**What it does.** Validates whether the problem is real and paid-for using Paul Graham's "talk to users" framework.
**When to use.** After the idea exists, before building — you need a customer-discovery plan and a verdict on problem realness.
**How to invoke.** `/startup-validate-problem`, or *"validate my problem"*, *"is this a real problem"*, *"customer discovery"*. Asks for idea + target customer if missing.
**What you get.** Specific Pain (trigger moment, frequency, cost, "in their words") → Early Adopter Profile (a specific person, where to find 10 this week, what they've tried) → 5 Mom-Test discovery questions + what each reveals + banned questions → Validation Criteria (green lights, red flags, minimum bar) → **Verdict**: Painkiller / Vitamin / Placebo + current-workaround test.
**How it works.** Applies *The Mom Test* — no pitching, no hypotheticals, no leading questions. Enforces daily/weekly problems only, early adopter must be a specific person (not a segment), and the user's words must sound like a human, not a pitch deck.
**Example.**
```
/startup-validate-problem idea: AI SOAP notes; customer: solo therapists in private practice
```
*Outputs 5 Mom-Test discovery questions, where to find 10 therapists this week, and a **Painkiller** verdict because every therapist currently burns 30 min after each session writing by hand.*
---
### `/startup-map-competition`
**What it does.** Maps every real competitor — including the invisible ones most founders miss, especially current behavior / inertia.
**When to use.** You need a comprehensive competitive picture, especially to surface the status-quo behavior that is the real competitor.
**How to invoke.** `/startup-map-competition`, or *"map my competition"*, *"competitive analysis"*, *"who are my competitors"*. Asks for idea + target customer if missing.
**What you get.** Current Behavior breakdown (competitor #1) → Direct Competitors table (strength / weakness / awareness / switching cost) → Indirect Competitors table → The Real Enemy (the specific habit / inertia to defeat) → Genuine Differentiation reality-check → competitive verdict (Empty / Emerging / Crowded / Graveyard) + opening.
**How it works.** PG "what are people doing now" framing. Enforces: *"we have no competition"* = always wrong; *"we have AI"* = not differentiation in 2026. Rates each competitor on awareness + switching cost + satisfaction.
**Example.**
```
/startup-map-competition idea: AI SOAP notes; customer: solo therapists
```
*Surfaces Upheal and Mentalyc as direct competitors, SimplePractice's built-in notes as indirect, and "therapists writing by hand during sessions" as The Real Enemy — verdict: **Emerging, narrow opening around insurance-coded formats.***
---
### `/startup-build-mvp`
**What it does.** Designs the smallest MVP that tests one falsifiable core assumption in two weeks.
**When to use.** You have an idea and need a ruthless cut-down MVP scoped to testing a single assumption with real users.
**How to invoke.** `/startup-build-mvp`, or *"design my mvp"*, *"what should I build first"*, *"minimum viable product"*. Asks for idea + core assumption if either is missing.
**What you get.** Core Assumption (falsifiable) → Minimum Feature Set table (3–5 features max) → What Gets Cut table → behavioral Test Criteria (validated / invalidated thresholds + non-valid signals + sample size) → Week 1 Build / Week 2 Launch day-by-day plan → post-test branching (validated / invalidated / ambiguous).
**How it works.** PG "build something people want" framing. Enforces: MVP tests *one* assumption — never two; every non-test feature gets cut; test criteria must be behavioral, not opinion; launch week must end with real users generating signal.
**Example.**
```
/startup-build-mvp idea: AI SOAP notes; assumption: therapists will paste a session transcript and trust the output enough to ship it to their EHR
```
*Cuts scope to 3 features (transcript upload, SOAP generator, copy-to-clipboard), sets "70% of users ship without edits" as the validated threshold, and plans a day-by-day 2-week launch.*
---
### `/startup-find-customers`
**What it does.** Builds a manual plan to acquire the first 10 real customers using "do things that don't scale."
**When to use.** You need a non-automated, channel-specific plan to locate, message, and convert your first 10 users.
**How to invoke.** `/startup-find-customers`, or *"find my first customers"*, *"first 10 users"*, *"early traction plan"*. Asks for idea + target customer if missing.
**What you get.** Table of exact channels / locations with estimates → per-channel manual outreach approach → actual first-message templates (<100 words) → Devastation Test success criteria + politeness-signal red flags → 4-week milestone plan (Research → First Conversations → First Users → PMF Signal).
**How it works.** Rules enforce specificity ("Reddit" isn't; "r/SaaS" is), manual-only (no ads, no automation), and asking for a conversation — never a sale. Templates come with `[bracket]` personalization points.
**Example.**
```
/startup-find-customers idea: AI SOAP notes; customer: solo therapists in private practice
```
*Channel table points to r/therapists, Psychology Today directory scraping, and ADAA conferences. Hands back a 72-word first-message template and a 4-week milestone plan: Research → First Conversations → First Users → PMF Signal.*
---
### `/startup-growth-strategy`
**What it does.** Designs a compounding growth engine rooted in product-driven word of mouth.
**When to use.** You have users and need a 90-day plan to reach 1,000 with a natural growth loop and disciplined channel selection.
**How to invoke.** `/startup-growth-strategy`, or *"growth plan"*, *"how do I grow"*, *"acquisition strategy"*. Asks for idea + current user count + target customer if missing.
**What you get.** Natural Growth Loop (type, speed, strength %) → Top 3 Acquisition Channels (with CAC, time-to-results, 1-week test) → Referral Mechanism (built-in, not bolted on) → 90-day week-by-week plan (Foundation / Amplify / Compound) → The Single Metric (leading, not lagging) + "if you stopped marketing today" test.
**How it works.** PG "make something people want and tell their friends" framing. Enforces: retention <40% weekly → fix retention first; content marketing / SEO aren't strategies; a referral program is a bribe, not a referral.
**Example.**
```
/startup-growth-strategy idea: AI SOAP notes; users: 47; target: solo therapists
```
*Identifies a "your therapist colleague asks what tool you use" word-of-mouth loop, picks r/therapists + Psychology Today + conference sponsorships as the top 3 channels, and lays out a 90-day week-by-week plan to 1,000 users.*
---
### `/seo`
**What it does.** Universal SEO analysis — audits, page/tech/content/schema/images/sitemap reviews, Generative Engine Optimization for AI Overviews / ChatGPT / Perplexity, and strategic planning.
**When to use.** Any SEO work on a URL or site: full audit, page-level review, schema generation, AI-search readiness, or strategic planning by industry.
**How to invoke.** Subcommand + URL or business type:
- `/seo audit <url>` — full site audit
- `/seo page <url>` — single-page deep dive
- `/seo schema <url>` — detect / validate / generate structured data
- `/seo geo <url>` — AI Overviews / ChatGPT / Perplexity readiness
- `/seo plan <business-type>` — strategic SEO roadmap
Also fires on *"SEO"*, *"Core Web Vitals"*, *"E-E-A-T"*, *"AI Overviews"*, *"technical SEO"*, *"structured data"*.
**What you get.** Unified report with SEO Health Score (0–100, weighted across 7 categories) → industry detection → prioritized action plan (Critical → Low) → subcommand-specific deliverables (sitemap, schema markup, competitor pages, hreflang tags).
**How it works.** Orchestrates 12 sub-skills + 6 subagents (`seo-technical`, `seo-content`, `seo-schema`, `seo-sitemap`, `seo-performance`, `seo-visual`) in parallel. Enforces quality gates (hard stop at 50+ location pages, ban on HowTo schema post-deprecation, use INP not FID). Reference files load on-demand.
**Example.**
```
/seo audit https://acme.com
```
*Full audit returns a **62/100** SEO Health Score, industry detected as SaaS, three Critical issues (missing hreflang, INP > 500ms on pricing, duplicate H1s), plus a prioritized 14-item action plan.*
---
### `/market-research`
**What it does.** Scrapes free demand signals across multiple sources and ranks keyword opportunities for content and SEO.
**When to use.** You want keyword opportunities, article ideas, or demand signal around a topic for US / T1 audiences — grounded in real search data, not guesses.
**How to invoke.** *"market research"*, *"keyword research"*, *"find keywords"*, *"article ideas"*. Pass seeds via `--only "topic1, topic2"` — your phrases are used verbatim with no suffixes. Defaults to built-in seeds if none given.
**What you get.** Raw + scored JSON files dated in the skill directory → top-50 console dump → a final markdown report with Top 10 opportunities table, per-keyword content strategy, quick wins, cluster strategy, seasonality notes, and priority ranking.
**How it works.** Runs `node keyword-research.js` which scrapes Google Autocomplete (with a–z expansion), YouTube Autocomplete, Google Related Searches HTML, Reddit post titles, and Google Trends. Cross-source count is the core demand signal.
**Example.**
```
market research --only "home espresso machine, pour over coffee setup"
```
*Scrapes all five sources and returns a Top 10 opportunities table — "jura espresso machine settings" scores **9.2** (high demand + low competition) with a recommended article cluster and seasonality note.*
---
### `/market`
**What it does.** Two-stage market intelligence pass for a product idea: a grounded 5–7 row competitor table (Direct / Indirect / Substitute) plus a Reddit voice-of-customer mine that surfaces real pain, demand signals, and the exact words customers use.
**When to use.** Before building or repositioning, when you need to understand the *space* — who else is in it, what the current behavior is, and what customers actually complain about and ask for. Distinct from `/market-research` (keyword scraper) and `/marketing-reddit` (Reddit posting).
**How to invoke.** `/market`, or `/market <one-line product description>`, or *"competitor map"*, *"competitive landscape"*, *"voice of customer"*, *"reddit sentiment"*, *"customer language"*, *"market intelligence"*. Asks for `[target audience] + [problem or goal] + [product or approach]` if missing.
**What you get.** One-line restatement of the product → **Stage 1** markdown table (5–7 rows × Competitor / Type / Key Offering / Strengths / Weaknesses / How We're Different — with a mandatory Substitute row for current behavior) → **Stage 2** Reddit synthesis from 3–5 specific subreddits: top pain points with verbatim quotes + permalinks, explicit demand signals, an 8–15 phrase customer language glossary (split into pain terms vs. outcome terms), current alternatives & complaints, and a sentiment summary → final **Market Read** (crowdedness verdict, most underserved pain, landing-page phrase candidate, wedge competitor, biggest red flag, one concrete next move).
**How it works.** Stage 1 uses WebSearch + WebFetch to verify competitors exist before listing them — no fabricated companies. Stage 2 hits Reddit's public JSON API via `curl` (top.json + search.json + comments.json) for real posts and quotes, with WebSearch fallback if blocked. Hard rules: no fabricated quotes, every quote has a permalink, the Substitute row is mandatory (current behavior is always a competitor), and "we have AI" is never accepted as differentiation.
**Example.**
```
/market I'm building a SOAP-note tool for solo therapists that drafts notes from session audio
```
*Stage 1 surfaces Mentalyc, Upheal, and SimplePractice's built-in notes as Direct, a generic AI scribe used off-label as Indirect, and "therapists writing by hand during sessions" as the mandatory Substitute. Stage 2 mines r/therapists and r/psychotherapy, pulls 6 verbatim complaints about Mentalyc missing EMDR session structure (with permalinks), and surfaces the phrase "I want my evenings back" as the landing-page candidate. Market Read: **Emerging**, wedge is insurance-coded note formats.*
---
### `/marketing-reddit`
**What it does.** Finds relevant Reddit posts, comments on them, or creates new threads — human-sounding and channel-tailored.
**When to use.** You want to search Reddit authentically, leave tailored comments on matched or URL-given posts, or create a new thread in a specific subreddit. Built for real engagement, not spam.
**How to invoke.** Natural language — *"find reddit posts about X"*, *"comment on this reddit URL"*, *"post to r/SaaS with title ..."*. Triggers include *"reddit find/search/reply/comment"*, *"post on reddit"*, *"create reddit post"*, *"submit to reddit"*, or a Reddit URL with a comment request.
**What you get.** Ranked posts list (score, comments, date, author, permalink) → posted-comments summary table with URLs → created-thread summary table with the new post URL.
**How it works.** Uses `curl` / `urllib` against Reddit's public JSON search API (last-3-days filter) for search, then **Playwright MCP** (`browser_run_code` with stable locators on the Lexical composer) for comments and threads. Enforces strict human style: no em dashes, no sycophancy, no all-lowercase-AI voice.
**Example.**
```
find reddit posts about notion alternatives in the last 3 days and draft comments
```
*Returns 12 ranked posts across r/Notion, r/productivity, and r/selfhosted, then drafts a human-voice 2-sentence comment for each — no dashes, no "great question," no AI tells.*
---
### `/cmux-diff`
**What it does.** Launches a VSCode-style sidebar changes/diff viewer for the current working directory.
**When to use.** You want a browser-based sidebar UI to scan changed files and diffs instead of reading `git diff` in the terminal.
**How to invoke.** `/cmux-diff`, or *"show changes"*, *"changes panel"*, *"diff viewer"*. Operates on `$PWD`.
**What you get.** A background-running local web server (port auto-detected) opened in the cmux browser. Log at `$XDG_STATE_HOME/cmux-diff/`.
**How it works.** Bash-only skill. Ensures `~/Scripts/cmux-diff` has `bun` deps installed, spawns `bun run src/cli.ts --dry-run` in the background, scrapes the port from the log, and calls `cmux browser open`.
**Example.**
```
/cmux-diff
```
*Spawns the local server, scrapes port 48291 from the log, and opens the sidebar changes panel in the cmux browser — ready to click through files without leaving the terminal.*
---
### `/debug-trace`
**What it does.** Cursor-style runtime instrumentation debugger. Spins up a tiny localhost daemon, injects fire-and-forget HTTP probes into the user's source at suspect sites, captures runtime values as the program runs, reads them back through the daemon, iterates toward a fix, and **removes every probe before exiting**. Print-debugging on autopilot, with cleanup as a hard invariant.
**When to use.** A bug whose cause is opaque from reading the code — you need to see actual runtime values at specific points without manually scattering and cleaning up `console.log`s.
**How to invoke.** `/debug-trace <bug description>`, or *"instrument and run"*, *"trace these values"*, *"cursor-style debug"*, *"inject debug logs"*, *"find this bug by tracing values"*.
**What you get.** Pre-flight orphan-marker scan → daemon started on a free loopback port (zero-deps Node) → a one-sentence hypothesis → suspect sites instrumented with marker-wrapped probes (UUID per probe, language-appropriate idiom) → user runs the failing scenario → AI reads the JSONL dump, compares actual vs expected, narrows or fixes → mandatory cleanup pass (`git grep '@debug-trace:'` must be empty), daemon shutdown, `.debug-trace/` deleted → final report.
**How it works.** Two pieces: `scripts/daemon.js` (zero-deps, loopback-only, `/log` `/dump` `/clear` `/health` `/shutdown`, body cap 1MB, 10k-line ring rotation) and a SKILL.md that codifies the injection contract — every probe wrapped in `@debug-trace:<uuid>` open/close marker comments using the file's native syntax, every HTTP call fire-and-forget so daemon-down never alters program flow, idiom table covering JS/TS, Python, Go, Ruby, Java/Kotlin, Shell, Rust, C/C++. Cleanup is non-negotiable: never end a turn with markers in the working tree; first action on next invocation is to scan for and remove orphans.
**Example.**
```
/debug-trace orderTotal is wrong on the checkout page when a discount applies
```
*Daemon starts on `127.0.0.1:64157`, AI hypothesizes "discount is double-applied", drops 4 marker-wrapped `fetch()` probes around the discount pipeline in `src/checkout/total.ts`, asks the user to reproduce, reads the dump, sees `subtotal=42 discount=4 total=34` (off by `discount` applied twice), proposes the one-line fix, removes all four probe blocks, shuts down the daemon — `git grep '@debug-trace:'` is empty.*
---
### `/narrate`
**What it does.** Reads a short summary of each of Claude's responses aloud using macOS text-to-speech. When ON, a `Stop` hook fires whenever Claude finishes a turn, pulls the final message from the session transcript, strips markdown, trims it to a sentence-bounded blurb, and speaks it via the `say` command.
**When to use.** You want to step away from the screen while Claude works and still hear when (and roughly what) it finished — or you just prefer an audible completion cue over watching the terminal. macOS only.
**How to invoke.** `/narrate on` / `/narrate off`, or `/narrate status`, `/narrate voice "Karen"`, `/narrate voices`, `/narrate length 150`, `/narrate personality "funny"` (or `serious`, `pirate`, any tone; `off` for verbatim), `/narrate build`, `/narrate test`, `/narrate uninstall`. Also fires on *"narrate my responses"*, *"speak my responses"*, *"set a personality"*, *"make it funny"*, *"mute the voice"*.
**What you get.** A global, opt-in spoken summary after every completed turn. `on` is self-contained: it copies the engine to a stable path (`~/.claude/narrate-engine.sh`) and merges a `Stop` hook into **your own** `~/.claude/settings.json`. The plugin ships no global hook — nothing runs for anyone until they opt in. Voice defaults to Samantha; point it at a downloaded **Premium** (neural) voice for higher quality. Set a **personality** and each spoken line is rewritten in that tone — funny, serious, deadpan, pirate, whatever you type.
**How it works.** The skill is a thin front-end over a bundled control script (`scripts/narrate`). The engine (`scripts/speak-on-stop.sh`) is gated three ways so it never misfires: it exits instantly when the toggle file is absent or `say` is unavailable (clean no-op off-Mac), only speaks fresh content, and de-dupes on a content hash so the same message is never spoken twice. When a personality is set, the line is rewritten first by **Apple's on-device Foundation model** (Apple Intelligence) via a bundled Swift helper (`scripts/narrate-rewrite.swift`, compiled on first use to `~/.claude/narrate-rewrite`) — free, local, ~0.5s, no API key; it falls back to verbatim if the model is unavailable. Requires `jq`; personalities additionally require macOS 26 + Apple Intelligence + `swiftc`.
**Example.**
```
/narrate on
```
*Installs the `Stop` hook into your settings, then speaks a one- or two-sentence summary at the end of every turn — e.g. "Renamed it to slash narrate. The skill is wired and the old slash talk is gone." `/narrate voice "Karen"` switches to the Australian voice; `/narrate personality "funny"` makes the on-device model rephrase each summary with a wink ("…now I'm ready to take over the marketplace!"); `/narrate off` mutes it; `/narrate uninstall` removes everything.*
---
## Subagent roster
This plugin ships **skills only**. The 161 specialist subagents the skills dispatch — Reality Checker, Code Reviewer, Brand Guardian, Sales Coach, TikTok Strategist, Backend Architect, etc. — live in the companion [`jaequery/supabuild`](https://github.com/jaequery/supabuild) plugin. Install supabuild alongside this one and Claude resolves agent names automatically across both plugins.
Without supabuild installed, the dispatching skills (`/dda`, `/next-feature`, `/shark-tank`, `/code-review`) will still run but will fall back to the generic `general-purpose` agent for each role.
---
## Layout
```
plugins/jaequery/
└── skills/ ← all 21 slash commands
├── next-feature/
├── dda/
├── code-review/
├── code-audit/
├── taste/
├── shark-tank/
├── git-audit/
├── seo/
├── market-research/
├── marketing-reddit/
├── cmux-diff/
├── debug-trace/
├── narrate/ ← macOS TTS, on-device personality rewrites (Apple Intelligence)
└── startup-*/ ← six-skill Paul Graham playbook
```
## The pattern
Skills codify *workflows* — the sequence of steps you'd want every time. Subagents (in supabuild) codify *perspectives* — the domain lens a specialist brings. `/dda` and `/next-feature` are the bridge: workflows that assemble perspectives on demand and pit them against each other.
That's the whole philosophy: jaequery owns the workflows, supabuild owns the personas.