Vibe Coding Production: What Gartner's 60% Claim Means
Vibe coding production readiness, explained: what the Gartner headline says, what it doesn't, and a free checklist to test and ship your AI-built app.
On this page
Vibe coding production is the question every non-coder hits sooner or later: the app works in the preview, but will it hold up with real customers? A recent headline on CXOToday.com points at the answer the industry is moving toward. This article covers what the headline says, what it doesn't, and the habits you can adopt today instead of waiting for better tools.
Vibe coding production: what Gartner is predicting
CXOToday.com ran a piece titled "From Vibe Coding to Production Discipline: Gartner Predicts 60% Fewer Defects With AI Coding Harnesses by 2028." The headline carries three claims: a prediction from Gartner, a 2028 time horizon, and a 60% reduction in defects tied to AI coding harnesses.
One caveat before going further. The text we could extract from the page was mostly a cookie notice, so this article works from the headline alone. We don't describe the report's methodology, its definitions or its supporting data, because we haven't seen them. If you want the details, read the original piece.
What the headline says and what it doesn't
It says an analyst firm expects defect rates to fall substantially by 2028 when teams use AI coding harnesses. It frames the shift as a move from "vibe coding" (improvising with prompts and hoping the result works) to "production discipline" (treating AI-generated software with the same care as any software that real people depend on).
It doesn't tell us what baseline the 60% is measured against, which teams or projects it covers, or whether it applies to apps built by non-programmers. Don't assume it does.
Why "prediction" is the key word
A prediction is a direction, not a measured result. It's useful because it tells you where serious practitioners expect things to go: toward verification and away from blind trust. It's not a guarantee that your app will have fewer bugs, and it says nothing about the tool you use today. Treat the number as a signal and the habits behind it as the actual takeaway.
What an AI coding harness means in plain English
"Harness" is jargon, and definitions vary by vendor. What follows is a general explanation, not Gartner's definition.

In broad terms, an AI coding harness is the structure wrapped around an AI agent that writes software. Instead of one prompt in and one blob of code out, there are clear instructions, automated checks, tests and review steps. The goal is that the output gets verified rather than trusted.
Guardrails around the agent, not just a smarter prompt
Compare two workflows.
| Prompt and ship | Harnessed workflow | |
|---|---|---|
| Input | One long, vague prompt | A clear spec with rules and constraints |
| Output | Whatever comes back | Output checked against the spec |
| Testing | "It looks fine in the preview" | Defined checks run after each change |
| When something breaks | Re-prompt and hope | Find the change that broke it, roll back |
| Release | When it feels done | When the checks pass |
That's the difference between vibe coding and production-ready code. The AI may write both versions. What differs is the process around it. If you want more on how AI builders compare with traditional no-code tools, see No-code vs AI app builders: what's the difference.
Why it matters if you build apps without code
A developer can read the code and spot a missing permission check or a sloppy database query. If you build without coding, you usually can't, so you have to catch problems by using the app, and that takes a deliberate process.
The gap between a working demo and a reliable app
A demo works on the happy path: you log in as yourself, click the buttons in the right order and type tidy data. A real app meets users who paste a 4,000-character name into a form, upload the wrong file type, open it on a phone, hit back mid-checkout or share a link with someone who shouldn't see it.
The preview showing your idea is real is a great first milestone. It's the start of testing, not the end.
Where defects usually hide in AI-built apps
The places worth checking first are predictable:
- Login and sessions. Can someone reach a page without logging in? What happens after logging out?
- Permissions. Can user A see or edit user B's records?
- Forms with bad input. Empty fields, very long text, special characters, wrong formats.
- Data that disappears. Does a record survive a refresh, a new session, an edit?
- Edge cases in your own rules. The "what must never happen" cases, like double-booking a slot or charging twice.
For a deeper pass on the security side, the vibe coding security risks checklist walks through what to verify before launch. And if you're wondering whether vibe coding is safe for business apps in general, Vibe coding for business: what Lovable's pivot means covers how the market is shifting toward that use case.
A production discipline checklist you can use today
You don't need a harness to borrow its logic. Here's how to reduce bugs in AI-generated apps with habits that cost nothing.

Spec first, then build
Before your first prompt, write half a page covering:
- Who uses it (roles: admin, customer, staff).
- The five key actions each role must be able to do.
- What must never happen (one customer seeing another's data, an unpaid order marked paid, a deleted record with no way back).
This becomes your test script later. Without it, you have nothing to test against.
Small changes, test every time
Ask for one change per message: "add a search bar to the client list," not "add search, filters, export and a new dashboard." When something breaks, you know which change caused it. After each change, run through your key actions for ten minutes. It feels slow and saves hours.
Test with real content
Demo data hides problems. Use your real PDFs, real product photos, a real spreadsheet export with its blank cells and odd formatting. If you're wondering how to test a vibe-coded app without reading code, this is the core of it: act like the messiest real user you can imagine, and write down what breaks.
A quick test script you can reuse:
- Log in as each role and try one action that role should not be allowed to do.
- Submit every form empty, then with absurdly long text, then with special characters.
- Upload a file that's too large or the wrong type.
- Refresh mid-task and confirm nothing is lost.
- Open the app on your phone.
Keep a restore point
Before any risky change, note which version is your last known good one. When a change breaks something, restoring beats debugging. Fixing forward with more prompts on top of a broken state tends to compound problems.
Pre-launch security pass
Before the app goes public, check login requirements, who can see what, and what's exposed if someone guesses a URL. Two resources help here: the AI app security checklist for founders and the vibe coding deployment checklist.
Build it with FromScratch
FromScratch fits this way of working because the loop is short: you describe the app in chat, an AI agent builds it (React front-end, Python FastAPI back-end and a database), and you see it running in a live preview within minutes. Then you refine by chatting, which suits the small-change, test-every-time habit.
Here's a practice project that turns the checklist above into something real: an internal release-checklist tracker for your team's launches. It's a good example of an internal tool you can build with AI.
Preview, refine, restore
- Open FromScratch and start a new project. The free plan is enough to try this.
- Paste the prompt below into the chat.
- Review the live preview. Create a test launch, add checklist items and try to mark it ready with one item still open. It shouldn't allow that.
- Refine one change at a time, for example "add a due date to each item," and re-test after each.
- Attach real content if useful. You can attach PDFs, images or spreadsheets, so upload your actual launch checklist and ask the app to use those items.
- Use version history. Every change is saved, so if a tweak breaks the "ready to launch" logic, restore the earlier version.
The prompt:
Build an internal release-checklist tracker for my small team. It should let me create a checklist for each app launch with items like 'tested login', 'tested with real data', 'checked permissions' and 'backup version saved', assign each item to a person, mark it done, and show a clear 'ready to launch' status only when every item is checked. Require login and add a simple dashboard of open items across all launches.
Publish when you're ready
When your checks pass, publish with one click to a public URL, or connect your own custom domain. Publishing is the last step of the checklist, not the first. Use the tracker you just built for your next real app.
What to watch as AI coding tools mature
Don't wait for 2028
Even if the prediction proves right, it's a forecast about the future. A spec, small changes, realistic testing, restore points and a pre-launch pass are free and apply now. They're also what makes any future tooling work better, because a harness needs something to check against, and your spec supplies it.
Questions to ask any AI app builder
When you evaluate tools, ask how they help you verify output, not only generate it:
- Can I see a working preview before anything goes public?
- Are changes saved so I can go back to a known good version?
- Can I use my real files and data while testing?
- Is login straightforward to require? (See how to add user login without coding if you haven't done this before.)
- What happens between "it works" and "it's live"?
Revisit the Gartner prediction as more details surface, and keep treating the 60% figure as direction, not a promise.
FAQ
Is vibe coding safe for a real business app?
It can be, if you add the verification a developer-built app would get: a clear spec, realistic testing, permission checks and a security pass before launch. Prompting alone doesn't make an app safe or unsafe. The process around it does.
Does Gartner say AI-built apps will have 60% fewer defects?
The CXOToday.com headline says Gartner predicts 60% fewer defects by 2028 with AI coding harnesses. That's a prediction about a specific approach, not a claim about every AI-built app, and we haven't seen the underlying report's details.
Do I need to read code to test my app?
No. Testing means using the app the way real users would: trying every role, submitting messy input, uploading real files and checking that data persists. Writing your "what must never happen" list first tells you exactly what to try.
How do I undo a change that broke my app?
Restore an earlier version. In FromScratch every change is saved, so you can return to the last version that worked, then re-apply your change in a smaller step. That's usually faster than prompting your way out of a broken state.
What should I check before publishing?
At minimum: login is required where it should be, each user sees only their own data, forms handle bad input, and your key actions work with real content. Then run through the deployment checklist and publish only once everything passes.