Asking ChatGPT to “write a function” works for one-off snippets and breaks the moment you point it at a real codebase. The difference is not the model — GPT-5.5 is genuinely strong at code — it is the workflow around it. ChatGPT cannot edit your files, run your test suite, or see your installed package versions the way an agent like Claude Code can. This guide is the repeatable process I use to ship real features through a chat window anyway.
TL;DR
- ChatGPT (GPT-5.5, default since April 23, 2026) is a chat-based coding partner, not a file-editing agent. It reads what you paste; it does not see your repo.
- Use Projects to hold reference files, custom instructions, and related chats in one workspace. Plus uploads up to 25 files per project; Free 5; Pro 40 (as of June 2026).
- Pick the right model variant: Instant for quick edits, Thinking for design and debugging that needs reasoning, Pro ($200 tier) for the gnarliest problems.
- Work in small chunks, ask for a plan before code, and always run the result locally. ChatGPT writes plausible code that fails on details it could not see.
Who this is for
Developers who use ChatGPT as their main AI coding assistant (no Cursor or Claude Code subscription), or who reach for it on languages and frameworks their primary agent struggles with. It also fits anyone on the Free or $8 Go tier who wants a disciplined process instead of slot-machine prompting.
What ChatGPT can and cannot do for coding (June 2026)
GPT-5.5 became the ChatGPT default on April 23, 2026, exposed through a three-way picker: Instant (fast, the default), Thinking (extended reasoning), and Pro (reserved for the $200 Pro and Enterprise tiers). On benchmarks GPT-5.5 posts 82.7% on Terminal-Bench 2.0 and 58.6% on SWE-bench Pro — competitive with Claude Opus 4.7 and Gemini 3.1 Pro, and strong enough that the model is rarely your bottleneck.
The bottleneck is context and execution. ChatGPT in the browser is not an agent: it cannot open your files, edit them in place, or run your tests against your dependencies. A few specifics worth knowing as of June 2026:
| Capability | What ChatGPT gives you | The catch |
|---|---|---|
| Code editing | Code blocks in chat (Canvas was folded into inline code blocks for GPT-5.5 Instant/Thinking) | You copy-paste in and out; it never touches your repo |
| Running code | Python runs in the browser sandbox via code interpreter | No access to your packages, services, or env vars |
| File context | Projects hold uploaded reference files; Plus 25 / Free 5 / Pro 40 per project | Pasted context only; it does not browse your tree |
| Context window | Instant ~32K on Plus, Thinking 256K when manually selected | Full 1M in-app context is only on the $200 Pro tier |
If you need true multi-file edits against a live repo, that is an agent’s job — use Cursor or Claude Code instead (more in Cursor vs Claude Code).
When to reach for ChatGPT, and when not to
Good fit: greenfield prototypes, small utility scripts, learning a new library, debugging an isolated function, generating and explaining tests, translating a function between languages, and rubber-ducking a design before you open your editor.
Wrong tool: multi-file refactors, large legacy codebases, anything that requires reading or editing files across your tree, and tasks where the cost of copy-pasting context exceeds the value. Reach for an agent there.
Set up a Project first
Before the first prompt, spend two minutes on setup. It pays for itself within one session.
- Create a Project (left sidebar). Projects keep related chats, uploaded files, and a shared custom instruction together so the model stays on-topic.
- Upload your reference files — the module you are working in, the relevant types, a sample test. Plus allows 25 files per project as of June 2026; that is enough for most single-feature work.
- Add a project-level instruction once instead of re-typing it every chat. Something like:
Default to TypeScript with strict mode and React function components.
State your assumptions before writing code. Generate one function at a time.
Never invent library APIs — if unsure about a method, say so.Custom instructions set on the Project apply to every chat inside it, which is the single biggest fix for the “it forgot my stack again” problem.
Step by step
- One chat per task, not per project. Long mixed-topic chats degrade fast as old context crowds out the new. Start fresh per feature.
- Paste existing code first, then the goal. Order matters — ChatGPT anchors to whatever it sees first, so lead with the code it must respect.
- State constraints explicitly: language and version, framework and version, which libraries are allowed or banned, and the exact test command. Version-pinning is what stops it from handing you React class components or Python 2 syntax.
- Ask for a plan before code: “List the files you would touch and why, before writing any code.” For design-heavy work, switch the picker to Thinking for this step.
- Generate in small chunks — one function, one component — not whole files. Smaller diffs are easier to review and re-prompt.
- Pressure-test each chunk: “What edge cases does this not handle?” Then have it add them. This single question catches more bugs than any other.
- Run it locally before accepting it. If it fails, paste the exact error and stack trace back and ask for the minimal fix — not a rewrite.
A real example: a loose date parser
Say you need a parseLooseDate(input) that accepts 2026-06-05, 06/05/2026, and June 5, 2026, returning a Date or null.
- In your Project chat, paste the existing
utils/date.tsand its current tests. - Prompt: “Add
parseLooseDate(input: string): Date | nullhandling ISO, USMM/DD/YYYY, and long-formMonth D, YYYY. No new dependencies. List your plan first.” - Confirm the plan, then ask for the function only.
- Ask: “What inputs break this? Ambiguous
01/02/2026, two-digit years, trailing whitespace?” Have it harden the function. - Ask for table-driven tests, then run them locally. ChatGPT-written tests frequently assert against APIs that do not exist, so a green run is the only proof that counts.
Common mistakes
- Dumping a 2000-line file and saying “find the bug.” ChatGPT pattern-matches across that much text; it does not actually trace execution. Narrow it to the suspect function plus the error.
- Skipping the plan step and going straight to code, then re-prompting endlessly to fix a design that was wrong from the start.
- Omitting the framework version, then fighting hooks-vs-class-components and dead syntax.
- Trusting the tests it wrote. They often hallucinate methods on your libraries. Run every one.
- Treating context as unlimited. On Plus, Instant carries ~32K tokens; a huge paste silently pushes your earlier instructions out of the window. Use a Project file instead of re-pasting.
Advanced tips
- For unfamiliar libraries, paste the actual README or API page (or upload it to the Project). This is the most reliable cure for hallucinated APIs, because the model is no longer guessing the version.
- When debugging, include the full error and stack trace, never a paraphrase. The line numbers and frame names are signal.
- Use Thinking for design, Instant for typing. Switch the picker to Thinking for architecture and tricky bugs, then back to Instant for mechanical edits to save time and rate limits.
- Run Python in the sandbox to sanity-check pure logic (parsing, math, regex) before you wire it into your app. It will not reach your services, but it proves the algorithm.
Copy-ready prompt
Language: [lang] [version]
Framework: [framework] [version]
File context: [paste the file the change lives in]
Goal: [one sentence]
Constraints: [libraries allowed/banned, performance, style]
First, list the changes you would make and why.
Wait for me to confirm before writing any code.FAQ
Should I use ChatGPT or Claude for coding? For chat-based coding both are strong; Claude Opus 4.7 leads on long-context reliability and edges ahead on SWE-bench Verified (87.6% vs GPT-5.5’s lead on Terminal-Bench at 82.7%). For agentic file editing, neither chat window is the answer — use Cursor or Claude Code.
Why does it keep hallucinating APIs? It cannot see your installed package versions, so it guesses the most common signature. Pin the version in your prompt, or paste/upload the relevant docs into the Project.
Can ChatGPT edit my files directly? No. In the browser it returns code blocks you copy in and out; it never touches your repo. Canvas was merged into inline code blocks for GPT-5.5. For in-repo edits you need an agent like Cursor or Claude Code.
How big a file can I paste? On Plus, Instant holds roughly 32K tokens of context, so a few hundred lines is safe but a whole large module is not. Switch to Thinking (256K) for bigger work, or upload the file to a Project so it stays in scope without eating the chat window.
Which model variant should I pick? Instant for fast edits and snippets, Thinking for design and reasoning-heavy debugging, and Pro (on the $200 tier) for the hardest problems. Instant is the default and handles most day-to-day coding.
Related
Tags: #ChatGPT #Tutorial #AI coding #Workflow