What you’ll learn:

This guide combines two essential aspects of prompting in Rocket:

  • The C.L.E.A.R. framework for writing strong, effective prompts.
  • Core prompting strategies, like zero-shot, one-shot, few-shot, and chain-of-thought.

These tools help you go from simple tasks to deeply structured conversations—faster, smarter, and more reliably.

​
Why prompting principles matter

A prompt isn’t just a request - it’s your instruction manual for Rocket’s AI.
Strong prompts give you better structure, smarter behavior, and fewer surprises.

This guide introduces two core models that will level up how you prompt:

  • The C.L.E.A.R. framework for writing high-quality prompts.
  • A set of universal prompting strategies, including zero-shot, few-shot, one-shot, and chain-of-thought prompting.

​
The C.L.E.A.R. Framework

This framework outlines five qualities that make your prompt easier for Rocket to interpret and dramatically improves the quality of your output.

To show how this works in practice, we’ll use one example prompt across all five stages:

Goal: Create a screen where users can book a consultation call.

​
1. Concise

Be brief but clear. Focus on what matters, and cut unnecessary wording.

Do:
Add a booking form with name, email, and preferred time.
Don’t:
I want something that collects a user’s details—like their name or email address.

Rocket parses prompts instantly. Extra words don’t help - it’s clarity that counts.

​
2. Logical

Group related elements. Organize the layout like a user would experience it.

Do:
Start with a short heading. Then stack fields for name, email, and time slot. Add a submit button last.
Don’t:
Add email and password first, then the name field somewhere. Add a button too.

Prompting out of sequence often leads to unexpected layouts or confusing flows.

Key term: Layout refers to how interface components are visually arranged. Logical order helps Rocket structure your app cleanly.

​
3. Explicit

Be specific about what you want to appear and how it should behave.

Do:
Add placeholder text in each input. Make the time slot a dropdown. Show a success message after submitting.
Don’t:
Add a few fields so users can register. Make sure it works like most forms.

Don’t leave details up to interpretation. The more precisely you describe the behavior, the more accurate the output.

Prompting works best when you imagine you’re writing instructions for a builder. Specific requests = precise results.

​
4. Adaptive

Tailor your prompt to the current goal - whether it’s design, logic, or debugging.

Do (Design):
Create a clean and focused booking form. Center it on the screen, use generous spacing, and keep visual elements minimal.
Do (Logic):
When someone submits the form, validate the inputs, store them in a bookings table, and show a confirmation message.
Do (Debug):
The submit button doesn’t respond. Check if it’s disabled or missing an onClick handler.
Don’t:
Build a form and connect it to the backend. Also make sure it’s styled well.

Being too general makes it harder for Rocket to know what to prioritize - layout, logic, or both.

Key term: Logic describes how elements behave—validation, interactions, and flows.

​
5. Reflective

Don’t settle for your first draft. Reflective prompting means reviewing, adjusting, or rephrasing based on results or what you learned from a previous attempt.

Do:
Tried a version that felt too vague, so you rewrote it:

Add a form with name, email, and time. Include dropdowns where needed and show a confirmation message once submitted.
Don’t:
Kept using the same unclear prompt even after Rocket returned layout issues or missing behaviors.

Great prompting is iterative. If the output isn’t quite right, don’t just edit the result - rethink the instruction.

Reflection is what turns decent prompts into excellent ones. If the result wasn’t what you expected, revise the input - not just the app.

​
Prompting strategies that level you up

Once you know the basics of prompting, you can start experimenting with different approaches. These strategies help you:

  • Get more accurate results.
  • Adapt the tone and formatting.
  • Handle more complex goals.

Let’s look at the most useful ones.

​
Zero-shot prompting

Use this when the task is simple and doesn’t need examples or setup.

Create a screen that lists all orders placed in the last 7 days.

Clean and direct. Great for short tasks with clear goals.

​
Instructional prompting

Use this when you want specific behaviors, structure, or formatting.

Create a welcome page with a bold heading, two short bullet points, and a button that says “Get started.”

You’re guiding Rocket on how to shape the result.

​
Prompting for tone and clarity

Use this when you want the output to reflect empathy, clarity, or audience awareness.

Improve the layout to make the screen feel more intuitive for someone using it for the first time.

​
Few-shot prompting

Use this when you want Rocket to follow a style or layout you’ve used before like how you structure sections, repeat visual patterns, or carry consistent behaviors across screens.

Create a section with a bold title and a short intro. Below that, place three cards—each with an icon, a title, and a brief description. Finish with a centered button at the bottom.

Each section should have a heading at the top. Put the main text on the left and an icon or image on the right.

For interactions, tapping a row should expand details in place. Use the same behavior for all list-based screens.

You’re showing Rocket what “good” looks like. It continues the pattern across your app.

​
Chain-of-thought prompting

Use this when you want Rocket to reason through the task step-by-step before generating output.

Let’s break this down: First, check if the user is logged in. If they are, show the dashboard. If not, redirect to the login screen.

Great for logic-heavy prompts, debugging, and multi-step flows.

​
Quick strategy guide

StrategyWhen to use itWhat it helps with
Zero-shotSimple, well-scoped tasksQuick builds with minimal setup
InstructionalYou need control over layout, logic, or styleClear, structured, and repeatable results
Tone/ClarityFirst-time UX or voice-sensitive screensShapes the experience to fit the audience
Few-shotYou’ve already used a pattern you want to repeatMaintains design consistency and flow
Chain-of-thoughtTasks with logic, order, or dependenciesBreaks down steps for accurate execution

The more intentional your prompt, the more reliable your results.

​
Preventing hallucinations and inconsistencies

Even well-written prompts can generate off-track results. Here’s how to reduce drift, missing logic, or features you didn’t ask for.

​
1. Be specific about source data and constraints

Instead of:
Build a dashboard with all the user metrics.
Try:
Build a dashboard that shows active users, churn rate, and average session time from the `user_metrics` table.

Specific nouns (fields, collections, actions) reduce ambiguity and keep Rocket grounded.

​
2. Sequence complex logic into steps

Instead of:
Build a complete workflow that saves data, and emails the user.
Try:
Step 1: Create a form with validation.  
Step 2: Save the data to the database.  
Step 3: Send a follow-up email.

Step-by-step instructions reduce skipped behavior and are easier to test.

​
3. Reflect and revise before re-prompting

If the output isn’t what you expect, don’t just rephrase—step back and clarify what Rocket misunderstood.

Review this screen’s logic. What assumptions did Rocket make that aren’t valid?

The more complex the task, the more your prompt becomes a design brief. Revising the instruction is often more effective than editing the output.

​
What’s next?

Try combining strategies for even more control. For example:

Show a feedback screen with a short title, a sentence of text, and three emoji buttons to rate the experience.

Then…

Now write a thank-you message that feels warm and personal.

Start with structure, then refine tone. Stack prompts to shape the experience.

Continue exploring: