How AI Generation Works
You describe an app. AppX plans, generates, and validates the code; when that work finishes, you can test the result on your phone. Build time varies with scope and complexity. Knowing the shape of the process helps you write better prompts and read what AppX is doing as it builds.
AppX generates real Expo + React Native code — StyleSheet for styling, lucide-react-native for icons. Not a visual-builder export you can't touch, but actual code you can inspect, edit, and ship.
Plan → Generate → Validate
Every new app moves through three stages:
1. PLAN
The AI reads your prompt and works out:
- Which screens to build
- The data each screen needs and how it flows
- How navigation ties the screens together
↓
2. GENERATE
For each screen, the AI writes:
- React Native + TypeScript code
- StyleSheet styles + lucide-react-native icons
- The planned navigation and state
↓
3. VALIDATE
Every file is checked automatically:
- Syntax
- Packages and imports that resolve
- A TypeScript check of the whole project
1. Plan
Before writing a line of code, the AI produces a plan — the list of screens, the navigation shape (tabs, stack, or a mix), and the data model that connects everything. This is what keeps a multi-screen app coherent instead of a pile of unrelated screens.
Every new app starts with a plan card: the planned screens and "About N credits". Press Build first milestone to start, or Stop if the plan is not what you want. Edits to an existing app run straight away.
2. Generate
With the plan set, the AI writes each screen: complete TypeScript, StyleSheet.create styling, navigation hooks, and state. When a screen should remember data between launches, it wires up on-device storage.
Every generated app shares one consistent stack:
- Expo Router for file-based navigation
- StyleSheet.create for styling
- lucide-react-native for icons
- TypeScript throughout
The stack is fixed on purpose — consistent, validated output beats a different toolkit on every build. (AppX doesn't generate NativeWind or react-native-paper apps.)
3. Validate
Each file passes through automated checks before it reaches your phone: syntax, packages and imports that resolve, and a TypeScript check of the whole project. If a check fails, AppX reads the error, fixes it and builds again on its own.
Refining by chat
Once your app exists, you shape it through conversation. Edits run a tighter, more surgical loop than a full build:
- The AI reads the code it needs.
- It makes precise, targeted changes to just the part that needs to change — not a full rewrite.
- The change is applied and validated.
- If something's off, the AI sees the error and corrects it — those internal retries are part of the same turn.
- The edit is applied and the preview updates. To go back, use Undo on the turn card, or open the project menu → Version history → Restore.
Surgical edits are safer than rewrites: the AI touches only what you asked about, so the rest of your screen stays exactly as it was.
When something fails
If a build or an edit fails, AppX tells you in the chat, and you are not charged. Usually a short nudge ("the build failed on an import error — try again") gets it through on the next pass.