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.

Mode	Best For	Bit Cost
Quick	Fast iteration, simple changes	Lowest
Enhanced	Most projects (default)	Low
Max	Complex logic, deep debugging	Higher

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

Command	Instead 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)

Start with workout logging (name, sets, reps)
Add exercise history view
Add progress charts
Add meal logging
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

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

First-Time Success

Getting it right the first time saves bits.

Before Sending a Prompt

Be specific — Include exact values, colors, sizes
Be complete — Mention all requirements upfront
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

Strategy	Savings
Specific prompts	50-70%
Reference images	40-60%
Building incrementally	30-50%
Quick error context	20-40%
Manual edits (Pro)	90% for small changes
Batching similar changes	30-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

​Optimizing AI Usage

​Choose the Right AI Mode

​When to Switch Modes

​Use the Toolkit to Save Bits

​Without Toolkit (More Bits)

​With Toolkit (Fewer Bits)

​Quick Toolkit Reference

​Understanding Bit Consumption

​What Uses More Bits

​What Uses Fewer Bits

​The Specificity Principle

​Expensive (Vague)

​Efficient (Specific)

​Build Incrementally

​Expensive (All at Once)

​Efficient (Step by Step)

​Use Reference Images

​Without Image

​With Image

​How to Use Images

​First-Time Success

​Before Sending a Prompt

​The 30-Second Check

​Leverage Pro Plan Features

​AI-Efficient

​Manual-Efficient

​Optimize Error Handling

​Preventive Prompting

​Quick Error Context

​Batch Similar Changes

​Expensive (Separate Requests)

​Efficient (One Request)

​Know When to Start Fresh

​Signs to Rebuild

​Efficient Restart

​Smart Plan Management

​Don’t Interrupt Plans

​Clear Plans When Pivoting

​Review Before Execution

​Bit Usage by Action

​Low Bit Usage (1-10 bits)

​Medium Bit Usage (10-25 bits)

​High Bit Usage (25-50 bits)

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

​Tracking Your Usage

​Monitor in Real-Time

​Plan Your Sessions

​Quick Reference

​Next Steps

Prompt Workshop

AI Modes

Toolkit

Plans & Pricing

Optimizing AI Usage

Choose the Right AI Mode

When to Switch Modes

Use the Toolkit to Save Bits

Without Toolkit (More Bits)

With Toolkit (Fewer Bits)

Quick Toolkit Reference

Understanding Bit Consumption

What Uses More Bits

What Uses Fewer Bits

The Specificity Principle

Expensive (Vague)

Efficient (Specific)

Build Incrementally

Expensive (All at Once)

Efficient (Step by Step)

Use Reference Images

Without Image

With Image

How to Use Images

First-Time Success

Before Sending a Prompt

The 30-Second Check

Leverage Pro Plan Features

AI-Efficient

Manual-Efficient

Optimize Error Handling

Preventive Prompting

Quick Error Context

Batch Similar Changes

Expensive (Separate Requests)

Efficient (One Request)

Know When to Start Fresh

Signs to Rebuild

Efficient Restart

Smart Plan Management

Don’t Interrupt Plans

Clear Plans When Pivoting

Review Before Execution

Bit Usage by Action

Low Bit Usage (1-10 bits)

Medium Bit Usage (10-25 bits)

High Bit Usage (25-50 bits)

Very High Bit Usage (50-100+ bits)

Tracking Your Usage

Monitor in Real-Time

Plan Your Sessions

Quick Reference

Next Steps