Prompts & Skills

Deep review of Java code for bugs, performance issues, and best practices. Tags every finding by severity and category.

Audit code for OWASP Top 10 vulnerabilities — injection, broken auth, sensitive data exposure, misconfiguration, and more.

Find CPU hotspots, memory allocation issues, N+1 queries, unnecessary blocking calls, and inefficient data structures.

Audit Spring Security configs for common misconfigurations — permissive rules, CSRF gaps, JWT weaknesses, open actuator endpoints.

Review a REST API design for consistency, RESTful correctness, naming conventions, status codes, and versioning strategy.

Spot race conditions, deadlocks, missing synchronization, and incorrect use of volatile, synchronized, and concurrent collections.

Paste any stack trace and get root cause, likely trigger, exact fix, and prevention strategy in 60 seconds.

Debug Spring Boot startup failures, bean conflicts, auto-configuration problems, and runtime errors.

Diagnose JVM memory leaks from heap dumps, GC logs, or code — identify leak root cause and fix strategy.

Diagnose why a database query is slow — reads the EXPLAIN plan and pinpoints missing indexes, bad joins, or lock contention.

Debug connection pool exhaustion, timeout cascades, and network-level failures in microservices.

Generate comprehensive JUnit 5 tests with Mockito, edge cases, boundary conditions, and parameterized tests for any Java method.

Design integration tests for Spring Boot REST endpoints using @SpringBootTest, MockMvc, and TestContainers.

Identify untested code paths, missing edge cases, and risky uncovered branches in an existing test suite.

Design a load test scenario for an API — realistic user flows, ramp-up strategy, thresholds, and failure criteria.

Generate Spring Cloud Contract definitions for a REST API — producer contracts, consumer stubs, and verification tests.

Generate clear, structured pull request descriptions from a git diff or list of changes.

Write a structured ADR for any architectural decision — capturing context, options considered, and rationale.

Generate OpenAPI 3.0 YAML and Javadoc from a REST controller — endpoints, params, responses, error codes, and examples.

Write a structured operations runbook for handling a production incident — detection, diagnosis, mitigation, and post-mortem.

Write a structured technical design doc (TDD) for a new feature or system — problem, approach, API design, data model, risks.

Identify service boundaries in a monolith using domain-driven design — which services to extract first and why.

Review a database schema for normalization gaps, missing indexes, naming consistency, and scalability issues.

Design an event-driven system for a given use case — event schema, topic strategy, consumer groups, error handling, and ordering.

Review a system design for scalability, reliability, consistency tradeoffs, and single points of failure.

Write conventional commit messages from a diff or change description — feat, fix, refactor, perf, and more.

Summarize a long PR diff into a concise review — key changes, risks, questions to ask the author, and a go / no-go recommendation.

Explain what a git log or blame output means — find when a bug was introduced, who changed what, and why.

Rewrite legacy Java code using records, sealed classes, pattern matching, virtual threads, and modern Stream/Optional idioms.

Find @Transactional anti-patterns — private methods, self-invocation, wrong rollback rules, missing propagation settings.

Design a robust Kafka consumer with correct ack modes, error handling, DLQ routing, and idempotency.

Fix JPA N+1 problems, lazy/eager loading mistakes, cartesian product joins, and missing indexes in Spring Data JPA.

Design a robust Spring Batch job with chunks, skip logic, retry, listeners, and restart strategy for large-scale data processing.

Review code for correct use of Java 21 virtual threads, structured concurrency, and safe parallel patterns with CompletableFuture.

Design meaningful health checks, liveness/readiness probes, and Actuator endpoint security for Kubernetes deployments.

Review a RAG implementation for chunking strategy, retrieval quality, context assembly, reranking, and hallucination risks.

Diagnose why an LLM prompt isn't performing as expected — ambiguity, missing constraints, format issues — and get a fixed version.

Analyze an AI application's LLM usage and identify where to cut costs — model routing, caching, token budgeting, batching.

Design the right embedding strategy for your use case — model selection, dimensionality, storage, and similarity threshold.

Design a multi-step AI agent workflow — tool definitions, orchestration logic, error recovery, and human-in-the-loop gates.

Design robust validation for LLM outputs — schema enforcement, hallucination detection, retry logic, and fallback strategies.

A complete system prompt for a Claude session focused on AI engineering, Java, and production architecture.

Drop in .claude/skills/ — paste any error or stack trace and get root cause + fix in 30 seconds.

Drop in .claude/skills/ — generates JUnit 5 tests for the current file or a specified method.

Drop in .claude/skills/ — reviews your current git diff for bugs and issues before you commit.

Drop in .claude/skills/ — analyzes a slow SQL query and recommends indexes and rewrites.

Drop in .claude/skills/ — generates Javadoc or README documentation for a class or module.

Drop in .claude/skills/ — scans the current file or directory for OWASP Top 10 vulnerabilities.

Drop in .claude/skills/ — generates a CHANGELOG.md entry from recent git commits.

Drop in .claude/skills/ — refactors a class or method to improve clarity, reduce duplication, or apply a specific pattern.

Find hardcoded API keys, credentials, and secrets in your codebase. Moves everything to environment variables and audits .gitignore and logs.

Map every piece of personal data your app collects, where it goes, and how to minimize exposure. Covers GDPR/CCPA compliance, third-party integrations, and data deletion.

Catch configuration drift, debug code left in, missing security headers, weak CORS, and other 'almost right' production issues before users hit them.

Comprehensive check for authorization bugs (IDOR), payment manipulation, SQL injection, XSS, and authentication bypass — the vulnerabilities that cause actual breaches.

Think like an attacker: ID manipulation, login bypass, privilege escalation, feature abuse, content injection, and business logic flaws that individual code checks miss.

Hand a coding agent your pending SEO issues. It confirms each problem in a production build first, fixes it task by task, never invents facts, and lists what needs your decision.

Add a script and a GitHub Actions workflow that fail the build when titles, descriptions, canonicals, H1s, alt text or structured data regress. Lighthouse CI included.

A read-only content audit: pages that are too short, pages competing for the same query, and posts with too few internal links. Produces a ranked to-do list, changes nothing.

A system prompt that makes an AI act as your growth team for a content-led business: audit, SEO plan, funnels, email and measurement. Honest about estimates.

Turn one technical article into a LinkedIn post, newsletter, thread, carousel outline, video script, meta tags, FAQ and JSON-LD, without inventing anything the article does not say.

Design a free resource that fits one article or course, the landing page copy, the signup form and a 5-email follow-up sequence that leads to a clear next step.

A phased, approval-gated brief for redesigning a technical site into a credible publication: audit first, then tokens, homepage, article template. Forbids invented stats.

Generate a conversion-focused dark-mode landing page for a developer tool, with the exact section order, copy slots, aesthetic and accessibility constraints.

Turn a product idea into a build-ready blueprint: user flow, AI output schema, database schema, plans, payments, email, security and a phased delivery plan.

Make an AI transform an existing codebase safely: scored audit first, then one approved feature at a time, never rewriting working code, always deployable.

Have Claude Code read your repo and write a CLAUDE.md that makes future sessions productive: real commands, the big-picture architecture, and nothing generic or invented.

Generate .github/copilot-instructions.md from your real repo: stack, commands, conventions and review rules that make Copilot suggestions match how your team writes code.