Skip to main content

​
Optimizing AI Usage

Bits measure your AI usage in Nativeline. Using them wisely means building more with less. This guide shares strategies for efficient building.

​
Choose the Right AI Mode

Different AI modes have different bit costs. Picking the right one saves bits.
ModeBest ForBit Cost
QuickFast iteration, simple changesLowest
EnhancedMost projects (default)Low
MaxComplex logic, deep debuggingHigher
Enhanced is the default for good reason — it produces the best designs and makes fewer mistakes, so you often use fewer total bits than Quick mode for the same result.

​
When to Switch Modes

  • Use Quick for rapid color/text tweaks
  • Stay on Enhanced for building features (default)
  • Switch to Max only for complex algorithms or stubborn bugs See AI Modes for the full comparison.

​
Use the Toolkit to Save Bits

The Toolkit’s # commands let you attach real assets instead of describing them — saving bits and getting better results.

​
Without Toolkit (More Bits)

Use a rounded sans-serif font that looks modern and clean,
similar to SF Pro Rounded but with more character
→ AI guesses, you iterate → 30+ bits

​
With Toolkit (Fewer Bits)

#font Use this font for all headings
→ AI uses your exact font → 10 bits

​
Quick Toolkit Reference

CommandInstead of Describing…
#image”Add an image that looks like…”
#font”Use a font similar to…”
#color”Use a blue like hex #…”
#data”Create sample data with…”
#sound”Add a notification sound”
#video”Add a background video”
#lottie”Create a loading animation”
#3d”Add a 3D model viewer”
See Toolkit for the full guide.

​
Understanding Bit Consumption

Not all requests use the same number of bits.

​
What Uses More Bits

  • Vague requests that need multiple iterations
  • Complex features built all at once
  • Repeated error-fix cycles
  • Large code rewrites
  • Back-and-forth clarifications
  • Using Max mode for simple tasks

​
What Uses Fewer Bits

  • Specific, clear requests
  • Features built incrementally
  • First-time success (fewer fix attempts)
  • Small, focused changes
  • Using reference images
  • Using the Toolkit for assets
  • Staying on Enhanced mode for most work

​
The Specificity Principle

The more specific your request, the fewer bits it uses.

​
Expensive (Vague)

Make the app look better
→ AI guesses, you correct, repeat several times → 60+ bits

​
Efficient (Specific)

Add 16pt padding to all cards, 12pt rounded corners,
and a subtle drop shadow (offset 0, blur 8, opacity 10%)
→ AI implements exactly what you want → 10-15 bits

​
Build Incrementally

Building one feature at a time is more efficient than requesting everything at once.

​
Expensive (All at Once)

Build a complete fitness app with workout tracking,
meal plans, progress charts, social sharing,
achievements, and calendar integration
→ Huge request, more likely to need fixes → 60-80 bits (single message, but often needs follow-ups)

​
Efficient (Step by Step)

1. Start with workout logging (name, sets, reps)
2. Add exercise history view
3. Add progress charts
4. Add meal logging
5. etc.
→ Each step builds on stable foundation → 25-40 bits per message (cleaner results, fewer fixes needed)

​
Use Reference Images

A picture really is worth a thousand words tokens.

​
Without Image

I want a card layout where the image is on top,
then the title below it in bold, then a subtitle
in gray, and a price on the right side...
→ Multiple iterations to get it right → 50+ bits

​
With Image

Make my product cards look like this screenshot
[attached image]
→ AI sees exactly what you want → 15-25 bits

​
How to Use Images

  1. Take a screenshot of any app/website you like
  2. Drag and drop it into the Nativeline chat
  3. Reference it in your prompt

​
First-Time Success

Getting it right the first time saves bits.

​
Before Sending a Prompt

  1. Be specific — Include exact values, colors, sizes
  2. Be complete — Mention all requirements upfront
  3. Be clear — Describe the user experience, not just the UI

​
The 30-Second Check

Before sending, ask yourself:
  • Have I specified WHERE this should appear?
  • Have I specified HOW it should look?
  • Have I specified WHAT it should do?
This small investment prevents expensive iterations.

​
Leverage Pro Plan Features

If you’re on Pro plan, use the code editor for small changes.

​
AI-Efficient

Add a settings screen with notification toggle
Use AI for new features and complex logic.

​
Manual-Efficient

Open the code editor and change: 
.foregroundColor(.blue)  // change to .green
.padding(16)              // change to 20
Text("Save")              // change to "Submit"
Save your bits for things that actually need AI.

​
Optimize Error Handling

Errors consume bits. Reduce them.

​
Preventive Prompting

Add a save button that saves the form data.
Include error handling if the save fails,
and show a loading indicator while saving.
Asking for error handling upfront prevents errors later.

​
Quick Error Context

When errors occur, provide helpful context immediately: 
The error says 'user' not found. It should use
'currentUser' from AuthManager.
Good context = faster fix = fewer bits.

​
Batch Similar Changes

If you need multiple similar changes, batch them:

​
Expensive (Separate Requests)

Change the home screen button to blue
then 
Change the profile screen button to blue
then 
Change the settings screen button to blue
→ 45+ bits (3 separate operations)

​
Efficient (One Request)

Change all buttons across the app to use blue (#007AFF)
as the primary color
→ 15 bits (single operation)

​
Know When to Start Fresh

Sometimes restarting is more efficient than fixing.

​
Signs to Rebuild

  • Same error returning repeatedly
  • Multiple interconnected issues
  • Fundamental architecture problem
  • More than 5 fix attempts

​
Efficient Restart

/planclear
Delete the [feature] code completely.
Let's rebuild it with a simpler approach: [description]
A clean rebuild often uses fewer bits than endless fixes.

​
Smart Plan Management

​
Don’t Interrupt Plans

Let the AI complete its current plan before adding new requests. Interruptions can leave things half-done.

​
Clear Plans When Pivoting

If you’re changing direction: 
/planclear
Then start fresh. Don’t let old plans interfere.

​
Review Before Execution

When the AI shows its plan, review it:
  • Is this what you want?
  • Is it the simplest approach?
  • Should anything be different?
Feedback before implementation is cheaper than fixes after.

​
Bit Usage by Action

​
Low Bit Usage (1-10 bits)

  • Simple questions
  • Single color/text changes
  • Spacing adjustments
  • Single property changes

​
Medium Bit Usage (10-25 bits)

  • Multiple styling changes
  • Minor bug fixes
  • Small UI polish
  • Simple additions

​
High Bit Usage (25-50 bits)

  • New components
  • New screens
  • Small features
  • Multi-step changes

​
Very High Bit Usage (50-100+ bits)

  • Complete app builds
  • Complex features
  • Major bug investigations
  • Large multi-file changes

​
Tracking Your Usage

​
Monitor in Real-Time

Check the bit counter in Nativeline’s toolbar:
  • Current remaining bits
  • Usage trend
  • Reset date

​
Plan Your Sessions

If you have 200 bits left:
  • ✅ Polish existing features
  • ✅ Make small fixes
  • ❌ Start a major new feature (save for after reset)

​
Quick Reference

StrategySavings
Specific prompts50-70%
Reference images40-60%
Building incrementally30-50%
Quick error context20-40%
Manual edits (Pro)90% for small changes
Batching similar changes30-50%

​
Next Steps

Prompt Workshop

Master efficient prompting

AI Modes

Choose the right mode for the task

Toolkit

Attach assets to save bits

Plans & Pricing

Understand bit allocation