> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nativeline.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Working with Plans
> Understand how the AI works and manage it effectively
# Working with Plans
When you ask Nativeline to build something, the AI creates an internal plan and immediately starts executing it. Understanding how this works helps you collaborate more effectively.
## How the AI Works
When you describe what you want, the AI:
1. Analyzes your request
2. Breaks it into logical steps internally
3. Executes each step in order
4. Shows you code previews and tool cards as it works
5. Builds and tests your app automatically
The AI doesn't wait for approval — it starts working immediately. You can watch the progress through code previews and redirect if needed.
### Example
You say: "Add a profile screen with user avatar, name, and settings"
The AI internally plans to:
1. Create ProfileView\.swift
2. Add avatar image component
3. Add name display
4. Add settings section
5. Connect to navigation
6. Build and test
You'll see code being written in real-time as the AI executes each step.
***
## Slash Commands
Nativeline provides commands to help manage the AI:
| Command | What it does |
| ------------ | ----------------------------------------- |
| `/help` | Shows all available commands |
| `/plan` | Shows the current internal plan status |
| `/planclear` | Clears the current plan (keeps your code) |
| `/debug` | Toggles debug logging on/off |
### The /planclear Command
**`/planclear`** clears the current plan and lets you start fresh.
**When to use it:**
* You want to work on something different
* The AI seems stuck or going in the wrong direction
* You've changed your mind about what you want
* The AI keeps trying to complete something you no longer need
**How to use it:**
```
/planclear
```
**What it does NOT do:**
* Does NOT undo any code changes
* Does NOT delete your files
* Does NOT reset your project
It only clears the internal plan — your code stays exactly as it is.
### The /plan Command
Use `/plan` to see what the AI is currently working on:
```
/plan
```
This shows the internal plan status, which can help you understand what's happening if the AI seems busy.
***
## Resuming Work
### Coming Back to a Project
If you had work in progress and return later:
**Option 1: Continue where you left off**
```
continue
```
or
```
keep going
```
**Option 2: Start fresh**
```
/planclear
```
Then describe what you want to do instead.
### What if the AI is Stuck?
If the AI keeps trying and failing:
1. Try: "Let's try a different approach to \[the stuck task]"
2. Or: `/planclear` and re-describe what you want
3. Or: Provide more specific guidance about what's going wrong
***
## Best Practices
### 1. Let the AI Figure Out the Details
You don't need to tell the AI exactly what files to create or what code to write. Just describe the feature and let it work.
**Don't:**
```
Create a file called ProfileView.swift with a struct that has an @State variable for the username...
```
**Do:**
```
Add a profile screen where users can edit their username and email
```
### 2. Watch and Redirect
As the AI works, you'll see code previews showing what it's creating. You can:
* **Let it work:** Most of the time, just watch it build
* **Redirect:** "Actually, don't include email, just username"
* **Clarify:** "That's not quite what I want, let me explain differently"
### 3. Keep Requests Focused
One clear request = focused work.
**Too broad:**
```
Build my whole app with user profiles, posts, comments, likes, and messaging
```
**Just right:**
```
Start with user profiles where people can set their name and avatar
```
After that works, add the next feature.
### 4. Don't Interrupt Mid-Task (Usually)
Let the AI complete its current task before adding new requests. Interrupting can lead to half-finished work.
However, if you see it going wrong, it's fine to say:
```
Stop, that's not what I meant. Let me clarify...
```
***
## Handling Build Errors
If a build fails while the AI is working:
1. The AI automatically detects the error
2. It attempts to fix it (up to 3 times)
3. After fixing, it continues with remaining work
4. You don't need to restart anything
See [Debugging Guide](/guides/debugging) for more details.
***
## Common Scenarios
### "I want to change direction"
```
/planclear
```
Then describe your new direction.
### "I want to add more features"
Wait for the current work to complete, then:
```
Now also add [new feature]
```
### "The AI keeps failing on something"
```
Let's skip that for now and try a simpler approach.
```
Or:
```
/planclear
Let's take a simpler approach to [feature]
```
### "I don't understand what's happening"
```
Explain what you're doing and why
```
The AI will describe its approach in plain English.
***
## AI Memory
The AI remembers:
* What it's already built and tried
* Previous conversation context
* Your project's structure and patterns
* Your preferences and style
This memory helps it:
* Avoid repeating failed approaches
* Build consistently with existing code
* Remember your preferences
### The .nativeline Folder
Your project contains a hidden `.nativeline` folder with AI memory about your project. Don't delete this folder unless you want to reset the AI's memory completely.
***
## Troubleshooting
Make sure you type exactly: `/planclear`
It should work immediately. If not, try closing and reopening the project.
1. Type `/planclear` explicitly
2. Wait for confirmation
3. Then start your new request
Clear it and start smaller:
```
/planclear
Let's start with just [the core feature]. We'll add more later.
```
Try:
```
What are you currently working on? Can you summarize?
```
Or use `/plan` to check the status, then `/planclear` if needed.
***
## Next Steps
Handle build errors effectively
Write better prompts for better results