Cursor Prompts

Finds TypeScript files where `any` types, missing type annotations, or unsafe casts hide potential runtime errors.

Find gaps between documented OpenAPI schemas and actual implementation across route handlers.

Parse application logs to identify slow operations, memory spikes, and latency patterns causing user friction.

Finds every background job, queue worker, and scheduled task that runs without logging, metrics, or alerting attached.

Reads your routing layer and identifies every endpoint that lacks explicit authentication or authorization checks.

Scans your config files to surface every value that differs across envs and ranks the risk of each divergence.

Reads your Prisma schema and flags relations, missing indexes, and model shapes likely to produce slow queries at scale.

Scans your async code to surface every unhandled promise rejection that can silently crash your app.

Maps every feature flag in the codebase to its age, branch coverage, and the dead code risk it creates if never removed.

Identifies every external SDK or service call in the codebase that will hard-fail with no graceful degradation if the vendor goes down.

Finds every place in a Redux or Zustand codebase where state is mutated directly instead of through the proper store update path.

Scans your route definitions to surface every endpoint that has no rate limiting middleware or decorator applied.

Refactors a bloated route handler into clean controller, service, and data-access layers without changing behavior.

Locates all forced type casts and assertions in your codebase that bypass runtime validation and hide real bugs.

Maps each env var in your codebase to where it's read, how it's validated, and what breaks if it's missing.

Scans your async code to surface every Promise chain that silently swallows rejections or forgets to handle errors.

Finds pagination limits, timeouts, retry counts, and size caps buried in code that will break under real load.

Moves scattered raw SQL strings out of business logic and into a structured, testable query module without breaking anything.

Scans a codebase for business logic, persistence calls, or presentation concerns that have leaked into the wrong architectural layer.

Adds a Cursor rule that catches misleading variable names where the name implies one type but the value is another.

Analyzes an oversized class or object and produces a concrete multi-file refactor plan with clear ownership boundaries.

Refactor deeply nested callback pyramids into readable async/await with proper error isolation and cancellation awareness.

Add a rule that blocks any import violating your intended layer architecture before it gets normalized into the codebase.

Locate all coercions and casts that silently lose precision, nullability, or domain meaning at runtime.

Forces the AI to document what breaks and how before writing any code that touches an external service or API.

Surfaces async flows where promise resolution order is assumed but never guaranteed, before it bites you in prod.

Finds every hardcoded constant buried across your codebase and consolidates them into a single typed config object.

Audits every external input entry point in a module and generates validation, normalization, and rejection code.

Makes the AI declare a clear owner for every cache, connection, file handle, or global before touching it.

Finds every call site where a meaningful return value is silently discarded, hiding bugs.

Composer prompt that performs a risky migration with a feature flag wrapper and instant rollback path baked in.

A .cursorrules block that forces the AI to defend new wrappers, helpers, and layers before adding them.

Forces Cursor to audit async flows for race conditions, stale closures, and ordering assumptions.

A .cursorrules block that makes Cursor refuse to write try/catch blocks that hide failure from the caller.

Composer prompt for safely propagating a breaking type change across a codebase by reasoning about each call site individually.

A Cursor chat prompt that exposes the hidden responsibilities packed into a single function so you know where to split it.

A Composer prompt that upgrades a codebase littered with console.log into intentional, queryable telemetry.

A .cursorrules block that blocks Cursor from adding npm packages without a written cost-benefit defense.

Force Cursor to surface the undocumented assumptions a function depends on before you change a single line.

Multi-file Composer prompt that decomposes a bloated component into smaller ones while preserving the exact external prop contract.

A .cursorrules block that makes Cursor refuse to write implementation code until the test exists and fails for the right reason.

Forces Cursor to map the full async execution path before guessing at a fix for race conditions or stale state bugs.

A Composer prompt that finds every hardcoded conditional for a feature, unifies them behind a single flag, and ships the rollout plan.

A drop-in .cursorrules block that makes Cursor handle errors differently at the boundary, service, and infrastructure layers.

Forces Cursor to produce a reversible, staged database migration plan with rollback and dual-write checkpoints before any code change.

Builds a meaningful test suite around legacy code by inferring its real behavior contract before touching it.

Forces Cursor to trace a bug to its actual source instead of patching the first plausible symptom it finds.

Forces a frontend and backend contract negotiation before code on either side gets written, killing rework loops.

A disciplined protocol for finding the real cause of a flaky test instead of adding retries and moving on.

Turn a one-paragraph feature spec into a coherent multi-file vertical slice with tests, types, and a rollback plan.

Force Cursor to trace every caller, side effect, and contract before touching a single line of code.

A .cursorrules block that makes Cursor pause and justify itself before touching auth, payments, migrations, or shared state.

Runs a brutal self-review on your staged changes so you catch the embarrassing stuff before a human does.

Forces Cursor Composer to lock down current behavior before rewriting, so migrations don't silently break things.

Generate a .cursorrules block that forces Cursor to write error handling the same way every time.

Audit a codebase for unused functions, exports, and files that can be safely deleted.

Wrap existing functionality in a feature flag without changing behavior for current users.

Turn a vague bug report into a runnable minimal reproduction case you can debug in isolation.

Create seed data that actually looks like your production data so local dev and demos feel real.

Hand Cursor a working prototype and have it identify exactly what needs hardening before you ship it.

Generate a .cursorrules file that blocks the specific bad patterns Cursor tends to produce in your stack.

Hand Cursor a clean, dense recap when your chat is drifting so it stops hallucinating old state and re-focuses.

Use Composer to rename a domain concept everywhere (types, files, strings, comments) without breaking references.

Make Cursor walk a bug backwards through the codebase before suggesting any fix, so you understand the real cause.

Turns Cursor into a code reviewer that walks you through an unfamiliar file with concerns flagged.

Forces Cursor Composer to write failing tests before any implementation code, keeping scope honest.

Generates a tight .cursorrules file based on the actual conventions in your repo, not generic best practices.

Have Cursor plan an entire feature before writing a line — specs out files to touch, edge cases to handle, and tests to write first.

A Cursor-native prompt that refactors a function or file while preserving all existing behavior — includes a verification checklist.

Generate a .cursorrules file tailored to your stack — includes coding style, what to avoid, and how to handle edge cases specific to your project.

Find TypeScript interfaces and types that are used in API responses or database reads but have no runtime validation.

Force Cursor Composer to produce a precise file-by-file change plan before it touches a single line of code.

Get a senior-engineer-quality explanation of unfamiliar code instead of a textbook walkthrough.

Walk Cursor through a refactor in safe, reviewable chunks.

Drop-in .cursorrules for TypeScript/React projects. Covers conventions, patterns, and what to avoid.