I Used AI to Build an Entire App With Just Words—Here’s What Happened

Let’s talk about a big promise you’ve probably heard before:

“You can build an entire app just by speaking English to AI.”

Sounds magical, doesn’t it? Like whispering wishes into a genie’s lamp.

But is this true today?

I decided to test it myself, using one of the popular AI coding tools, Cursor. I pretended to have absolutely zero coding experience—though it was challenging to ignore my background, I committed to approaching everything as a complete beginner.

Here are a few recent posts I've seen about this:

Buckle up. This is the story of my experiment—what worked, what didn’t, and why AI isn’t quite ready to make coding obsolete just yet.

The Dream: Building an App Without Coding

To test the limits of AI development tools, I picked a real app idea I’d worked on before: Kidly.

Kidly is an app for parents. You tell it where you are, how many kids you have, and what kind of activities you’re looking for. The app spits out personalized suggestions for family-friendly events nearby—perfect for rainy Saturdays or sunny afternoons at the park.

The version we built in 2022 took a month of work, a team of developers, and countless headaches.

So here was my challenge: Could I recreate a basic version of this app in one afternoon, without writing a single line of code myself?

The rules of my experiment were simple:

• No coding knowledge: I would pretend I had never written a single line of code.
• Just English: I would rely solely on natural language instructions to Cursor and ChatGPT.
• Follow AI’s lead: I wouldn’t “think” or solve problems myself. I’d let the AI guide me every step of the way.

Would this promise of “no-code app building” hold up?

Let’s find out.

Step 1: Starting with the UI (User Interface)

The first thing I wanted was a visual layout—a basic user interface where parents could browse activities.

I described my vision to ChatGPT-o1:

Prompt: “I want an app where users can toggle between a map view and a scrolling feed of activities. The feed should show cards with details about each activity, like age group, weather suitability, and discounts.”

I got something like this:

Result: “Create the following UI for me with the description below (generate and use fake data to get started):

Page Layout:

1. Header Section:

• Positioned at the top of the screen.
• Contains the app name or page category (Discover, Assistant, etc.) in a horizontal navigation menu.
• The currently selected page (“Assistant”) is highlighted.
• The right-hand corner displays a user profile avatar with the name “Romain Huet”.

1. Main Content Area:

• Split into two sections:
• Left Side: Text-based conv….”

ChatGPT-o1 is great for this. I got a detailed description of the UI and a list of things a developer would need to build it. I open a folder in Cursor and copy-pasted the result.

Cursor is an interactive development tool where you describe what you want, and it generates code for you. The interface is something like this:

The tool has a simple layout divided into three parts:

• On the right: A chat window where you talk to the AI
• In the middle: A space where you see the code the AI creates
• On the left: A list of your project files

There's a video you can watch to see how it works in detail, but it's pretty simple - I just chat with the AI on the right side and approve the changes it suggests.

When I pasted my request, Cursor turned my description into actual code. But it was just code.

To visualize what this code renders, I needed to run it in my browser. I asked Cursor for instructions, encountered errors, pasted them back into Cursor, and implemented the fixes.

After several cycles of troubleshooting, I got my result.

A static interface. (not so bad actually, for zero coding knowledge!)

It looked like what I wanted, but nothing worked. Buttons didn’t click. The design feels unpolished. The map didn’t load. It was just a picture. But that being said, it's a promising start. In fact, this is the only part of the process where AI feels truly magical. As we'll see, the rest becomes much more challenging.

Step 2: Adding Interactivity

Now that I had the basic layout, I wanted to make it interactive.

I asked for the map. I got instructions and some code, but nothing worked (I knew why actually, because I knew we needed an API key from Google... but I kept interacting in English and just giving the errors, like someone with no knowledge).

So, I copied the errors I got when trying to run the app, pasted them back into Cursor, and asked it to fix things.

This process repeated over and over:

• Error.
• Paste error into Cursor.
• Get a fix.
• Run code.
• New error.
• Repeat.

Sometimes I needed to revert back, because the AI changes broke my app (sometimes I couldn’t exactly revert back…).

I got instructions on how to generate an API on the Google Cloud Console, etc.

Eventually, I had a working interface. At first, the map didn’t display properly. Then, it displayed the wrong data. It took around an hour of back-and-forth, but I got there.

Finally I could navigate properly between the Map and Places section:

While all the data in the interface is static, this is actually quite an achievement for someone with zero coding knowledge in just one hour! Don't you think?

At one point, the map data and feed data didn’t match. When I clicked on an activity in the feed, it wouldn’t appear on the map.

The AI gave me solutions—most of which broke the app even more. Sometimes I had to undo its changes.

This is where things got frustrating.

The Loop of Doom

AI coding tools have a bad habit. When they don’t know how to fix something, they loop.

Here’s what happens:

• Problem 1 leads to Solution A.
• Solution A creates Problem 2.
• Problem 2 leads back to Solution B.
• Solution B creates Problem 1.

I call this the Loop of Doom.

If you’re not careful, you can waste hours going in circles. At one point, I was so stuck that I upgraded to Cursor’s paid version to access OpenAI’s more powerful GPT-o1 model.

That helped—eventually. But the frustration of these endless loops is real. If you don’t have patience, you’ll quit.

Step 3: Building the Backend

The frontend (what users see) was running (a good enough version). Now, I needed a backend (the system that stores and processes data).

I decided to add an authentication system. This means users would need to log in before accessing the app.

Rather than building an authentication system from scratch, I wanted to connect it to an existing one my company uses.

This step took the most time.

Here’s why:

• Debugging was painful: Every time I fixed one issue, another popped up.
• AI suggested bad code: Cursor made suggestions that broke my app.
• Blind trust didn’t work: I accepted AI’s changes without knowing what they did, which led to even more issues.

After three or four hours, I had a functioning authentication system. But…

The Big Problem

By the time I got authentication working, my app was broken.

Somewhere along the way, Cursor had overwritten parts of my original code. I lost features I had already built.

This is how the app looks like now after I’m authenticated:

Now I need to go back to my old code, recover the old components, and debug—achievable but quite painful...

Why? Because I accepted AI's changes blindly. I pretended not to know how to reject bad suggestions or save working versions of my code. This is exactly what would happen to someone using this "blindly".

It is also worth mentioning that Cursor and other AI development tools offer possibilities to focus prompts on very specific parts of the code to avoid breaking other parts while debugging. While this is true, in most situations the AI needs to make changes across the app for debugging, and you need to give it access to the whole code. You need to have a "good enough" knowledge of the code to make the best use of this feature.

The Hard Truths About AI Coding

Here’s what this experience taught me:

1. AI is not a magic wand. You CAN’T just “speak English” and get a fully functional app.
2. You need to learn as you go. Take the AI’s code, paste it into ChatGPT, and ask for explanations. Learn what each line does so can challenge, accept or refuse the proposed changes.
3. Save your work. Use version control tools like GitHub. Save each working version of your app so you can go back if something breaks.
4. Be ready to struggle. Building with AI is not smooth sailing. It requires patience, persistence, and problem-solving.

Can Anyone Build an App with AI?

Yes, BUT…

If you have zero coding knowledge and no interest in learning, you’ll fail.

If you’re willing to learn and treat this as a learning journey, you can build something meaningful—even as a beginner.

Practical Advice for Beginners

If you want to try building an app with AI, here’s how to make it work:

1. Use AI to learn, not just build: Copy the code Cursor gives you. Paste it into ChatGPT. Ask it to explain the code like you’re 12 years old.
2. Save versions of your app: Use Git or manually save versions (e.g., “v1,” “v2”). Always have a backup. ALWAYS.
3. Be specific: The clearer your instructions, the better the results. Vague requests lead to bad code.
4. Don’t rush: Building with AI takes time. Expect lots of trial and error.

The Future of AI Coding

Right now, AI can't replace developers.

But it's closing the gap.

In a year or two, tools like Cursor might become powerful enough for anyone to build apps effortlessly. For now, though, AI coding requires patience, persistence, and a willingness to learn.

Don't consider AI as an executor but a collaborator — so far.

Treat it like a curious, slightly clumsy assistant. Guide it. Learn from it. And you'll surprise yourself with what you can create.

What's your next project?

Think of something small you've always wanted to build — a tool, an app, or even a simple automation.

Then challenge yourself to build it with AI.

Not because it's easy, but because the process will teach you something valuable.

Let me know how it goes.

Until next time,

—Charafeddine