The Claude Code Prompt Pack.

I'm starting [describe project/feature]. Here's the current state:
- Tech stack: [list]
- What already exists: [describe]
- What I need to build: [describe]

Before writing any code:
1. Confirm you understand what I'm asking
2. List any files you'll need to read first
3. Outline your implementation approach in bullet points
4. Flag any risks or things you're unsure about

Wait for my approval before writing any code.

I have a bug. Here are the details:

File: [filename and line number if known]
Expected: [what should happen]
Actual: [what is happening]
Error: [paste exact error and stack trace]
Repro: [how to trigger it]

Approach:
1. Read the relevant files first
2. Explain what you think is causing it
3. Propose a fix
4. Apply only after I confirm

Do not change anything outside the scope of this bug.

Please review the code in [filename].

Focus on:
1. Correctness -- will this actually work?
2. Edge cases -- what could go wrong?
3. Performance -- any obvious bottlenecks?
4. Security -- any vulnerabilities?
5. Readability -- is it clear what this does?

For each issue:
- Quote the specific line
- Explain why it's a problem
- Suggest a fix

Don't rewrite everything. Be surgical.

Refactor [file/function] to [goal].

Constraints:
- Do NOT change any public interfaces or function signatures
- Do NOT break existing tests
- Keep the same behaviour -- this is not the time to fix bugs
- Follow the patterns already used in [reference file]

Process:
1. Show me what you plan to change before doing it
2. Make changes incrementally, not all at once
3. After each change, explain what you did and why

Write tests for [file/function/feature].

Testing approach:
- Framework: [Jest / Pytest / Vitest / etc.]
- Test file location: [where tests should go]
- Cover: happy path, edge cases, error cases

For each test:
- Use descriptive names that explain what's being tested
- Follow Arrange / Act / Assert
- Mock external dependencies
- Test behaviour, not implementation details

After writing tests, run them and fix any failures.

Build [feature description].

Context:
- This fits into [part of the codebase]
- It needs to [list requirements]
- It should NOT [list what to avoid]
- Follow the existing pattern in [reference file]

Process:
1. Plan: list all files you'll create or modify
2. Build: implement the feature
3. Verify: run tests and linter
4. Summarise: tell me what you built and what to test manually

If you hit something unclear, ask before guessing.

Generate an AGENTS.md file for this project.

To do this:
1. Read the package.json / requirements.txt (or equivalent)
2. Look at the directory structure
3. Read 2-3 existing files to understand patterns
4. Check for existing README or CONTRIBUTING docs

Then write an AGENTS.md with:
- Project overview (2-3 sentences)
- Complete tech stack
- Directory structure with explanations
- All dev/test/lint/build commands
- Code conventions you observed
- Rules: things that should never be done

Be specific. 'Use async/await' beats 'write clean code'.