Skip to main content
Art of Prompting is the starter. This page is the deep cut — the patterns that come from long-form sessions, the failure modes that repeat, and the prompt shapes that just work. TL;DR
  • Five shapes cover most of what you’ll prompt — pick the one that matches what you’re doing.
  • Be specific early; reverts beat patches; pin invariants you keep re-saying.
  • When a prompt shape stops working, the bottleneck is usually stale chat context or the wrong model — not the prompt.

​
Five prompt shapes that earn their keep

The shapes below cover most of what you’ll want to do in a typical session. Print them out, paste them into your custom instructions, whatever — they’re worth knowing by heart.
ShapeUse it when…
Start a new buildThe project is empty and you want a strong v1.
Make a surgical editOne file, one change, no adjacent “improvements.”
Plan before a big changeThe change touches 3+ files or risks a regression. Use Plan Mode.
Anchor a design with referencesThe agent is producing generic visuals.
Correct a wrong turnThe last turn went sideways and you know why.

​
1. Start a new build

Build a {kind of app} for {specific user persona}.

They need to:
  - {primary job}
  - {secondary job}
  - {nice-to-have}

Stack: {if you care; otherwise omit}.
Feel: {three brand references}.
This shape forces specificity on the four levers that matter most: user, jobs, stack, feel. If you can’t fill in the persona, you’re not ready to start the project.

​
2. Make a surgical edit

In {specific file or component}, {one specific change}.
Don't change anything else.
This stops the agent from “improving” adjacent code, which is the single biggest source of regressions on long projects.

​
3. Plan before a big change

Plan how we'd {large change}. Read the relevant code first.
List the files you'd touch and the order. Don't write code yet.
Followed by: 
Looks good — implement it.
Or, when the plan is wrong: 
Skip step 3 and revise step 4 to {alternative}. Then implement.
The two-step plan-then-implement loop catches misunderstandings before they become 5-turn rabbit holes. See Plan Mode for what’s available and what isn’t during the planning turn.

​
4. Anchor a design with references

Build the {screen} to feel like the love child of {brand 1} and {brand 2},
but with {distinctive twist}.
Use {colour or font} as the through-line.
Concrete references plus a distinctive twist gives you something specific instead of “another premium dark dashboard.”

​
5. Correct a wrong turn

The {thing} doesn't work because {specific reason / error / observation}.
Revert your last change to that file and try a different approach: {hint}.
Naming why it’s wrong and pointing at a different approach beats “fix the bug you just introduced” by miles.

​
Habits across a long session

​
Save state to memory whenever you’ve decided

The moment you’ve committed to a design decision, save it. Memory survives compaction; chat history doesn’t.
“Save to memory: this is B2B for finance teams. Never use playful copy, never use emoji, always require login.”
See Memory for what belongs there and what doesn’t.

​
Confirm what’s good

When the agent gets something right, say so. “Yes — that’s exactly the pattern I want, keep it.” Confirmations get picked up the same way corrections do, and you stop the agent from second-guessing a good answer.

​
Roll back, don’t patch

A failed turn is best undone, not bandaged.
“Revert the last change to pages/Settings.tsx and try again with [different approach].”
Reverts are clean. Patches accumulate cruft and confuse future turns.

​
Use the “if you can’t, ask” prompt

If you're not sure about X, ask me before guessing.
Saved into custom instructions or memory, this single rule prevents most “the agent invented something weird” failures.

​
Reading the response

The agent shows you its work as it goes. Skim it.
  • File writes — what’s changing. Quick scan to confirm the agent is touching what you expected.
  • Tool calls — what it’s looking up (search, image gen, web fetch). If it’s about to fetch from the wrong source, this is your chance to interrupt.
  • Inline reasoning — short notes on why. Often surfaces a hidden assumption you can correct.
If the response is wrong, the reason it’s wrong is usually visible in this stream before the code lands.

​
Anti-patterns that consistently waste turns

  • “Make it better.” No information. The agent will make small unrelated changes and you’ll be no closer.
  • “Refactor everything.” Big refactors are best done as a plan-first prompt, then implemented in stages.
  • Asking for clean architecture as an afterthought. “Refactor this into clean architecture” produces a worse codebase than building cleanly from turn one. If architecture matters, name the pattern in the original prompt.
  • Vague visuals. “Modern”, “clean”, “premium” — useless. Replace with three references.

​
When the prompt-quality lever fails

If a prompt shape that usually works isn’t producing the right output, the bottleneck is usually one of:
  • Stale chat context — start a fresh chat with the lessons summarised. See Iterating → When to start over.
  • Wrong model for the task — pin a different one from the model picker in the chat composer.
  • The actual code is in a knot — fix the code, not the prompt. Ask the agent to plan a refactor.

​
Next

Iterating

Patterns for staying productive across many turns.

Memory

What to save and what not to.

Custom instructions

Codify your habits once, never type them again.

Troubleshooting

What to do when the loop breaks down.