> ## Documentation Index > Fetch the complete documentation index at: https://docs.vibely.sh/docs/llms.txt > Use this file to discover all available pages before exploring further. # Prompting > Prompt shapes, references, and habits that produce better output across long sessions. [Art of Prompting](/docs/introduction/prompting-best-practices) 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, save them to memory, whatever — they're worth knowing by heart. | Shape | Use it when… | | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | | [Start a new build](#1-start-a-new-build) | The project is empty and you want a strong v1. | | [Make a surgical edit](#2-make-a-surgical-edit) | One file, one change, no adjacent "improvements." | | [Plan before a big change](#3-plan-before-a-big-change) | The change touches 3+ files or risks a regression. Use [Plan Mode](/docs/tips/plan-mode). | | [Anchor a design with references](#4-anchor-a-design-with-references) | The agent is producing generic visuals. | | [Correct a wrong turn](#5-correct-a-wrong-turn) | The 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](/docs/tips/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](/docs/tips/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 project 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](/docs/tips/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 Patterns for staying productive across many turns. What to save and what not to. Codify your build recipes, invoke them from the composer. What to do when the loop breaks down.