What this covers
Editing a 1200-word essay inside a chat window is miserable — the model rewrites the whole thing every turn, you lose track of which paragraph changed, and the surrounding conversation scrolls past the part you actually care about. Canvas is ChatGPT’s split-view editor: the document lives on the right, the chat lives on the left, and you can tell the model “edit just this paragraph” without it regenerating the whole piece. This guide is for people who write or refactor in ChatGPT and keep getting frustrated that the chat-only loop is the wrong shape for the work.
Who this is for
Writers polishing a draft, engineers refactoring a 200-line function, PMs iterating on a one-pager, anyone who has caught themselves copy-pasting between ChatGPT and a Google Doc twelve times because the chat keeps losing the prior version. If your output is one paragraph, stay in chat. If your output is more than half a page and will be revised three or more times, switch to Canvas.
When to reach for it
- Iterating on a draft longer than 400 words where you want paragraph-level edits, not full rewrites.
- Refactoring code where you want the model to keep the function signature stable across turns.
- Writing something where you’ll want to compare versions — Canvas keeps a version history per document.
- Collaborating with the model on structure: outline, then expand section by section, without losing the outline.
Before you start
- Open Canvas explicitly via the toolbar (or ask “open this in canvas”) — ChatGPT does not always switch automatically.
- Decide upfront whether this is a writing canvas or a code canvas. Code-mode unlocks the run/review affordances; writing-mode unlocks tone and length sliders.
- Have your source material ready before opening Canvas. Once you’re in the document view, pasting reference text gets awkward.
- Pick a model strong enough for the task: GPT-5 for structural rewrites, GPT-5.5 for general editing, GPT-5.4 only for quick polish.
Step by step
-
Start the conversation in chat. Get the outline and rough draft done in the chat loop where it’s cheap to throw stuff away.
-
Once you have a draft worth keeping, switch to Canvas:
Open this draft in canvas so I can edit it paragraph by paragraph. -
Highlight (select) the paragraph you want to change, then prompt against the selection:
Tighten just this paragraph by 30%. Keep the example about the 1200-word essay. Do not touch the surrounding paragraphs. -
For code Canvas, ask for a targeted change with the function boundary called out:
Refactor the parseTransactions function to use a single pass instead of two. Keep the signature and return type unchanged. Do not modify the helper functions below it. -
Use the version arrows (top of the document) to compare. If a revision lost something important, roll back rather than asking the model to put it back from memory.
-
Copy the final version out to your real document — don’t treat Canvas as the source of truth for anything that has to ship.
A prompt that keeps Canvas edits surgical
Edit only the highlighted text. Constraints:
- Keep the surrounding paragraphs untouched.
- Preserve the example, the numbers, and the structure of the
sentence after the highlighted one.
- If a change requires touching adjacent text, stop and ask
before doing it.This is the single biggest improvement to my Canvas hit rate — it dramatically reduces “helpful” rewrites of paragraphs I didn’t want touched.
Quality check
- Diff against the previous version. If you can’t tell what changed, the edit was too broad.
- Re-read the paragraphs adjacent to the edited one — Canvas sometimes leaks edits across the boundary.
- For code: run it. Canvas’s inline review is not a substitute for actually executing the function.
- Check that links, citations, and numbers survived the edit. Canvas drops these more than chat does.
How to reuse this workflow
- Save a
canvas-edit-prompts.mdwith your top 5 selection-scoped prompts (tighten, expand, simplify-tone, add-example, fact-check-this-paragraph). - For recurring document types — weekly updates, release notes, retros — keep a starter Canvas you duplicate and edit, instead of starting from blank each time.
- For code refactors, keep a separate Canvas per file. Cross-file refactors are where Canvas’s context starts to leak.
Recommended workflow
Draft in chat → open in Canvas → highlight → scoped prompt → diff against prior version → roll back if it overreached → copy final to real document.
Common mistakes
- Starting in Canvas before you have a draft. The empty-document mode produces worse first drafts than chat does.
- Not highlighting before editing. An unscoped prompt rewrites the whole document and silently drops things you wanted kept.
- Treating Canvas as a real word processor. It has no comments, no track changes, and no real collaboration — copy out to Docs or Notion when you’re done.
- Editing in Canvas with a weak model. GPT-5.4 will preserve less of the surrounding context than GPT-5 or GPT-5.5.
- Ignoring the version history. If you lost a good sentence two edits ago, roll back — don’t ask the model to “remember it.”
- Pasting a 4000-word document into Canvas and expecting paragraph-level edits to work cleanly. Canvas degrades on very long documents; split the work.
FAQ
- Does Canvas work with every model?: It works with the current generation reasoning and chat models but not with the cheapest fast tier in some configurations. If the toolbar option is missing, switch models.
- Can I import a file directly into Canvas?: You can paste content in or ask the model to open a chat message in Canvas. Direct file-to-Canvas is hit or miss; paste the text body and have the model format it.
- Why did Canvas rewrite a paragraph I didn’t highlight?: Usually because the prompt mentioned the surrounding context. Re-prompt with explicit “do not touch the other paragraphs” language.
- Is Canvas safe for confidential content?: Same data policy as the rest of ChatGPT — check your plan’s settings. Don’t paste anything into Canvas you wouldn’t paste into chat.