30 Battle-Tested ChatGPT & Claude Prompts for Clean Code, Refactoring & Debugging

# rules.md
- Language: Python 3.12, type hints required, mypy --strict clean.
- Framework: FastAPI 0.11x, Pydantic v2, SQLAlchemy 2.0 async.
- Never add dependencies without listing them under "New dependencies".
- Never change public function signatures unless the task says so.
- Output diffs in unified format against the files provided. No full-file rewrites.
- If information is missing, list assumptions before answering.

debug:
- "Here is failing code and its error output. List the 3 most likely root causes ranked by probability. For each, give the evidence in the code and a minimal test that would confirm it. Then patch only the top cause as a unified diff.\n{code}\n{log}"
- "This test is flaky. Identify every source of non-determinism (time, ordering, shared state, concurrency, network). Propose a deterministic rewrite as a diff.\n{code}\n{log}"
- "Trace the execution path that produces this stack trace, frame by frame, stating the value of key variables at each step. Stop at the first frame where state diverges from intent.\n{code}\n{log}"
- "Audit this code for race conditions. For each, describe the interleaving that triggers it as a numbered timeline, then propose the smallest locking or idempotency fix.\n{code}"
- "Explain why this works locally but fails in CI. Consider env vars, file paths, timezones, dependency versions and parallelism. Output a checklist ordered by likelihood.\n{code}\n{log}"

refactor:
- "Refactor for readability without changing behaviour. Keep all public signatures. Output a unified diff and a list of every behavioural risk you considered.\n{code}"
- "Extract the duplicated logic in these files into one well-named function. Show the diff and name the tests that cover each call site.\n{code}"
- "Replace nested conditionals with guard clauses or a dispatch table, whichever is clearer. Diff only.\n{code}"
- "Identify the 3 functions with the highest cyclomatic complexity and split each into single-purpose helpers. Diff plus a one-line rationale per split.\n{code}"
- "Migrate this module from {task}. List breaking API differences first, then the diff. Flag anything you could not migrate safely.\n{code}"

tests:
- "Write pytest unit tests for this function covering normal cases, boundaries, invalid input and error paths. One test per behaviour, named test_<behaviour>.\n{code}"
- "Write property-based tests with Hypothesis for the invariants of this function. State each invariant in a comment above its test.\n{code}"
- "Write a regression test that fails on the current code because of this bug and passes once it is fixed. Do not fix the bug.\n{code}\n{log}"
- "List the untested branches in this code given these existing tests, then write tests for the 5 riskiest.\n{code}"
- "Generate table-driven tests for this parser with at least 15 tricky inputs (unicode, empty, huge, malformed). Explain why each input is tricky.\n{code}"

review:
- "Review this diff as a staff engineer. Output findings as: severity (blocker/major/minor), file:line, problem, suggested fix. No praise, no summaries.\n{code}"
- "Review this diff for security issues only: injection, auth bypass, IDOR, secrets, unsafe deserialisation. Same findings format.\n{code}"
- "Check this diff against the project rules in the system prompt. List every violation with file:line.\n{code}"
- "Identify any behaviour this diff changes that is not mentioned in its description: {task}\n{code}"
- "Point out naming, error-handling and logging inconsistencies with the surrounding code. Suggest exact replacements.\n{code}"

architecture:
- "Design the service boundary for: {task}. Give 2 alternative designs, the one you recommend, and what would make you change your mind."
- "Propose a database schema for: {task}. Include constraints, indexes, and the queries each index serves. Flag denormalisation decisions."
- "Write an API contract (OpenAPI YAML) for: {task}. Include error responses, pagination and idempotency keys."
- "Given this module, draw the dependency graph as a Mermaid diagram and identify cycles or layering violations.\n{code}"
- "Write an architecture decision record for: {task}. Sections: context, decision, alternatives rejected, consequences."

performance:
- "Given this profile output and code, list the top 3 bottlenecks with estimated impact (high/medium/low) and a fix for each.\n{code}\n{log}"
- "Find N+1 query patterns in this ORM code and rewrite each with eager loading or a batched query. Diff only.\n{code}"
- "Reduce memory usage of this data pipeline. Consider streaming, generators and chunking. Explain trade-offs.\n{code}"
- "Analyse this EXPLAIN plan and the query. Recommend indexes or rewrites and predict the new plan shape.\n{code}\n{log}"
- "Identify blocking I/O inside async code paths here and convert them to non-blocking equivalents. Diff only.\n{code}"

#!/usr/bin/env python3

"""coderun.py - run a structured coding prompt against Claude or ChatGPT."""

import argparse

import os

import pathlib

import sys

import yaml

def read_files(paths: list[str]) -> str:

blocks = []

for p in paths:

text = pathlib.Path(p).read_text(encoding="utf-8")

blocks.append(f"<file path=\"{p}\">\n{text}\n</file>")

return "\n".join(blocks)

def build_messages(args: argparse.Namespace) -> tuple[str, str]:

library = yaml.safe_load(pathlib.Path("prompts.yaml").read_text())

template = library[args.category][args.index]

rules_path = pathlib.Path("rules.md")

system = rules_path.read_text() if rules_path.exists() else "You are a senior engineer."

code = read_files(args.files) if args.files else ""

log = pathlib.Path(args.log).read_text() if args.log else ""

user = template.format(code=code, log=f"<log>\n{log}\n</log>" if log else "", task=args.task or "")

return system, user

def call_model(provider: str, system: str, user: str) -> str:

if provider == "claude":

import anthropic

client = anthropic.Anthropic()

resp = client.messages.create(

model=os.environ.get("CLAUDE_MODEL", "claude-sonnet-5-5"),

max_tokens=8000,

system=system,

messages=[{"role": "user", "content": user}],

)

return "".join(block.text for block in resp.content if block.type == "text")

from openai import OpenAI

client = OpenAI()

resp = client.chat.completions.create(

model=os.environ["OPENAI_MODEL"],

messages=[{"role": "system", "content": system}, {"role": "user", "content": user}],

)

return resp.choices[0].message.content or ""

def main() -> None:

parser = argparse.ArgumentParser()

parser.add_argument("category", choices=["debug", "refactor", "tests", "review", "architecture", "performance"])

parser.add_argument("--index", type=int, default=0, help="prompt number within the category (0-4)")

parser.add_argument("--files", nargs="*", default=[])

parser.add_argument("--log")

parser.add_argument("--task")

parser.add_argument("--provider", choices=["claude", "openai"], default="claude")

parser.add_argument("--out", default="response.md")

args = parser.parse_args()

system, user = build_messages(args)

answer = call_model(args.provider, system, user)

pathlib.Path(args.out).write_text(answer, encoding="utf-8")

print(f"Saved {len(answer)} chars to {args.out}", file=sys.stderr)

if __name__ == "__main__":

main()

python coderun.py debug --index 0 --files src/orders.py --log pytest.log

sed -n '/^--- a\//,$p' response.md > patch.diff

git switch -c ai/fix-orders

git apply --check patch.diff && git apply patch.diff && pytest -q