What AppX actually feels like: sentence to phone in 30 seconds
A second-by-second walkthrough of using AppX — empty box, one sentence, watch it build, scan a code, and your idea is running in your hand. The experience is the product.
AppX team ·
Let me walk you through what actually happens when you use AppX — not the pitch, the real thing, second by second. Because the experience is the product, and it's hard to believe until you've felt it.
It starts with an empty box and a blinking cursor. The same box every tool gives you. The difference is what's on the other side of it.
flowchart TD
T0["<b>second 0</b><br/>you type one sentence"] --> T1["<b>seconds 1–30</b><br/>watch it build, file by file"]
T1 --> T2["<b>second 30</b><br/>scan a code — the app opens in your hand"]
T2 --> T3["<b>after</b><br/>change it by talking:<br/>'make it warmer', 'add search'"]
T3 -. "every change, live" .-> T2
style T0 fill:#13203a,stroke:#5e6ad2,color:#dbe2ff
style T2 fill:#13241a,stroke:#2ecc71,color:#d7f7e3
style T3 fill:#241f13,stroke:#e0a23a,color:#f7e8cf
Second 0: you type a sentence
You type the thing you've been thinking about. Let's say:
"A reading log where I add books I've finished, give each a rating out of five, and see my reading streak."
That's it. No menus of options, no template gallery to scroll, no "select your tech stack." A sentence, in the language you already think in. You hit send.
Seconds 1–30: it builds, and you can watch
Here's where most tools would show you a spinner and a lie. AppX shows you the work. You watch it think through what your app needs, then build, file by file, the count climbing — the screen where you add a book, the list where they live, the logic that tracks your streak. It's not a progress bar inventing a percentage. It's the actual app being assembled, narrated in plain language as it goes.
This part matters more than it sounds. Watching the build turns a black box into something you trust, because you can see it doing exactly what you asked — and if it heads somewhere wrong, you notice early instead of at the end.
Second 30: it's on your phone
Then the moment the whole thing is built around. A code appears. You scan it with your phone. And your app — the one that existed only as a sentence half a minute ago — opens in your hand. Not a preview. Not a video. Not a mockup you tap and nothing happens. A running app. You add a book. It saves. You rate it four stars. The stars fill. You finish another and your streak ticks to two.
I've watched a lot of people hit this moment. There's a half-second delay, and then the same reaction almost every time — a small, involuntary laugh. The laugh of that's not supposed to be possible. Because for their entire life it wasn't. An app was a thing other people made, over months, for money. And here's one they described over a coffee, in their hand, working. That laugh is the product. Everything I build is in service of producing it reliably.
Seconds 30 and beyond: you change it by talking
Now the part that turns a neat demo into something you'd actually use: you keep going, by conversation. You look at your reading log and you have opinions — you always do, the moment it's real. So you say them, and each sentence changes the app:
| You say | What happens |
|---|---|
| "Make the ratings hearts instead of stars." | The control swaps, live, in the app you're holding. |
| "Add a screen for books I want to read next." | A new screen appears, wired into the navigation. |
| "The home screen feels cold. Warmer colors." | The whole palette shifts. |
| "Let me sort by rating." | Sorting shows up where it belongs. |
You're not opening a code file. You're not filing a ticket and waiting. You're talking to something that builds, and it updates the real app you're already holding. The loop — see it, react, refine — is so fast that you stop planning and start playing, and the playing is where the good ideas actually come from. You'll think of features standing there with the app in your hand that you'd never have specced on a blank page.
What it feels like, honestly
The closest thing I can compare it to is the first time you used a tool that collapsed a gap you'd accepted as permanent. The first time a phone gave you the whole internet in your pocket. The first time you said something out loud and a device actually did it.
There's a specific feeling when a wall you'd stopped noticing — because you'd lived behind it so long — just isn't there anymore. You reach for the limitation out of habit and your hand goes through it. "I can't build apps, I don't code" is a wall most people have leaned on their whole adult life. Watching your own idea run on your own phone, thirty seconds after describing it, is the feeling of that wall not being there.
I won't pretend it's magic with no rough edges. It's software; it's young; sometimes you'll refine a description twice to land what you meant. But the core loop — sentence in, running app on your phone, change it by talking — that works, today, and it does the thing it promises.
Go feel it
I can describe this for a thousand words and it won't land the way thirty seconds of doing it will. It's an experience, and experiences don't transfer through text — they have to happen to you.
So here's the only ask: think of the smallest version of an app you've wanted. One screen. One core action. The thing that's been rattling around in your head. Then open AppX and type it as one clear sentence.
Thirty seconds later, check your phone. I'll bet on the laugh.
— Ilyos, building AppX. Follow the journey @ilyos_ceo.