Jesse Vincent

Takes a roadmap or implementation plan and spawns independent agents to tackle each workstream in parallel, then synthesizes results back into a coherent output.

Creates an isolated workspace for a feature branch using git worktrees, so you can switch contexts without stashing or committing half-done work.

Takes a spec or requirement document and produces a step-by-step implementation roadmap with dependencies, risk flags, and test points mapped to each milestone.

Runs your SKILL.md against test cases, checks for trigger overlap, flags logic gaps, and suggests rewrites before you publish.

Takes a written plan from a prior session and runs it in chunks, pausing at each checkpoint for your review before continuing to the next phase.

Takes a feature spec or bug report and generates a comprehensive test suite that drives the implementation. Tests are runnable immediately and document the expected behavior.

Reviews your branch state, test results, and commit history. Recommends the right merge strategy — rebase, squash, or conventional PR — and flags any cleanup needed first.

Pastes a diff or branch and receives a structured review: does it meet the requirement, are there bugs, what's the maintainability hit, and what should change before merge.

Teaches Claude to search and invoke skills before responding to your request, so you get the right tool—not a generic answer. Works in any chat.

Runs the test suite, build checks, and integration tests against your code, captures the output, and surfaces failures before you commit—preventing "ready to merge" claims that break in production.

Splits independent work across parallel agents — research one thing, draft another, review a third — and collects results once all complete. Faster than serial work.

Maps the gap between the vague request and a real spec by asking about user intent, tradeoffs, and constraints. Surfaces hidden requirements before you waste time implementing.

Takes a review comment that feels vague or wrong, breaks down the technical claim, and tells you whether it's justified and how to fix it — or why to push back.

Takes a failing test or error message and walks through reproduction, hypothesis formation, and root cause in a structured order — before jumping to code changes.

Spins up independent Claude agents in parallel to tackle separate problems — bugs, research threads, data checks — without waiting for one to finish before starting the next.

Sends your code and the original spec to a reviewer agent, which compares them line-by-line and flags gaps, oversights, and improvement opportunities before you ship.

Scans your skills directory for dead links, inconsistent naming, missing cross-references, and coverage holes — then generates a repair checklist grouped by urgency.

Guides you through forking, branching, and opening a pull request so your skill reaches other Claudinho users without manual git commands.

Takes a core belief about your product, market, or strategy and inverts it to surface hidden constraints, unstated tradeoffs, and paths you haven't considered.

Takes your business model or product roadmap and asks what breaks when you run it 1000x bigger, 1000x smaller, or stretched across a year. Exposes hidden assumptions.

Traces a concept backwards through Slack, docs, and commits to show what changed, why, and when—surfacing forgotten solutions and past reasoning that's now relevant again.

Generates a test suite for your feature before any implementation. You write the minimal code to pass each test, catching edge cases early and building confidence in your changes.

Documents your current process, runs a skill against it, identifies where it fails, and iterates the skill until it handles edge cases consistently and reliably.

Takes a code review comment and helps you either push back with a clear technical argument or identify the real issue your reviewer caught — avoiding both ego and blind acceptance.

Adds validation checkpoints at every layer where data enters, moves, and leaves your system—ensuring malformed inputs, corrupt states, or bad outputs are caught immediately with clear error messages.

Analyzes team friction to spot when opposing views each contain truth—and which tensions to hold rather than resolve fast. Includes a framework for tracking tradeoffs.

Asks focused questions about your rough sketch or concept, challenges assumptions, and builds a complete design brief with flows, states, and open questions mapped out.

Takes a detailed plan and executes it in phases, pausing for your review after each batch of steps before moving forward. Tracks progress and adjusts based on your feedback.

Preps a finished feature branch for merge: runs final checks, generates a PR template with context, and handles cleanup so nothing gets left dangling.

Indexes your conversation history and finds past decisions, code snippets, design choices, or discussions by meaning or keyword — without starting from scratch.

Converts a feature spec or RFC into a step-by-step implementation plan with enough context that a new engineer can start coding without asking questions.

Takes a stack trace or error log and walks backward through the call chain to isolate the first function that went wrong—with a hypothesis for why.

Walks through isolate → reproduce → inspect → confirm, ensuring you find the actual cause before trying a solution. Prevents wasted fix attempts.

Fetches new and updated skills from the central repository and merges them into your local copy, preserving any customizations you've made.

Runs your process against test scenarios with subagents, finds the ambiguous steps, and rewrites the docs until they're clear enough that someone else can follow them cold.

Takes your problem and forces it to collide with a random unrelated domain — treating customer churn like a supply-chain problem, or pricing like chess. Reveals hidden patterns and unconventional moves.

Takes examples from separate fields and surfaces the deep pattern that appears in all of them — the kind of insight that makes you say "oh, so it's really about X".

Analyzes your product roadmap or feature list and identifies high-leverage truths that would collapse multiple components at once — turning a 12-month plan into a 3-month one.

Listens to where you're blocked—stuck on scope, clarity, resources, or execution—and routes you to a specific problem-solving framework that actually fits your bottleneck.

Replaces sleep() calls with smart polling that waits for the actual condition you care about — reducing test timeouts and false failures in async code.

Reads test code and flags common pitfalls: mocking internals instead of boundaries, test-only production code, untested dependencies. Explains the smell and the fix.

A walkthrough of what a skill is, how to find one, and when to use it. Includes a brainstorm starter for discovering which routines in your day could become one.

Creates isolated worktrees so you can jump between branches without stashing, losing uncommitted changes, or tangling your workspace. Includes safety checks.

Runs your test suite or verification script, parses the output, and only marks a task complete if all assertions pass — catches regressions before they ship.

Takes a spec or feature list and assigns each task to a fresh subagent, then runs code review between tasks to catch regressions before they compound.