Agent Prompts Library

Deep code review for Spring Boot services examining transaction boundaries, JPA N+1 queries, concurrency, and validation.

Review Next.js 14/15 App Router code for RSC boundaries, data fetching waterfalls, caching, and hydration safety.

Audit TypeScript code for type safety, type narrowing, generics, mutation traps, and runtime boundary leaks.

Structured PR review prompt that categorizes findings into Blocker, Major, Minor, and Nitpick with actionable diffs.

Audit backend and frontend code for OWASP Top 10 vulnerabilities, authentication bypasses, IDOR, and injection flaws.

Analyze production stack traces, error logs, and surrounding code using hypothesis-driven debugging.

Diagnose Postgres/MySQL transaction deadlocks, lock contention, and concurrent update race conditions.

Identify slow database queries, serialization bottlenecks, and memory churn in sluggish API endpoints.

Analyze heap snapshots, unclosed event listeners, and runaway closures causing Node.js OOM crashes.

Fix nondeterministic test failures, unhandled async promises, and race conditions in Playwright, Jest, or Vitest.

Design or review RESTful API contracts for idempotency, pagination, error models, and non-breaking versioning.

Design production PostgreSQL schemas with composite indexes, foreign key strategies, and partitioning.

Deconstruct monoliths or complex systems into bounded contexts with clear domain events and data ownership.

Generate thorough, engineering-ready Request for Comments (RFC) and Architecture Decision Records (ADRs).

Review Kafka, RabbitMQ, or SQS/SNS event architectures for exactly-once semantics, out-of-order delivery, and DLQs.

Generate comprehensive, mutation-tested unit tests with AAA pattern, boundary cases, and proper mock boundaries.

Create robust integration test suites with real databases in Docker containers and contract verification.

Generate adversarial fuzzing test cases, SQL injection payloads, and schema violation matrices for REST endpoints.

Validate database schema migrations for zero data loss, backward compatibility, and forward/backward rollbacks.

Audit test suites by simulating mutant bugs (flipped conditionals, off-by-one errors) to expose weak assertions.

Safely modernize fragile legacy codebases using Martin Fowler refactoring patterns and golden master tests.

Decompose monolithic 1,000+ line classes into Single Responsibility components using SOLID design patterns.

Convert blocking I/O code into non-blocking async/await, reactive streams, or virtual threads.

Generate a step-by-step upgrade strategy for major framework shifts (e.g. Next 12 to 15, Spring 2 to 3).

Refactor tangled MVC controllers and service layers into Clean Architecture (Ports & Adapters).

Transform messy product requirements into razor-sharp User Stories with Given-When-Then Gherkin acceptance criteria.

Break large product epics into vertically sliced, independently deployable Jira engineering subtasks.

Conduct rigorous backlog refinement, identify hidden complexity, and estimate story points with Scrum poker criteria.

Turn vague user bug reports into crisp, reproducible defect tickets with root-cause hints and regression steps.

Synthesize team retro feedback into categorized themes, root causes (5 Whys), and SMART action items.

Optimize Dockerfiles for minimal image size, non-root security, layer caching, and CVE vulnerability reduction.

Speed up slow GitHub Actions workflows with dependency caching, matrix parallelization, and security secrets.

Audit Kubernetes manifests for CPU/memory requests, readiness/liveness probes, HPA, and Pod Disruption Budgets.

Audit Terraform HCL code for IAM over-permissioning, unencrypted storage, public security groups, and drift risks.

Plan high-volume, live table restructuring and large column migrations without application outages.

Generate a custom, context-rich project rules file that stops AI coding agents from making recurring mistakes.

Instruct coding agents (Cursor, Claude Code, Cline) to generate actionable multi-step implementation plans before touching code.

Force AI coding agents to follow the Red-Green-Refactor cycle: write failing tests first, then write minimal code to pass.

Prompt an agent to analyze an unfamiliar codebase and deliver an architectural breakdown, data flows, and gotchas.

Prompt orchestrating agents to delegate subtasks to child agents with strict verification gates and bounded context.