Vibe Coder

Here's the error I'm getting: [paste error]. Here's the relevant code: [paste code]. Explain what's causing it and give me the minimal fix.

This function should do X but instead does Y. Walk through it step by step and tell me where the logic diverges from what I expect.

Add temporary debug logging at the key decision points in this function so I can see what's happening at runtime.

This bug only happens intermittently / in production. List the most likely causes given this code and stack.

Here's my code and a failing test. Explain why the test fails, then fix the code, not the test.

Bisect this: here's the working version and the broken version. What changed that could cause this regression?

Refactor this function for readability without changing its behavior. Explain each change you make and why.

This file has grown too large. Suggest how to split it into smaller modules, and show the new file boundaries.

Point out any code smells, duplication, or anti-patterns in this file, ranked by how much they'd hurt maintainability.

Rewrite this using [pattern/library, e.g. early returns / a hook / composition] instead of the current approach, and explain the tradeoff.

Simplify this without adding new abstractions or dependencies — I want fewer lines and fewer concepts, not more indirection.

Is this function doing too many things? If so, split it and name each piece by what it actually does.

Write unit tests for this function, covering the happy path, edge cases, and at least one failure case.

Here's a bug that just got fixed: [describe/paste diff]. Write a regression test that would have caught it.

What are the edge cases I'm not testing for this input? List them, then write tests for the ones that matter most.

Write an end-to-end test for this user flow: [describe flow, e.g. sign up -> verify email -> log in].

This test is flaky. Explain the likely source of non-determinism and rewrite it to be stable.

Mock out [external dependency, e.g. the API call / database] in this test so it runs in isolation.

Review this PR diff as if you were a senior engineer. Flag bugs, security issues, and unclear naming — skip style nitpicks.

Is there anything in this change that could break existing callers or break backwards compatibility?

Review this for security issues specifically: injection, auth, secrets, unvalidated input.

Summarize what this PR does in 2-3 sentences for the changelog, based on the diff.

Would a new engineer understand this code without extra context? Point out anything that needs a comment or better naming.

Compare these two implementations of the same feature and recommend which to merge, with reasons.

Write a docstring/comment for this function describing its purpose, parameters, return value, and any side effects.

Generate a README section explaining how to set up and run this project locally, based on the package.json/config files.

Add inline comments only where the code isn't self-explanatory — don't narrate the obvious lines.

Document this API endpoint: method, path, request body, response shape, and possible error codes.

Explain this codebase's architecture in a short doc for a new team member — main modules and how data flows between them.

Turn these commit messages / PR titles into a human-readable changelog entry.

I want to build [feature]. Before writing code, outline the approach: main components, data flow, and key decisions.

Given these requirements: [list], what are 2-3 possible architectures, and what are the tradeoffs of each?

How would this design scale if usage grew 10x? What would break first?

Break this feature down into small, independently shippable tasks I can work through one at a time.

What existing patterns/modules in this codebase should this new feature reuse instead of duplicating?

Review this database schema for this use case: [describe]. Point out normalization issues or missing indexes.

Give me the relevant code only, not the whole file, and tell me exactly which lines to replace.

Before making changes, ask me any clarifying questions you need — don't assume.

Explain your reasoning first, then show the code — I want to check the approach before the implementation.

Don't add new dependencies, frameworks, or files unless I explicitly ask for them.

Here's my code style/conventions: [describe or paste example]. Match this style in your suggestions.

Give me three different ways to solve this, ranked by simplicity, and explain when I'd pick each one.