Jesse Vincent

Dispatch code-reviewer subagent to catch issues before merging, with focused context and clear feedback workflow.

Run verification commands and confirm output before claiming work success

Process code review feedback with technical rigor, verification, and reasoned pushback before implementation.

Dispatch multiple Claude agents concurrently to investigate and fix independent problems without sequential bottlenecks.

Trace how ideas evolved to rediscover abandoned solutions and avoid repeating past failures before proposing changes.

Create isolated git worktrees with smart directory selection and safety verification for parallel feature development.

Apply four-phase root cause investigation before proposing fixes—guarantees systematic problem-solving over guessing.

Test system designs at extreme scales (1000x bigger/smaller, instant/year-long) to expose architectural limits and hidden failure modes.

Force unrelated concepts together to generate breakthrough innovations by discovering emergent properties through deliberate metaphor-mixing.

Master TDD's red-green-refactor cycle to write tests first, verify failures, implement minimal code, then refactor.

Identify and eliminate three critical testing anti-patterns: testing mock behavior, adding test-only methods to production, and mocking without understanding dependencies.

Debug any technical issue by finding root cause first through evidence gathering, pattern analysis, and fix validation—never patch symptoms.

Evaluate code review feedback with technical rigor, verify before implementing, and push back with reasoning when suggestions are incorrect.

Trace bugs backward through call stacks to find original triggers, not symptoms—with instrumentation techniques and real examples.

Generate detailed, task-by-task implementation plans from specs with file mappings, tests, and exact commands.

Search archived conversations using semantic similarity or exact text matching to find facts, patterns, and decisions.

Create bite-sized TDD implementation plans with exact file paths and commands for engineers unfamiliar with your codebase.

Explore user intent and requirements through dialogue before implementation, ensuring design approval.

Transform rough ideas into fully-formed designs through structured questioning and iterative validation.

Dispatch multiple independent agents concurrently to solve separate problems without shared state or sequential dependencies.

Guide developers through merge, PR, or discard decisions with test verification and structured execution steps.

Write failing tests first, then minimal code to pass, then refactor—ensuring every production line is tested.

Enforce evidence-based verification before claiming work completion, passing tests, or creating commits.

Execute structured workflow to merge, PR, or discard completed feature branches with test verification.

Create isolated git worktrees with smart directory selection and safety verification for parallel branch work.

Validate data at every system layer to make bugs structurally impossible, not just caught.

Extract universal principles by identifying patterns repeated across 3+ domains to unlock new applications.

Identify unifying principles that eliminate multiple redundant components through abstraction discovery.

Replace arbitrary timeouts with condition polling to eliminate flaky tests and race conditions.

Dispatch code-reviewer subagent to catch implementation issues before they cascade.

Execute written implementation plans with review checkpoints and verification steps.

Execute detailed plans in batches with review checkpoints between iterations.

Apply test-driven development to process documentation by establishing baselines, writing skills addressing failures, then closing loopholes.

Identify which problem-solving technique matches your specific stuck-type symptom.

Flip core assumptions systematically to expose hidden constraints and discover alternative solutions.

Execute implementation plans by dispatching fresh subagents per task with code review gates between tasks.