Skip to content

Guides

Vibe coding an app: what a quick prototype hides

Vibe coding an app is fast to a first draft but slow to a working product. Here is what PCWorld's experiment shows and how to plan the fixes.

On this page
  1. What PCWorld's vibe-coding experiment actually showed
  2. Why the first draft is the easy part
    1. Why the first version looks finished but is not
  3. The bug-fixing loop non-coders should expect
    1. Specific requirements you must state
    2. Handling regressions
  4. What this means for people building apps without code
  5. A practical process to reduce rework
  6. Build it with FromScratch
  7. FAQ
Laptop on a desk displaying a simple app prototype, representing vibe coding an app

Vibe coding an app is quick at the start and slow at the finish. PCWorld's Mark Hachman described prompting ChatGPT for a Windows transcription app and getting a first version in minutes. Turning that version into something that worked took many more rounds of fixing. That gap matters for anyone without a coding background who wants to build a small tool with AI, and it shapes how you should plan the work.

What PCWorld's vibe-coding experiment actually showed

Hachman wanted a voice transcription app for Windows. It would run locally, detect the computer's hardware, and offer versions for both x86 and ARM processors. It needed to handle prerecorded and live audio, let him tag speakers and save those speaker models, sync highlighted text to playback, and split the transcript into paragraphs with punctuation. He wrote one detailed prompt and tried it twice in ChatGPT: once in a project using the "Pro" reasoning model, and once in a regular chat using the faster model. He named the two results "HachTalk" and "HachTalk Astra."

The timings are useful as a baseline. According to the original PCWorld article, HachTalk produced a prototype in 4 minutes 43 seconds and an executable in 18 minutes 39 seconds. HachTalk Astra took 3 minutes 3 seconds for the prototype and 9 minutes 49 seconds for the executable. Neither version worked on the first pass. Both returned errors Hachman could not interpret, and both began by producing a non-functional prototype instead of the executable he had asked for.

The point is not that the tools are slow. The point is that the time to a first output and the time to a usable product are very different numbers.

Why the first draft is the easy part

The first version of an AI-built app is built from your description, so it looks like what you asked for. Buttons appear, screens load, and the project seems close. Hachman's two versions looked very different from each other. The Astra version was so basic that he said it was barely recognizable as an app. The Pro version had configurable options. Neither look told him whether the app worked, and a good-looking interface is not evidence that the logic behind it is correct.

Why the first version looks finished but is not

Hachman did not need to read code to make progress. When an error appeared, he took a screenshot of the message and pasted it back to ChatGPT with a request to fix it. The fix was "sort of" successful, and after a few rounds the app transcribed his speech and an audio file. That method works for someone without coding skills, but it is slow, because every round depends on the AI guessing what went wrong from a single error message.

Treat the first draft as a rough prototype. It shows that the idea is possible, not that the product is ready.

The bug-fixing loop non-coders should expect

The most useful lesson in the article is that fixes do not stay fixed. Hachman's version of the app first improved paragraphs and punctuation, then reverted to the older, less accurate transcription. He had to spot that regression and fix it again. A developer might catch this through a test. A non-developer usually catches it by using the app and noticing that something that worked yesterday now does not.

Hachman also found that the AI missed constraints he had not stated. One version accepted only MP3 files, even though he wanted several input formats. He had to say so explicitly. The AI does not know what you have not told it, and it will not raise questions about gaps in your spec the way a human developer would.

Specific requirements you must state

Vague instructions produce vague results. "Support audio files" can mean one format or many, and "save speakers" can mean per session or permanently. Before you prompt, write down:

  • Every input and output, including file types, sizes and formats.
  • What the user clicks, types or sees at each step.
  • Which data must persist between sessions.
  • Edge cases you care about, such as empty files or very long recordings.

You can paste this list into your prompt. It will not remove every bug, but it removes many of the surprises that come from guessing.

Handling regressions

Hachman kept his project in a folder and returned to it when he wanted. That works, but you also need a way to undo changes. When a new fix breaks an older feature, the fastest route back is a saved version. Many AI builders keep a history of changes so you can restore an earlier state. Check whether the tool you use offers this before you start, and save a copy of anything you cannot afford to lose.

What this means for people building apps without code

The PCWorld experiment answers a practical question: is vibe coding worth it? For a single-purpose tool with clear inputs and outputs, usually yes. Hachman's transcription app is a good example. It does one job, and he knew exactly what that job was. He could also judge the result himself, because he was the user.

The limitations are just as clear. Vibe coding is weakest when the app has many interacting parts, when the rules are complicated, or when someone else depends on it being reliable. Those projects need more planning, a longer testing period and, often, a developer who can read the code. If you have a complex product in mind, treat the first week as research, not as the build itself. A beginner's starter guide to vibe coding covers the basics of that planning.

Plan for time. A prototype in minutes does not mean a finished tool in an afternoon. Hachman's first version took under five minutes, and the working app took several iterations and more of his attention. Budget for testing with real files, not just the examples you wrote in your prompt.

Vibe coding limitations also include the risk of building on top of work you do not fully understand. If the app handles customer data or sensitive documents, check the privacy and security of the tool and the approach before you launch.

A practical process to reduce rework

You can reduce the number of fix cycles with a simple routine:

  1. Write the spec first. List inputs, outputs, file types, user actions and what must be saved. Keep it to one page.
  2. Start with the smallest working version. Ask for the core feature only. Add the rest after the core works.
  3. Ask for one change per request. When you combine several changes, you cannot tell which one broke something.
  4. Test after every change. Use a checklist of the features you care about and run through it each time.
  5. Screenshot errors and include context. Paste the exact message, the step you took and what you expected.
  6. Save a version before each risky change. If the next fix breaks something, you can roll back in one step.
  7. Attach real sample files. Give the app your actual content, such as a real PDF or spreadsheet, so you find problems with the data you will really use.

This process is slower than typing a single long prompt and hoping for the best. It is faster overall because you spend less time untangling several problems at once.

Build it with FromScratch

If you want to test this process on a web app, FromScratch is one option. You describe the app in plain language in a chat, and an AI agent builds it. The app uses a React front-end, a Python (FastAPI) back-end and a database, and you can see it in a live preview within minutes. Here is how to work through a build:

  1. Create a new project and open the chat. Paste your spec, including the inputs, outputs and saved data.
  2. Type your first prompt. Use the one below or adapt it to your own app.
  3. Check the live preview. Test each feature in your list before asking for anything new.
  4. Attach real files such as PDFs, images or spreadsheets so the app works with your actual content.
  5. Refine one change at a time. For example, "add a search bar" or "require login" as separate requests.
  6. Restore an earlier version if a change breaks something that worked before.
  7. Publish to a public URL or your own domain when the core features pass your tests.

Start with the free plan to see how the workflow feels before you decide on paid options. Here is a starting prompt you can type into the chat:

Build a simple web app that lets me upload an audio file or paste a transcript, then displays the text split into paragraphs with punctuation cleaned up. Let me tag speakers by name and save those labels for future transcripts. Add a search bar and a 'Restore previous version' option for each saved transcript.

Once that first version runs, test it with a real transcript and note any problems before you prompt again.

FAQ

Can I vibe code an app with no programming experience?

Yes, for simple, single-purpose tools. You will still need to describe the features clearly, test each change and recognize when something is wrong. Complex apps with many rules usually need more planning and sometimes a developer review.

Why does the AI keep breaking things it already fixed?

Changes can interact in ways that are not obvious from the error message. A fix in one part of the app can alter behavior elsewhere, which is what happened when Hachman's punctuation improvement reverted. Ask for one change at a time, test after each one and keep saved versions you can return to.

Is a Windows desktop app the same as a web app?

No. Hachman built a Windows desktop application that ran locally. FromScratch builds web apps with a React front-end and a FastAPI back-end. If you need a desktop installer, plan that as a separate decision, and check whether a web app meets your needs first. The best AI app builder guide explains how to compare tools by the kind of app they produce, and a how-to on building a web app without coding walks through the web option in more detail.

How do I know when a vibe-coded app is ready to use?

Use a short checklist of the features and edge cases from your spec, and run it with real data after every major change. If the app passes the checklist several times in a row, and you can restore a working version when something breaks, it is ready for a small test group. Before you open it to the public, review the privacy and security of any data it stores. The AI app builder overview describes what these tools do with your projects in more detail.

Written by

FromScratch TeamEditorial team

The team building FromScratch, the AI app builder that turns a plain-language description into a real, published full-stack app.