Claude Code Prompts

Scan a codebase for N+1 query problems where loops trigger repeated database calls instead of batch operations.

Identify schema changes, data loss points, and production safety issues in migration files.

Scan a codebase for async operations (promises, callbacks, event handlers) that lack logging, tracing, or error instrumentation.

Scan a codebase for database queries that fetch or modify data without tenant/user isolation checks.

Map every mutation that touches persistent storage without recording who changed what or when.

Configure Claude Code to reject any code that accesses object properties without first asserting the value exists.

Scan your codebase for async patterns that silently serialize work and kill throughput under load.

Locates every exported function, type, or constant that has zero import references across the entire codebase.

Scans your codebase for caching logic that stores data but never defines when or how to clear it.

Audits your webhook receiving and sending logic to surface every point where silent delivery failures can occur.

Locates all retry logic in your codebase that can run indefinitely because it has no absolute deadline or maximum elapsed time guard.

A CLAUDE.md config that prevents Claude from mutating shared data structures when passing them between services or modules.

Finds all the places in your codebase where errors are caught, logged, and silently dropped instead of surfaced.

A slash command that maps every route to its auth enforcement and surfaces gaps where requests reach handlers unauthenticated.

A CLAUDE.md config that stops Claude from introducing imports that violate your layered architecture.

Scan a codebase for async functions secretly doing sync I/O and explain the performance cost of each.

Scan a codebase for stringly-typed config and environment values that are secretly a closed set.

System config that forces Claude to surface and handle null/undefined at every IO and module boundary.

Map all background jobs, workers, and async tasks in a codebase to the exact user action or system event that starts them.

Audit a module or file to surface every function that looks pure but secretly reads from or writes to shared state.

A Claude Code slash command that hunts down conditions, branches, and returns that can never execute given actual data flow.

Configure Claude Code to reject implicit state changes and require documented transition guards on every state-bearing object.

Locate every catch block, fallback, and default that hides failure instead of surfacing it to the caller.

Force every test in the project to assert a specific observable outcome, not just that code executed.

Find every point in your codebase where auth decisions are made, deferred, or silently skipped.

Stops Claude from generating database migrations without a tested, explicit rollback strategy attached.

Scans your codebase for files and modules that lack clear ownership signals before they become incidents.

Finds every config value that is environment-specific and flags the ones with no validation or parity check.

Hunts down every assignment in the codebase whose value is never consumed before being overwritten or discarded.

Configures Claude Code to challenge every new name it proposes before writing it into the codebase.

Finds functions that look pure but secretly mutate state, hit I/O, or produce hidden effects.

A slash command that surfaces undeclared dependencies: env vars, file paths, network assumptions, and global state.

A CLAUDE.md directive that makes Claude declare the runtime, maintenance, and cognitive cost of every change before proposing it.

Surfaces the seam your codebase is begging for by analyzing import patterns and responsibility leakage.

Forces Claude to extract the hidden state machine from imperative code before you refactor or extend it.

A CLAUDE.md block that makes Claude classify every change by how hard it is to undo before writing the commit.

A slash command that surfaces gaps between a function's declared contract (types, docstring, tests) and its actual runtime behavior.

A reusable slash command that maps the true blast radius of a proposed change across files, services, and consumers.

A CLAUDE.md block that makes Claude enumerate how a feature can fail before writing a single implementation line.

Force Claude to map the implicit architecture of an unfamiliar codebase before touching a single line.

A /seam-check slash command that proves a module is actually extractable before you waste an afternoon trying.

A CLAUDE.md block that makes Claude Code state its plan, assumptions, and rollback path before any file change.

Turn Claude Code into a hostile but fair PR reviewer that catches what your team's rubber stamps miss.

Plans a minimal, behavior-preserving seam in a messy module so you can refactor or add features without rewriting it.

A slash command that forces Claude to lock the spec, contracts, and assumptions in writing before any implementation.

Generates a CLAUDE.md section that prevents Claude from sprawling your dependency tree or breaking import conventions.

Generates a tight CLAUDE.md that captures your real coding conventions from actual diffs, not aspirational rules.

Forces Claude Code to build a layered understanding of an unfamiliar repo before you ask it to touch anything.

A reusable slash command that stops Claude Code from quietly expanding the blast radius of a task you gave it.

Refactor across many files safely by having Claude Code first capture observable behavior, then preserve it.

A reusable Claude Code slash command that audits your working tree and blocks dumb pushes before they happen.

Have Claude Code explore your repo and write a CLAUDE.md that actually reflects how the codebase works.

Set up a Claude Code pre-tool-use hook that runs your linter before every file edit — catches issues before Claude writes bad code.

A structured prompt sequence to start a Claude Code session, orient it to your codebase, and ship a complete feature without going off the rails.

Have Claude Code explore an unfamiliar repo and produce a structured map of how it actually works.

Run a quarterly audit to find tech debt, dead code, and rot before it becomes pain.

Run a security pass over a feature using the OWASP top-10 lens, but don't get lost in noise.

Diagnose a perf regression the way an SRE would, not by sprinkling random optimizations.

A senior-style test strategy doc that decides what to test, what not to test, and at what level.

Reverse-engineer a legacy codebase you inherited, the way an experienced engineer would.

A surgical protocol for triaging a live production bug with Claude Code without making things worse.

Get Claude Code productive across 3+ repos without context window meltdown.

A repeatable, premium-grade loop for building non-trivial features with Claude Code without surprises.

The full CLAUDE.md I use across 47 Industries. Copy/paste, fill in, ship.

Decide which dependency updates to take this week without rolling the dice on breaking changes.

Walk through open PRs and decide what to do with each one.

A repeatable workflow for finding stale feature flags and removing them safely.

Turn a branch full of commits into a clear, scannable PR description.

Generate a clean conventional commit message from the staged diff.

Stop Claude from papering over real bugs with try/catches, defaults, and "compatibility shims" that hide the actual problem.

Force Claude Code to actually check its work — typecheck, run tests, hit the endpoint — instead of declaring victory and stopping.

Force Claude to write a plan and get approval before touching code. Saves hours on multi-file changes.

Constrain Claude to the smallest possible change. Eliminates surprise refactors and scope creep.

Force Claude Code to understand existing code before changing it. Cuts down hallucinated edits dramatically.

A drop-in CLAUDE.md template that gives Claude Code immediate context about your stack, conventions, and what 'done' means.