Prompt-to-app tools like Bolt.new and Lovable have taken off in the last few months, ushering us into the era of “vibe coding.” While these tools are powerful, a bit of prompting work can lead to better outcomes and help you get out of jams.
Prompting isn’t rocket science, but a few practical tips can help you get the most out of these new AI app builders.
If you’re using any of these no-code app builders, here are a few things to keep in mind.
Before diving into the details, all the prompt examples are available for free in this group on PromptHub.
Structure your prompt with context, task, and details
One of the best ways to ensure the AI understands your request is to structure your prompt clearly. Instead of throwing out a single sentence about the app you want built, break your prompt into sections that cover the context (what you’re building), the specific task at hand, any guidelines or style preferences, and constraints (things that must or must not happen).
This might feel like a little overkill but it has 2 benefits:
- It will help the model better understand what you want,
- It will make you think through a little more about what you want to build.
You don’t need to follow this structure exactly—it’s more of a useful starting point. You can always take your half-formed idea and have ChatGPT convert it into this clear, structured format.
For example, here’s how a prompt for starting a new project might look when you combine context, requirements, and a clear first task (inspired by Lovable’s documentation):
State key requirements up front
When kicking off a brand-new app idea, it can be helpful to mention all your major requirements in the initial prompt. For example, what platforms your app needs to support (web, mobile, CMS, etc.), user roles, core features, design preferences, and even anticipated scale (users or data). Thinking this through from the start can help save time down the line, and even save you from needing to completely restart your project. Below is an example prompt from this Reddit thread in the Bolt subreddit.
Laying these out up front helps Bolt or Lovable atleast start to think about architectural decisions early on so you don’t run into problems later.
Listing requirements like this not only informs the AI, but also helps you organize your thoughts about what the app should do. Essentially, you’re writing a mini project brief.
Pro Tip: If you’re using Bolt.new, take advantage of its Prompt Enhancer feature to flesh out your initial idea. You can start with a simple description, then click the enhancer to automatically generate a more detailed prompt
Be specific and avoid vague language
The first best practice listed in our first article (10 Best Practices for Prompt Engineering with Any Model) is be specific!
When it comes to prompt engineering clarity is king. Vague prompts will produce vague results. Here's a nice example from Lovable.
Being specific also means using the proper names for technologies or libraries when relevant.
If your app should use React, or you want to use Tailwind CSS design, mention that explicitly in your prompt.
Both Bolt and Lovable are capable of working with various frameworks and services, but they only will if you tell them to.
You’re effectively the “product manager” here – the clearer your requirements, the closer the AI’s output will match your intent.
Include constraints and “don’ts”
Just as you tell the AI what to do, it’s often helpful to tell it what not to do. Adding constraints in your prompt can prevent the AI from going off track and editing components you don’t want it to. For example, if you want to tweak the UI but not the underlying logic
Here are a few kinds of constraints you might include in your prompts:
- Scope limits: E.g. “Please refrain from modifying the homepage; focus only on the dashboard component.
- Performance or size limits: E.g. “Use at most 4 API calls for this feature,”
- Tech constraints: E.g. “Do not use any paid libraries,”
- Don’t change X: If there’s something that must remain untouched, mention that. For instance: “Optimize the code in this component, but do not change the UI or core logic – just improve performance”.
It’s usually easier to tell the LLM “don’t do that” upfront than to fix unwanted changes after. Both Lovable and Bolt support this style of prompting. In Bolt, you can even lock files from editing via the interface, but it’s still good to mention constraints in your prompt to be extra clear.
Remember, the AI cannot read your mind – if something is a must-have or a must-not, spell it out in the prompt.
Build in steps and iterate
It’s tempting to try and ask for an entire full-stack app in one prompt, and the tools are good enough to deliver pretty solid and robust apps in one go, but you’ll get better results by breaking the work into smaller steps and working iteratively. You’ll be less likely to get into inescapable situations this way.
In practice, this means you should prompt for one feature or component at a time, see the result, test it, test to make sure it didn’t break adjacent functionality, and then move on to the next.
That said, if you have a few very closely related tweaks, you can batch them into one prompt to save time. For example if you want to change the color of a button, and add mobile responsiveness to a page.
Use LLMs and tools to refine your prompts
1. Meta prompting
You don’t need to write the perfect prompt, because LLMs can help you with that! We’ve written about meta prompting before, and it is a good tool to leverage here.
A common workflow I use is:
- Dump my thoughts to ChatGPT using voice-to-text tool
- Do a little back and forth
- Tell it to write out instructions for another LLM developer I am working with
- Paste into Bolt
Bolt also has a prompt enhancer built into the platform that works quite well, but I’ve found the ability to go back-and-forth with ChatGPT leads to better results.
2. Reverse meta prompting
Lovable notes a pretty interesting technique in their prompting 1.1 resource called reverse meta prompting, here’s how it works.
After the AI completes a task, you can ask it to summarize what it did and generate a reusable prompt.
This not only helps document fixes but also builds a library of prompts for future use. Here’s an example of something you would say after fixing some integration.
3. Lovable’s prompt library
Check out Lovable’s Prompt Library for sample prompts on common scenarios like starting a project, adding features, or tweaking UI elements. You can also check out our group of prompts which contains all the prompts listed in this article. Here are a few examples:
Starting a New Project
UI Only Changes
Mobile responsiveness
Refactoring
Planning a Feature Implementation:
Getting unstuck: Debugging strategies for AI coding tools
Building with these AI code builders can be truly magical, until it’s not. Sometimes it can feel like you’re really ‘stuck’ in a project, especially when it gets to a large scale. It can start to feel impossible to make even the most minor changes. Here are a fwe ways you can get outof a jam:
- Meta Prompting: Use an LLM to refine and enhance your prompt before executing it.
- Reverse Meta Prompting: After resolving an issue, ask the AI to summarize what went wrong and how it was fixed, then generate a reusable prompt for similar future challenges.
- Iterative Prompting: Break down complex tasks into smaller, manageable steps. Work prompt-by-prompt, testing often, and rolling back when necessary.
- Rephrasing and Simplification: When the AI seems stuck, rephrase your prompt to be more focused and detailed.
- Safe Approach for Fragile Updates: For critical or sensitive parts of your project, instruct the AI to proceed with extra caution.
- Handling Persistent Errors: When errors keep recurring, use these four strategies:
- Ask What It Has Tried Already: This will help avoid repeating the same fixes “What solutions have we attempted so far to resolve this integration error?”
- Explain the Error in Simple Terms: Helps give context on the root of the problem (for you and the AI) “Explain in simple terms why this rate formatting error occurs.”
- Consider an Alternate Approach: “Since we keep running into this error, can you suggest a different way to accomplish the goal?
- Revert and Replay: Roll backs are your friend!
- Full System Review (Codebase Audit): When your project becomes large and complex, having the AI review the full codebase can be helpful.
- Performance Optimization Check: If your app is working, but it is slow, you can have the AI analyze performance.
Conclusion
Here is the TL;DR:
- Give context and details when possible: Always start by explaining what you’re trying to build and include important details (tech stack, features, roles, etc.) up front. More specificity yields better results. If you want a particular library or style, say so.
- Include constraints/constraints: Tell the AI what not to do or where to limit itself (e.g. “don’t change the login page code” or “use at most 3 API calls”). This is a balance though, as you don’t want to over constrain a model inside the component you want it to work on.
- Use a structured format: Format your prompt in a logical way – you can use lists or sections for clarity. A structured prompt is easier for the AI to follow and for you to write.
- Iterate step by step: For complex projects, break your prompts into smaller tasks and build iteratively. Tackle one feature at a time instead of asking for everything at once.
- Leverage the tools: Use Bolt’s Enhance Prompt button or Lovable’s idea of reverse meta prompting to improve your instructions.
