Code
Collections
Hand-picked prompts for a role, with guides and FAQs.
API Design — Endpoints, Errors and Versioning
Design an API that other developers can use without asking you questions: endpoints, request and response shapes, status codes, error format, pagination, auth and a versioning plan.
Architecture Decision Record — Write Down the Why
Write an architecture decision record (ADR) from your notes: the context, the options you weighed, the decision and its consequences, so the next developer knows why and doesn't reopen it.
Code From Spec — Small, Tested and Idiomatic
Write code from a spec in your stack and style: a short plan, the implementation, tests for the edge cases, and a list of every assumption made, instead of a wall of code you have to reverse-engineer.
React Component — Accessible, Typed and Ready for Every State
Build a React component that's typed, accessible and handles loading, empty and error states, matched to your styling and existing components, with usage examples and tests.
Code Review — Findings Ranked by Severity
Get a thorough code review of a diff or file: bugs, security issues, edge cases and readability problems, each ranked by severity with a suggested fix, plus what's good about the change.
Feature Spec — From Idea to Buildable Ticket
Turn a feature idea into a spec a developer can build from: the problem, user stories, acceptance criteria, edge cases, data and API changes, and the open questions to settle first.
System Design Review — Trade-offs Before You Build
Get a design reviewed before you build it: the weak points, failure modes, scaling limits and simpler alternatives, with each risk ranked and the questions a senior reviewer would ask.
Database Schema Design — Tables, Keys and Migrations
Design a database schema from your requirements: tables, columns and types, keys and constraints, indexes for your real queries, and a migration plan that flags steps that could lock a table or lose data.
SQL Query Writer — Correct, Readable and Indexed
Write a SQL query from a plain-English question and your schema, with an explanation of how it works, the edge cases it handles, and what would keep it fast at scale.
Regex Builder — Pattern, Explanation and Test Cases
Build a regular expression from examples of what should and shouldn't match. You get the pattern, a piece-by-piece explanation, test cases, and a warning when regex is the wrong tool.
Code Explainer — What It Does and Why It's Written That Way
Paste code you didn't write and get it explained at your level: what it does, how data flows through it, the non-obvious parts, the assumptions it makes and the questions to ask its author.
Code Migration — Port Code to a New Language or Framework
Port code to another language, framework or major version without changing what it does: a mapping of old to new, idiomatic target code, the gaps with no direct equivalent, and tests that check both versions match.
Refactor Plan — Safe Steps, Same Behavior
Plan a refactor you can ship safely: what's wrong with the code now, the target design, small steps that keep behavior unchanged, tests to add first, and how to roll each step back.
Bug Hunt — From Symptom to Root Cause
Track down a bug methodically: ranked hypotheses, the quickest test for each, the root cause once found, a minimal fix and a regression test so it stays fixed.
Error Message Explainer — What Broke and Where to Look
Paste an error or stack trace and get it in plain language: what it means, the line that matters, the most likely causes in your code, and the first things to check.
Performance Investigation — Measure Before You Optimize
Find out why something is slow before you change it: a measurement plan, likely bottlenecks ranked, the profiling tools to use, and fixes ordered by impact and effort.
Unit Tests — Edge Cases First
Write unit tests for existing code in your test framework: a test plan, tests for the happy path, edge cases and failures, and a list of behaviors that look like bugs.
Security Review — Check Your Code for Common Holes
Review your own code for common security flaws: injection, broken auth and access control, exposed secrets, unsafe input handling and risky dependencies, with each finding rated and fixed.
Coding Agent Brief — A Task Claude Code or Cursor Can Finish
Turn a vague coding task into a brief an AI coding agent can finish without drifting: current state, desired state, files in scope, constraints, acceptance checks and when to stop and ask.
Project Rules File — A CLAUDE.md or AGENTS.md for Your Repo
Write a rules file that gives AI coding agents the context they keep missing: stack, commands, structure, conventions and the things they must never do, kept short enough to actually be read.
Codebase Tour — Get Oriented in an Unfamiliar Repo
Get oriented in a codebase you didn't write: what it does, how it's organized, how a request flows through it, where to make common changes and the risky areas to avoid on day one.
AI Code Check — Review Agent-Written Code Before You Merge
Review code an AI agent wrote before you merge it: does it match the request, what did it invent or change outside scope, which tests are real, and what to verify by hand.
README Writer — Setup That Works on the First Try
Write a README a new developer can follow on the first try: what the project does, prerequisites, setup and run commands, configuration, common problems and how to contribute.
Commit Message and PR Description — What Changed and Why
Turn a diff into a clear commit message and pull request description: what changed, why, how it was tested, the risks and what reviewers should look at first.