How to Build an App With AI: Tools, Steps and Real Limits

To build an app with AI, describe it to a prompt-to-app builder such as Lovable, Bolt, Base44 or Replit, and you can have a working web prototype in a few days for under $100. For a product that real customers pay for, the practical path is a developer using an AI coding tool such as Cursor, Claude Code or OpenAI Codex, which writes most of the code while a person owns the decisions. AI still does not decide what your product should do, secure your users' data by default, set up your Apple, Google and payment accounts, or look after the app once it is live.

That is the whole map. The rest of this guide fills it in: the three kinds of tools and who each one fits, the order of work, what it costs in subscriptions and credits, where these apps break, and when a team makes sense.

I checked each vendor's pricing page on November 12, 2026 for the numbers below. These prices move every few months, so treat them as a snapshot and look again before you pay.

Founders lump all of this together as AI. There are three different products here, and picking the wrong kind costs you more time than picking the wrong brand.

Chat assistants

ChatGPT and Claude in a chat window. You ask, it answers, and it can write code in the conversation. Use them for the thinking: the spec, the data model, the wording of your onboarding, a second opinion on an error message. As a way to build the app itself, chat runs out fast, because you end up copying code between a browser tab and files you do not understand. This fits every founder as a planning tool and almost nobody as the build tool.

Prompt-to-app builders

Lovable, Bolt, Base44, Replit and v0 from Vercel. You type what you want, and the tool writes the code, runs it, hosts it and gives you a link. Most include a database, sign-in and a publish button, so there is nothing to install. What comes out is a web app that runs in a browser, including the browser on a phone.

This fits a non-technical founder who needs to show something this week: a prototype for user interviews, an internal tool, a demo for an investor. It also fits a small real product with simple data and low stakes. One note on the list: Google announced in March 2026 that it is closing Firebase Studio, and new sign-ups ended in June, so leave it off yours.

AI coding agents used by developers

Cursor, Claude Code and OpenAI Codex. These work inside a real code project on a computer or in the cloud. They read the whole codebase, change many files at once, run the tests and report back. The output is ordinary code in a repository you own, in whatever stack you choose, including React Native for iOS and Android.

They are built for people who can read what comes back. A founder with no coding background can get a long way with one, and our guide on how to build an app with ChatGPT and where it stops walks that exact path with Codex. The catch is that the agent makes choices on every task, and somebody has to judge them. In a developer's hands these tools now write a large share of the code in serious products.

How to choose

• You want to test an idea and you do not code: a builder. Lovable or Base44 if you want the most hand-holding, Bolt or Replit if you want to see more of the code.
• You want a marketing site or a front end that looks sharp: v0 or Lovable.
• You need a native iOS and Android app in the stores: a developer with a coding agent. Builders are weakest here.
• The app holds money, health data or anything regulated: a developer with a coding agent, from the first line.

The order below matters more than the tool. Most stuck projects I see skipped step one or did step three last.

Step 1: Write a one-page spec

One page, in plain words. Who the user is, the single job the app does for them, the five or six screens that job needs, and a list of what is out. Then write the test: "a dog walker can book a slot and pay in under two minutes." The AI builds what the page says, so a vague page gets you a polished version of a vague idea. If you have not validated the idea yet, our founder's guide to creating an app covers that part before any tool gets opened.

Step 2: Pick the tool from the section above

Pick one and stay on it for the first version. Moving a half-built app between builders costs more than finishing it where it is. Before you commit, confirm the tool lets you export the code or sync it to GitHub. Lovable, Bolt, Base44 and v0 all list a GitHub connection on their plans, and you want your code somewhere you control from day one.

Step 3: Get the data model right first

Before any screen, ask the AI to propose the tables: users, bookings, payments, whatever your nouns are, and how they connect. Read it. Ask a chat assistant to find holes in it. A wrong button takes one prompt to fix. A wrong data model means rebuilding every screen that touches it, and by week three that is all of them.

Step 4: Build the core flow, one screen at a time

Ask for one screen, look at it, then ask for the next. Big prompts burn credits and produce big mistakes. Leave settings, profile pages and dark mode until the main job works end to end with fake data.

Step 5: Add sign-in and payments through managed services

Do not let the AI invent its own login or its own checkout. Use the builder's built-in auth, or a service such as Supabase Auth or Clerk, and use Stripe's hosted checkout for payments on the web. You are borrowing years of security work from a company whose whole product is that one thing.

Step 6: Test with real users

Put it in front of five to ten people who have the problem and say nothing while they use it. Then fix what confused them. Bugs you can find alone. Confusion you can only find by watching.

Most of these tools charge a monthly fee that buys credits or tokens, and you buy more when you run out. Here is what each vendor's own page listed when I checked.

• Lovable: a free plan with 5 build credits a day, capped at 30 a month. Pro is $25 a month for 100 credits, $50 for 200 and $100 for 400. Lovable's docs put a typical build message at about half a credit to 2 credits, with "add authentication" at 1.2. Hosting and the built-in backend draw from the same credit balance.
• Bolt: free with 1 million tokens a month and a 300,000 daily cap. Pro is $25 a month, starts at 10 million tokens and adds custom domains.
• Base44: free with 25 message credits a month. Paid plans are $16, $40, $80 and $160 a month on annual billing, for 100, 250, 500 and 1,200 message credits.
• Replit: Core is $20 a month with $20 of credits. Pro is $100 a month with $100 of credits.
• v0: the free plan allows 7 messages a day. Paid plans include $30 of credits per user each month.
• Claude Code: included in Claude Pro at $20 a month, or $17 a month paid yearly. Max is $100 and Ultra is $200.
• OpenAI Codex: included with ChatGPT Plus at $20 a month. Pro starts at $100.
• Cursor: now sold in one subscription with Grok and X features, sharing a usage pool. Plus is $8 a month with Grok models only. Premium is $30 and adds other companies' models at API list price. Super is $100 and Ultra is $200.

The sticker price is the floor. A founder building one app on a builder usually spends $25 to $100 in the first month, then $50 to $200 a month in the heavy weeks when every fix costs credits. The pattern to watch is the debugging loop: the app breaks, you prompt, it breaks somewhere else, and each round is billed. If you spend more than a day and 50 credits on one bug, stop prompting and get a person to look at it.

A developer on a coding agent pays $20 to $200 a month for the tool. Their time is the real cost, and it dwarfs the subscription.

Add the fees that have nothing to do with AI: a domain at $10 to $20 a year, Apple's developer program at $99 a year and Google Play's one-time $25 if you go to the stores, plus hosting and a database at $0 to $50 a month for a young product.

How long each stage takes

• Spec: one or two days, if you are strict about cutting.
• Clickable prototype in a builder: two to five days.
• Real data, sign-in and payments: one to two weeks. This is where the easy part ends.
• Testing with users and fixing: one to two weeks.

So a simple web app, built by a founder on a builder, takes three to six weeks to reach a first version that strangers can use. The demo you saw built in ten minutes was the first stage only.

These are the five places, roughly in the order you will hit them.

Sign-in and data access rules

This is the big one. The login screen works, so it looks finished. The failure sits one layer down, in the rules that say which user may read which row in the database. Builders often leave those rules open or half-written, and the app still runs fine in your own testing because you are the only user. Then a stranger changes an ID in the address bar and reads someone else's bookings. Our guide to taking vibe-coded apps to production quality goes through these patterns one by one.

Payments

A checkout button is easy. The hard parts are everything after the click: confirming the payment on the server through a webhook, handling failed cards, refunds, and cancelled subscriptions, and keeping your database in step with what Stripe says is true. AI-written payment code tends to trust the browser, which means a user can tell your app they paid when they did not.

Scale

The first hundred users rarely break anything. The trouble starts when the tables grow: pages that load every record at once, missing database indexes, no caching, and a bill from your builder's hosting that climbs with every visit. None of it shows up with ten test accounts.

Native iOS and Android, and store review

Builders make web apps. Wrapping one in a shell and submitting it is the route that gets rejected, because Apple's guideline 4.2 asks for more than a repackaged website. Apple also requires in-app account deletion and its own in-app purchase system for digital goods. On Android, a personal developer account created after November 13, 2023 has to run a closed test with at least 12 testers for 14 days before Google will consider it for production. No AI tool shortens that wait or finds you the twelve people.

Maintenance

After a few hundred prompts, nobody knows how the app works, including the model, which only sees part of the code at a time. Each fix risks an older feature. Libraries age, iOS changes every autumn, and a customer emails that they were charged twice. Someone has to own that, and a subscription to a builder does not include that person.

Run this list before you send the link to anyone outside your circle. A non-technical founder can do every item, and most take minutes.

• The two-account test. Create two accounts. Log in as the first, copy the address of a private page, log in as the second and paste it. If you see the first user's data, stop.
• Database rules are on. If your app sits on Supabase, row level security must be enabled on every table, with a policy for each. Ask the AI to list every table and its policy, then check the list against the dashboard yourself.
• No secret keys in the browser. Open the published site, view the page source and search for "sk_" and "secret." Payment and AI keys belong on the server only.
• Payments confirmed by webhook. Pay with a Stripe test card, then with a card that declines. The app should grant access only after Stripe confirms.
• Code in GitHub, in your account. If the builder closed tomorrow, you would still have the product.
• Backups. Know how to restore yesterday's database, and try it once.
• A privacy policy and a way to delete an account. Both are required by the app stores and expected by users.
• Error alerts. A tool such as Sentry, so you hear about crashes before your users write to you.

Then pay a developer for a few hours of review. At market rates of $75 to $200 an hour, a half-day security read of a small app costs a few hundred dollars. It is the cheapest insurance in the whole project.

The signals are plain. Strangers are using the app and asking to pay. The next feature involves money or private data. You need to be in the App Store and Google Play. Or you have spent a month in the fix-one-break-one loop and the product is going backwards.

At that point you have three routes, and these are market ranges, not a quote from us.

• A freelancer: $50 to $150 an hour in the US and Western Europe. Good for hardening a small web app or adding payments properly. A simple app runs $8,000 to $40,000.
• A product team or agency: $30,000 to $150,000 for a focused first version, in 8 to 16 weeks. Simple apps with one core flow sit at the low end. Payments, real-time features, several user roles and an admin panel push it up.
• In-house hires: two engineers and a designer cost $400,000 to $600,000 a year in a US market. That comes after the product is proven.

What drives the number is scope: how many screens, how many outside services, one platform or two, and how much custom design. Our app development cost page breaks each of those down so you can estimate your own product.

AI has changed this math less than founders expect. Agents make a good developer faster at writing code, so the same budget buys more product than it did two years ago. The hours spent on deciding what to build, design, testing on real devices, store review and security were never typing, and they have not shrunk much.

Your prototype carries over even if the code does not. A team that starts with a tested prototype, a one-page spec and notes from ten user sessions skips most of the guessing that makes builds run long. Sometimes the builder's code is kept and cleaned up. More often the screens and the data model are kept and the code is rewritten on a stack that can go to the stores.

Build the smallest version that can answer one question: do people want this enough to come back, or to pay. In practice that means a web app with a single core flow, managed sign-in, hosted checkout if money is the point, and nothing else.

Good first builds with AI:

• A landing page with a waitlist. An afternoon in any builder.
• A clickable prototype of the core flow with fake data, for user interviews.
• A one-job web tool: one input, one result.
• An internal tool for your own team, where a bug hurts nobody.

Leave these for later, or for a developer: native apps, anything with health or financial records, marketplaces that hold other people's money, and real-time features such as chat or live location.

Narrow scope is what makes speed possible, with or without AI. Fake Friends, an Instagram unfollower tool we designed and built, does one job: it reads Instagram's own data export and shows who unfollowed you, without ever asking for a password. It went from first commit to production in two days as a Next.js web app, with email-code sign-in through Clerk and Stripe checkout live on a custom domain. Two days was possible because sign-in and payments were handed to services built for them, and because the product refused to do a second job.

So this week, write the one-page spec, build the core flow in a builder, and put it in front of ten people. If they shrug, you spent under $100 to find out. If they ask when they can pay, you have a spec, a prototype and proof, which is the best starting point any build can have. When you reach that point, tell us what the product is, who it is for and which platforms it needs, and we will tell you what to keep from the prototype, what to rebuild and what the first real version should include. Book a free strategy call