ChatGPT Prompts for Coding: Debug, Refactor & Review

ChatGPT prompts for coding work when you paste stack context, a repro or behavior lock, and a single output shape: a debug hypothesis with a unified diff, a refactor that keeps public APIs stable, or a PR review ranked Blocking vs Optional. You leave with ROLE / TASK / FORMAT kits for GPT-5.5 Instant and GPT-5.6 Sol inside ChatGPT, plus stop rules that keep Instant from rewriting whole files. This page stays on ChatGPT workflows. Claude-specific coding paste stacks live on a separate guide. Soft tip: PromptMake /text can turn a rough coding ask into a labeled scaffold at https://promptmake.net/text before you paste into ChatGPT.

Who ChatGPT coding prompts help

You ship in a repo ChatGPT cannot see unless you paste files, diffs, test names, and error logs. The patterns fit engineers who use ChatGPT as a pair for a bounded change: a failing test, a noisy stack trace, a refactor inside named files, or a PR comment pass. Backend, frontend, and infra work all fit if you name language, framework version, and files in scope.

Skip this page if you want Claude Fable 5 / Opus 5 / Sonnet 5 paste shapes, or a cross-model encyclopedia that treats every vendor as equal. Stay here for ChatGPT-shaped kits: Instant for fast first passes, GPT-5.6 Sol for merge-risk debug and review. Skip it if you want the model to invent APIs, add packages without asking, or rewrite whole files when you needed a five-line fix.

Treat ChatGPT as a contractor with a written ticket. You supply stack, repro, files, tests, and banned edits. ChatGPT proposes a hypothesis, a diff, a refactor plan, or a review. You reject patches that touch files you did not name. Close the thread after one artifact type so a debug pass does not bleed into a drive-by rename.

ChatGPT prompts for coding: the paste stack

A strong ChatGPT coding prompt leads with four blocks before any tone request: stack, task, scope, and output shape. Stack is language, framework, versions, test runner, and package manager. Task is the bug, refactor goal, or review focus in one sentence plus repro or acceptance. Scope is files ChatGPT may change and files it must leave alone. Output shape is unified diff, single function, test file, or numbered review. Paste those four near the top. Put banned edits at the end so they survive a long paste.

Vague "fix this" pastes with 400 lines of a component produce a full rewrite because you asked for a rewrite. GPT-5.5 Instant and GPT-5.6 Sol both follow labeled blocks. They still invent helper files if you omit DO_NOT_MODIFY. They still drop error handling if you omit TESTS. Keep a short STACK sheet outside the chat and reuse it. One artifact per thread. Mixing a debug fix, a refactor, and a review in the same message muddies length and git history.

Soft tip: if your rough ask is messy, shape the prompt once at https://promptmake.net/text, then fill STACK, BUG, and FILES_IN_SCOPE yourself. PromptMake cannot see your repo. You still own paths and test commands.

Stack, scope, and output shape

Copy this wrapper and fill the brackets:

ROLE: You are a [language] engineer on this repo. You edit only FILES_IN_SCOPE. You do not invent files, APIs, or dependencies.

STACK: [language + version], [framework + version], [test runner], [package manager]

TASK: [one sentence goal]. Repro or acceptance: [steps or checks].

FILES_IN_SCOPE: [paths]

DO_NOT_MODIFY: [paths, schemas, public APIs]

OUTPUT: [unified diff | single function | test file | review with Blocking / Optional]

TESTS: [exact command, e.g. npm test -- SignupForm.test.tsx]

RULES: No full-file rewrites. No new dependencies without asking. If the root cause sits outside FILES_IN_SCOPE, stop and explain in 3 sentences. Mark missing facts with [NEED CONTEXT].

REMINDER: Output the artifact named in OUTPUT. Do not paste the whole file unless I asked for a full file.

That reminder line cuts the rewrite habit. ChatGPT likes complete files because they look tidy. Your rule forces a patch you can read in git.

Stop rules and ChatGPT model pick

Add stop rules when logs are incomplete or the bug might live in another service. Example: "If STACK or FILES_IN_SCOPE cannot explain the failure, write [NEED CONTEXT] and list the file or log you need. Do not guess network timeouts or race conditions." GPT-5.6 Sol follows this when you put it in RULES and repeat it in REMINDER.

For API work, name the contract: "Public function signatures stay stable. If the fix needs a signature change, propose it in 3 bullets and wait." For UI, name the library: "React 19, no class components, no new CSS framework." Instant still needs those lines; speed does not replace scope.

Pick Instant for first-pass plans, small diffs, and short reviews when the stack is short. Pick GPT-5.6 Sol for tangled bugs, multi-file contracts, and Blocking / Optional reviews you will merge. Skip long "think step by step" slogans on Sol. Goal, constraints, and format already steer it.

Debug kits: from stack trace to unified diff

Debug is the job most people mean when they search chatgpt prompts for coding. The trap is pasting a wall of code and writing "why broken?" ChatGPT then rewrites the file, changes unrelated imports, and leaves you with a diff you cannot trust. A debug kit forces three moves: state the symptom and repro, demand a short hypothesis before code, then demand a unified diff against FILES_IN_SCOPE only.

Keep the failing log or assertion in the same message as STACK. Strip secrets, customer data, and private keys. Name the test command that should go green. If you want a failing test first, run that as a separate thread before the fix. Soft tip: PromptMake /text helps when you need a labeled debug scaffold from a rough note; you still paste the stack trace yourself.

Run Instant when the bug is local and the file is under a few hundred lines. Escalate to GPT-5.6 Sol when the failure crosses modules, involves timing, or needs a ranked set of root-cause candidates. Both still fail if you omit Expected behavior and DO_NOT_MODIFY.

Symptom, repro, and hypothesis first

Debug plan pattern (run before any diff):

TASK: Diagnose BUG. Do not write production code yet.

BUG: [symptom]. Repro: [steps]. Expected: [behavior]. Actual: [what you see].

LOG: [paste truncated stack trace or assertion]

OUTPUT: 1) Hypothesis in 3 sentences. 2) Files that likely contain the fault (paths only). 3) Files to leave alone. 4) One test or check that would prove the fix. 5) Open questions marked [NEED CONTEXT]. Cap at 200 words.

Read the hypothesis out loud. Cross out files you will not allow. Then send the fix prompt with OUTPUT set to unified diff only.

Diff-only fix and test lock

Unified diff pattern:

TASK: Fix BUG. OUTPUT: unified diff only. No full file. No markdown fences around extra commentary except a 3-sentence hypothesis above the diff.

BUG: [symptom]. Repro: [steps]. Expected: [behavior].

FILES_IN_SCOPE: [path]. DO_NOT_MODIFY: [schemas, public APIs, tests you will write in a later pass].

If the root cause is outside scope, stop. Do not patch callers you did not name.

Test pattern (second message after you accept the diff):

TASK: Add or update tests that fail on the old bug and pass with the diff. OUTPUT: the test file or a diff against the test file. Use [test runner] style already in STACK. Cover the repro steps. Do not test private helpers I did not expose. Name the test after the bug, not after the function.

If Instant returns a whole file, send one follow-up: "Rewrite as unified diff against the paste. No full file." Then run TESTS on your machine. ChatGPT cannot see your CI unless you paste logs.

Refactor and review kits

Refactor and review are the other two jobs that keep ChatGPT useful after the bug is closed. A refactor without a behavior lock turns into a rewrite. A review without FOCUS turns into empty praise. Both kits reuse the same STACK and DO_NOT_MODIFY sheet from the debug section. You swap TASK and OUTPUT. You keep public APIs and test names stable so Instant and Sol do not invent a new module layout mid-thread.

Split threads: one for the refactor plan, one for the diff, one for the PR review. A plan that also dumps a 200-line rewrite hides the decision you needed: which files, which tests, which risk. Soft tip: if the rough ask is "clean this up," open https://promptmake.net/text once, generate a ROLE / TASK / FORMAT scaffold with BEHAVIOR_LOCK, then fill paths yourself.

Pick Instant for small readability refactors inside one file. Pick GPT-5.6 Sol when the refactor crosses modules or when the review needs ranked Blocking issues on a long diff. Neither replaces running the suite on your machine.

Behavior-locked refactor prompts

Refactor plan pattern:

TASK: Propose a refactor plan for [function or module] for [readability | performance | structure]. Do not write production code yet.

BEHAVIOR_LOCK: Public API unchanged. Existing tests must pass unchanged.

OUTPUT: 1) Goal in 2 sentences. 2) Files to touch. 3) Files to leave alone. 4) Risks (2 bullets). 5) [NEED CONTEXT] questions. Cap at 200 words.

Implementation pattern after you approve the plan:

TASK: Implement the approved refactor. Change only FILES_IN_SCOPE. BEHAVIOR_LOCK still holds. OUTPUT: unified diff. List any behavior you had to change; that list should be empty. No drive-by renames. No new dependencies. No comments that restate the code.

If Sol proposes a signature change, reject it unless you asked for an API change in TASK. Keep the house style: match existing names and error patterns.

PR review with Blocking vs Optional

Review pattern:

ROLE: Senior [language] reviewer. TASK: Review the PR diff below. FOCUS: [correctness | security | API | performance]. OUTPUT: Summary (2 sentences). Blocking (must fix). Optional (nits). Questions ([NEED CONTEXT] if the diff lacks a test or a contract). Ban praise stacks. Ban "looks good" with no evidence. Cite file:line from the paste.

Paste the git diff, not the whole branch. GPT-5.6 Sol ranks Blocking vs Optional with more care than a vague "review this." Instant still works if FOCUS is one concern and the diff is under a few hundred lines.

Security FOCUS example: "Flag injection, auth gaps, and secret handling. Ignore style nits unless they hide a bug." API FOCUS example: "Flag breaking signature changes and missing error cases. Ignore formatting." One FOCUS per review pass beats a kitchen-sink ask.

Mistakes that wreck ChatGPT coding chats

Mistake 1: Pasting a whole component and writing "fix this" with no repro. ChatGPT rewrites the file. You spend the next hour restoring imports. Add BUG, Repro, Expected, and OUTPUT: unified diff.

Mistake 2: Asking for tests in the same message as a production diff. ChatGPT mixes fixtures into app code or skips tests. Split: diff first, tests second, or tests first if you want red-green.

Mistake 3: Leaving FILES_IN_SCOPE empty. ChatGPT adds utils.ts and a new package. Name paths. Name DO_NOT_MODIFY for lockfiles, generated clients, and public types.

Mistake 4: Routing a multi-file contract bug to GPT-5.5 Instant and accepting the first patch. Instant is the daily driver. GPT-5.6 Sol fits the merge-risk pass.

Mistake 5: Padding prompts with "think step by step" on GPT-5.6 Sol. Give goal, constraints, format. Drop CoT slogans unless you measured a gain on that task.

Mistake 6: Treating a review as a compliment request. FOCUS plus Blocking / Optional plus file:line citations. Empty praise wastes a paid ChatGPT turn.

Mistake 7: Dumping Claude Project rules or Cursor agent instructions into ChatGPT without a ChatGPT-shaped OUTPUT. This article stays on ChatGPT paste. Claude coding kits and IDE agent rules belong on their own pages.

Mistake 8: Trusting ChatGPT on secrets. Strip tokens, customer data, and private keys from pastes. Ask for structure on logs you redacted.

Model notes for ChatGPT coding (mid-2026)

As of mid-2026, ChatGPT often defaults to GPT-5.5 Instant for fast chat. Instant fits first-pass debug plans, small unified diffs, and short reviews when STACK is short. Keep prompts short: ROLE, TASK, FORMAT, STACK, RULES. Few-shot a house diff if format slips.

GPT-5.6 Sol fits harder coding loops: tangled bugs, multi-file refactors with BEHAVIOR_LOCK, and Blocking / Optional reviews on longer diffs. Give goal, constraints, and format. Repeat DO_NOT_MODIFY. Use [NEED CONTEXT] so Sol stops instead of guessing.

Terra and Luna appear in OpenAI menus for other workloads. For day-to-day coding paste in ChatGPT, Instant and Sol cover the jobs on this page. Hedge on exact picker labels; vendor UIs shift. Re-check the model menu when you open a new thread.

Claude Sonnet 5, Claude Opus 5, and Claude Fable 5 remain strong coding models in claude.ai. Use them when your team standardizes on Anthropic. This guide does not replace the Claude coding article. Cross-model "AI prompts for code" encyclopedias cover shared patterns; here the dialect is ChatGPT.

Prompting split that holds: Instant gets RTF plus a short sample of your house diff style. GPT-5.6 Sol gets goal + constraints + format, with [NEED CONTEXT] and no CoT padding. Neither replaces running TESTS on your machine. ChatGPT cannot see your CI unless you paste logs.

Build coding prompts with PromptMake /text

Write the rough ask in plain words: language, bug or refactor or review, diff vs tests vs Blocking list, files in scope. Open https://promptmake.net/text and generate a structured prompt once. Expect labeled sections you can fill with STACK, BUG, and FILES_IN_SCOPE.

Edit paths, test commands, and public APIs yourself. PromptMake cannot see your repo. Paste the filled prompt into Instant for drafts or GPT-5.6 Sol for merge-risk work. Keep free-tier runs for scaffolding. Guests get about three runs per day; free accounts get about five.

Workflow that sticks: STACK sheet → PromptMake scaffold → fill files and repro → Instant plan or small diff → GPT-5.6 Sol for the hard patch or review → run tests on your machine → human read of the diff. Store one wrapper per repo so you do not rewrite ROLE and RULES each morning.

FAQ

What are the best ChatGPT prompts for coding in 2026?

The best ChatGPT prompts for coding lead with STACK, TASK, FILES_IN_SCOPE, DO_NOT_MODIFY, OUTPUT, and TESTS. Demand one artifact: debug hypothesis, unified diff, behavior-locked refactor, or Blocking / Optional review. Add [NEED CONTEXT] so ChatGPT stops instead of guessing. Match GPT-5.5 Instant for volume and GPT-5.6 Sol for merge-risk work.

Should I pick GPT-5.5 Instant or GPT-5.6 Sol for coding?

Pick Instant when the bug is local, the file is short, and you need a first-pass plan or small diff. Pick GPT-5.6 Sol when the failure crosses modules, the refactor needs a hard BEHAVIOR_LOCK, or the review needs ranked Blocking issues. Both need the same paste stack; tier choice does not replace FILES_IN_SCOPE.

How do I get ChatGPT to output a unified diff?

Set OUTPUT to unified diff only and ban full-file rewrites in RULES and REMINDER. Name FILES_IN_SCOPE. Paste the current file excerpt or git diff so ChatGPT has a base. If Instant still returns a whole file, send one follow-up: "Rewrite as unified diff against the paste. No full file."

Can ChatGPT write tests from a prompt?

Yes when you name the runner, the repro, and the test file path. Run tests as a second pass after you accept the production diff, or first if you want a failing test before the fix. Ban tests of private helpers you did not expose. ChatGPT still cannot run your suite unless you paste results.

How do I use ChatGPT prompts for coding on a PR review?

Paste the git diff, not the branch. Set ROLE to senior reviewer, FOCUS to one concern, and OUTPUT to Summary, Blocking, Optional, and [NEED CONTEXT] questions. Ask for file:line citations and skip empty praise. GPT-5.6 Sol fits this job; Instant fits short diffs with one FOCUS.

How is this different from Claude prompts for coding?

This page targets ChatGPT with GPT-5.5 Instant and GPT-5.6 Sol, plus debug, refactor, and review kits shaped for that UI. The Claude coding guide targets Fable 5, Opus 5, and Sonnet 5 paste stacks in claude.ai. Shared ideas exist (STACK, diff-only, Blocking / Optional). Keep the libraries apart so your team reuses the wrapper that matches the chat product you open.

How do I start with free ChatGPT and PromptMake?

Write STACK and one BUG in a notes file. Open PromptMake /text at https://promptmake.net/text, generate a coding scaffold, fill FILES_IN_SCOPE, and paste into ChatGPT Instant (or Sol if your plan includes it). Guests get about three PromptMake runs per day; free accounts get about five. Spend those runs on the wrapper, then iterate inside ChatGPT.