Claude Code Prompts for Agentic Coding

Don't write any code yet. Explore this codebase and explain how [feature/area] currently works: which files are involved, how data flows, and the key entry points. Read the relevant files first, then summarize your understanding so I can confirm it before we make changes.

I want to add [feature]. Don't implement it yet. Make a step-by-step plan: the files you'll create or change, the order of changes, edge cases to handle, and where tests are needed. Show me the plan and wait for my approval before writing any code.

Before proposing a solution, think hard about how to [tricky task, e.g. migrate this data without downtime]. Lay out two or three approaches with their trade-offs, the risks of each, and your recommendation. Don't write code, I want to decide on the approach with you first.

Create or update a CLAUDE.md for this project. Include the key commands (build, test, lint, run), the architecture and where things live, our coding conventions, and any gotchas or rules a new contributor must know. Read the codebase to ground it in reality, and keep it concise and scannable.

Implement the plan we agreed on for [feature]. Follow the conventions in CLAUDE.md, match the patterns in the existing files you read, and make the changes in logical steps. After each major step, briefly tell me what you did. Don't add new dependencies without asking.

Add [new thing, e.g. a new API route] by following the pattern in [existing file]. Read that file first, then replicate its structure, validation, and error handling for the new case. Point out anywhere the new case genuinely needs to differ from the template.

Build [feature] in small, verifiable increments. Start with [smallest working piece], confirm it works, then add the next piece. After each increment, run the relevant tests or tell me how to verify it manually. Pause between increments so I can review.

While we work on [main task], dispatch a subagent to independently [parallel sub-task, e.g. audit the codebase for all places that call the old API]. Have it report back a findings list. Keep our main thread focused on [main task] in the meantime.

Write tests for [feature/file] using our existing test framework and conventions. Cover the happy path, edge cases, and error handling. Run the tests yourself, fix any failures, and keep iterating until they pass. Then summarize what's covered and what you left out on purpose.

Run the test suite. For each failing test, investigate the actual cause before changing anything and tell me whether the test or the code is wrong. Fix the genuine issues, don't just make tests pass by weakening assertions, and re-run until everything is green.

I'm hitting this error: [paste error/stack trace]. It happens when [steps to reproduce]. Trace it to the root cause by reading the relevant files, explain what's actually going wrong, then apply the smallest fix. Add a regression test so it can't silently come back.

Before fixing [reported bug], first write a failing test or a minimal script that reproduces it, and show me it actually fails for the right reason. Only once we've confirmed the reproduction should you implement the fix and prove the test now passes.

Refactor [file/module] to improve clarity and reduce duplication without changing its behavior. First make sure there are tests covering it (write them if not), then refactor in small steps, running tests after each. Explain each change and flag anything that feels risky.

Without changing anything, answer: where is [behavior, e.g. user authentication] implemented, what's the full path from [entry point] to [outcome], and which files would I touch to change [something]? Read the code to answer accurately and cite the specific files and functions.

Search the codebase for unused code: exports nobody imports, functions never called, and dead branches. List what you find with its location and why you believe it's unused. Don't delete anything yet, I'll review the list and tell you what to remove.