---
title: "Vibe coding prompts: a 5-step method with examples"
description: "Context, task, constraints, plan, verification: how to write vibe coding prompts that work the first time, with 5 templates you can copy and paste."
url: "https://vibe-code.blog/en/vibe-coding-prompts"
lang: "en"
author: "Thierry Gustin"
published: "2026-08-21"
updated: "2026-11-21"
---

# Vibe coding prompts: a 5-step method with examples

> **Key takeaways** — A good vibe coding prompt gives the AI context (who and what it's for), a precise task with clear boundaries, concrete constraints, a request for a plan before any code, and a way to check the result. Make one change at a time and, after two failed corrections, start over with a fresh prompt instead of pushing on.

An effective vibe coding prompt has five parts: context, task, constraints, a request for a plan, and a way to verify the result. It's not a magic formula; it's what the Lovable, Bolt and Claude Code docs recommend, pulled together into one method. Here are the 5 steps, five templates ready to copy, and the mistakes that send the AI in circles.

## Why your prompts don't get you what you want

The AI can't read your mind: it fills the gaps with defaults. Anthropic's Claude documentation suggests thinking of the model as a brilliant new employee who knows nothing about your norms or your project. The more precisely you explain what you want, the better the result.

It also offers a simple test: show your prompt to a colleague with minimal context on the task and ask them to follow it. If they'd be confused, the AI will be too.

The three most common reasons prompts fail:

1. **Too vague**: "build me a booking app" lets the AI invent the users, the screens and the rules.
2. **Too big**: asking for ten features at once gets you mediocre results everywhere and bugs that are hard to isolate.
3. **No finish line**: if you don't say what "done" looks like, the AI stops whenever it thinks it's finished.

## The 5-step method

The method is to write each prompt in five blocks, always in the same order. For a small tweak, two or three blocks are enough. For a new feature or the first prompt of a project, use all five.

### Step 1: set the context

Start by saying what the product is, who it's for and what it's used for. Lovable recommends answering four questions first: what the product is, who it's for, why they'll use it, and the one key action they should take.

Example: "Inventory tracking app for a small corner shop. Users: the owner and two staff. Key action: log a delivery in under a minute."

Permanent context (stack, brand guidelines, rules) is best written once in a spec and in the tool's project instructions. That's what [writing a PRD your AI builder understands](https://vibe-code.blog/en/prd-for-ai-builders) is about.

### Step 2: describe a precise task and its boundaries

Say what to build, where it goes, and what must not change. Lovable's docs advise naming the boundaries explicitly, such as "only change the orders page" or "keep the existing styling." Bolt's docs say to be explicit about what should and shouldn't change.

For a bug, the Claude Code docs give the recipe: name the file or screen, describe the symptom, and say what "fixed" looks like up front. That usually saves you a round of corrections.

### Step 3: spell out concrete constraints

Say what makes the result acceptable: format, style, edge cases. Lovable suggests three habits:

- **Real copy, not placeholder text**: a real headline and real prices expose layout problems early.
- **Proper UI vocabulary**: card, badge, modal, tab. "One card per product with a red badge when stock is low" beats "show the products nicely."
- **The states people forget**: logged in or out, empty list, loading, error.

When order matters, number the steps. Anthropic recommends giving instructions as numbered steps whenever order or completeness is important.

### Step 4: ask for a plan before the code

End your prompt by asking the AI to raise its questions and propose a plan before coding. Lovable notes that its plan mode works especially well for this. Bolt has a Plan Mode where you can "plan and ask questions without making changes to your code," with a button to implement the plan once you approve it.

If you don't know exactly what you want yet, flip the roles. The Claude Code docs suggest asking the agent to interview you until it could write the spec to a file, then starting a fresh session to build from it.

### Step 5: set a way to verify the result

Say how you'll know it worked, and ask for evidence. The Claude Code docs are firm on this: ask for the command the agent ran and its output, or a screenshot, because "all tests pass" on its own tells you very little.

In an app builder without tests, the check can be a scenario: "I should be able to create a product, see it in the list, edit its stock, and see the red badge appear below 5 units."

> **One change at a time** — Bolt and Lovable give the same advice: make one change at a time and check it works before moving on. It's the single rule that prevents the most cascading bugs.

## Before and after: the same prompt, rewritten

Here's what the method does to a real request.

**Before**:

```text
Add a booking system to my site.
```

**After**:

```text
Context: website for a yoga studio in Austin, 3 classes a week, 12 spots max per class.
Students book from their phones.

Task: add a "Book" page listing classes for the next 14 days.
Don't change the home page or the menu, except to add the "Book" link.

Constraints:
1. Each class is a card with the date, time and number of spots left.
2. When a class is full, the button turns gray and reads "Full".
3. Students give their first name and email to book, no account needed.
4. Handle the case where no classes are scheduled.

Before coding: ask me your questions, then propose a plan in 5 points or fewer.

Done when: I can book a spot, see the counter go down,
and can no longer book when 0 spots are left.
```

The second prompt is longer, but it saves three or four rounds of fixes.

## Five prompt templates to copy

These templates cover the most common situations. Replace whatever is in brackets.

### The first prompt of a project

```text
I want to build [type of app] for [users].
Problem it solves: [one sentence].
Features for the first version:
1. [feature]
2. [feature]
3. [feature]
Out of scope for now: [what you don't want].
Style: [2 or 3 words, e.g. clean, easy to read on a phone].
Before coding, ask me any questions you need answered, then propose a plan.
```

### Adding a feature

```text
Add [feature] to [screen or page].
Don't change [what must stay as is].
Expected behavior: [2-3 sentence scenario].
Cases to handle: empty list, invalid input, logged-out user.
Explain your plan before changing any code.
```

### Fixing a bug

```text
Bug on [screen]: when I [action], I get [symptom] instead of [expected result].
Error message: [paste the full message].
What changed just before: [last change].
Find the cause before fixing it, explain it in 3 lines, then fix it without touching anything else.
```

### Changing the design

```text
On [page], change only the look, not the behavior.
Goal: [e.g. more breathing room, more premium, easier to read on mobile].
Keep the colors [codes or names] and the current font.
Show me what you'll change first.
```

For a small visual detail, Lovable suggests selecting the element in the preview rather than writing a prompt about the whole page.

### A review before going live

```text
Review the project as a developer in charge of security.
Without changing anything, list:
1. Any keys or secrets visible in the browser.
2. Any data one user could see that belongs to another user.
3. Any forms without validation.
Rank the issues from most to least serious.
```

That last prompt doesn't replace a real check: pair it with the [pre-launch security checklist](https://vibe-code.blog/en/vibe-coding-security).

## When the AI goes in circles: what to do

When the AI hasn't fixed something after two attempts, stop pushing and start over with a fresh prompt. The Claude Code docs say it plainly: after two failed corrections, a third mostly adds to a conversation that already contains two failed attempts. You're better off clearing the context and writing a better prompt that folds in what you learned.

Moves that get you unstuck:

1. **Roll back to the last working version** instead of stacking fixes.
2. **Paste the full error message**, not a summary.
3. **Ask for the cause before the fix**: "explain why this crashes before you touch the code."
4. **Narrow it down**: if a feature fails, isolate the smallest part that breaks.
5. **Start a new conversation** with a prompt that sums up the context and what failed.

## The most common prompt mistakes

| Mistake | What happens | Fix |
| --- | --- | --- |
| "Build an app that…" with no context | The AI invents users and screens | Step 1: who, what, why |
| Ten features in one prompt | Mediocre results, tangled bugs | One feature per prompt |
| No boundaries | The AI rewrites parts that worked | "Don't change…" |
| No finish line | The AI stops too early or overdoes it | "Done when…" |
| Fixing in a loop in the same chat | The AI gets bogged down | Roll back, write a fresh prompt |
| Vague words ("nice," "modern") | Generic output | Precise UI vocabulary |

Other traps beyond the prompt are covered in [12 mistakes that sink vibe coding projects](https://vibe-code.blog/en/vibe-coding-mistakes). And to see where prompting fits in the whole process, from scoping to deployment, read [the complete vibe coding guide](https://vibe-code.blog/en/vibe-coding-complete-guide).

## Does the method work with every tool?

Yes, the method works with every vibe coding tool, because it relies on what all models use: context, a clear task and a finish line. Only the names change: plan mode in [Lovable](https://lovable.dev/) and [Bolt](https://bolt.new/), spec files and commands in [Claude Code](https://www.anthropic.com/claude-code) or Cursor. To pick your tool, see [the complete comparison of vibe coding tools](https://vibe-code.blog/en/best-vibe-coding-tools).

## Frequently asked questions

## Frequently asked questions

### Do vibe coding prompts have to be in English?

No. Vibe coding tools handle many languages well, and a precise prompt in your own language beats a vague one in English. Write in whichever language you're most precise in. Just state the interface language if it differs, for example a Spanish-language app built from English prompts.

### How long should a vibe coding prompt be?

The right length is whatever leaves nothing important to guess. A color tweak fits in one sentence. A new feature often takes 8 to 15 lines: context, task, boundaries, edge cases, plan, finish line. Beyond that, it's usually a sign you should split the request into several prompts in a row.

### Can you ask the AI to improve your prompt?

Yes. Bolt has an "Enhance prompt" feature that asks you guided questions and then generates a richer version of your request, which you can edit. With any tool, you can also write: "Before coding, restate my request and ask me any questions you need answered." Always read the rewritten version before approving it.

### What should you do when the AI breaks something that worked?

Roll back to the last working version using the tool's history or Git, rather than asking for a fix on top. Then redo your request with an explicit boundary, such as "don't change the login page." That's exactly why you should save every step that works.

### Can one prompt build an entire app?

One prompt can generate a visible first version, but not a reliable app. Every tool recommends moving in steps and checking each change. The most effective approach: a short spec for the frame, a first prompt for the structure, then one prompt per feature, tested before you move on.

## Sources

- [Prompting best practices — Lovable Docs](https://docs.lovable.dev/prompting/prompting-one)
- [Prompt effectively — Bolt Support](https://support.bolt.new/prompting/prompting-effectively)
- [Plan Mode — Bolt Support](https://support.bolt.new/prompting/plan-mode)
- [Best practices for Claude Code — Claude Code Docs](https://code.claude.com/docs/en/best-practices)
- [Prompting best practices — Claude Platform Docs](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices)
- [What is vibe coding? — Google Cloud](https://cloud.google.com/discover/what-is-vibe-coding)

— Thierry Gustin, Formateur en intelligence artificielle (GustinAI) · November 21, 2026
