Vibe coding: the upside and the risks
<dfn>Vibe coding</dfn> means building software from prompts and not reading the code that comes out; you look at the result, say it again differently if it is not what you wanted, and the code stays a black box. For a prototype, an internal tool or learning, that is a good trade; for anything with real users and real data, you pay the cost somewhere else, usually later.
- Lesson 14 of 14
- Intermediate
- Free, no signup
Two pans, both of them real
Speed and access
- From idea to something showable, in one afternoon
- Internal tools that never justified the time
- Someone with no access to a technical team can start
- Seeing an idea before you know how to write it
What went unreviewed
- An access check never written, which never errored
- Code nobody can locate on the day it breaks
- A fragment that may carry a public code licence with it
- A skill never built, because being stuck was removed
The pans are level on purpose: which side weighs more depends on what this code is going to hold, and nobody can settle that for you.
Last checked: Facts and tool names in this lesson are re-checked against their sources on this date.
What exactly is vibe coding, and how is it different from AI-assisted coding?
The term spread in 2025 and, like any new term, everybody has their own meaning for it. The definition we use is the one the Stack Overflow developer survey put in its questionnaire, citing Wikipedia: generating software from LLM prompts.
But the sentence that separates this from ordinary use is not in the definition; it is in the behaviour. The real line is this: do you read and understand the generated code or not. Someone who reads the code, critiques it and writes its tests is coding with AI, and their lesson is coding with AI. Someone who only looks at what the run produced and writes the next prompt from that is vibe coding.
So this is a spectrum, not two camps. One person can vibe code a prototype in the morning and rewrite that same code line by line in the afternoon, and both can be right. What is wrong is not knowing which mode you are in.
And one thing that gets lost in the arguments: vibe coding is not a new invention in how people work. Copying code off a forum without reading it was exactly this, and it has twenty years of history. What changed is scale. Then you copied twenty lines; now you receive two thousand, and nobody reads those two thousand either.
How many developers actually do this?
The Persian and English internet are both full of the claim that vibe coding is the industry new way of working. The number says otherwise.
The 2025 Stack Overflow developer survey asked outright whether vibe coding is part of your professional development work, using the definition above. Of the 26,564 people who answered, 72.2 percent said no, and another 5.4 percent said emphatically no. On the positive side, 11.9 percent said yes, 2.8 percent said somewhat, and 0.4 percent said emphatically yes. A further 2.1 percent said they had tried it and 1.2 percent were not sure.
Two conclusions come out of that number, and both matter. First, within the same population where 84 percent use AI tools, about fifteen percent call what they do in professional work vibe coding. Which means widespread AI use and vibe coding are not the same thing, and people who treat them as one, whether in defining it or attacking it, are talking about two different things.
Second, do not read the number for more than it is. This is what people say about themselves, not a measurement of their behaviour, and the sample is self-selected. More importantly, the question was about professional work. Somebody who builds a small app from prompts at the weekend probably ticked "no" in this same survey, and that population is in fact growing.
Where does it genuinely pay off?
Criticising this way of working is easy and most writing does exactly that. But there are three places where vibe coding is not merely acceptable, it is the right choice.
A prototype that is going to be thrown away. When you want to find out whether an idea is worth anything at all, the only thing that matters is how fast you reach an answer you can touch. The quality of code that gets deleted tomorrow is a cost with no reason to pay it. The real condition here is a decision, not a technique: decide from the start that this code will be thrown away, and hold to that decision. A prototype that goes to production is the worst code in the project, and we have all seen every bit of that.
An internal tool for yourself. A script that runs once a month and only you run. A script that renames ten thousand files. A small page that shows one number. These have no users, no attacker, and if they break only your own time is lost. Worrying about code quality here is worrying about the wrong thing.
Learning, with one condition. Seeing how an idea works before you know how to write it builds motivation, and motivation is not a small thing in learning. The condition is that you go back afterwards and write the same thing yourself. Without that second step, vibe coding does for learning what watching a swimming video does for swimming.
And an advantage specific to Iran that is rarely stated: access. Somebody sitting in a small town with no route to a technical team can now take an idea far enough to show it to people. That is not a small thing, and no criticism of this method should ignore it.
Where does the cost show up?
None of this method costs are visible on day one, and that is what makes it dangerous. We talk here about mechanisms only, not about scary stories with no source.
Security, and one example most people get backwards. The common assumption is that danger means a key in client-side code. Now read Google own guidance page about Firebase API keys: it says Firebase keys, unlike typical API keys, are not used to control access to backend resources and are fine to include in code or checked-in config files; what actually protects the data is Security Rules. Which means a vibe-coded app can have a perfectly harmless key and a database open to everybody, because the rules were never written and no key scanner reports a thing. And two lines higher, the same page says the exact opposite about the Gemini API key: that one must never be in your code. Two keys in one app, two opposite rules, and the only way to know which is which is to read the documentation. A model writes code that works, and that is not the same as safe.
Maintenance. Code you have not read puts you, when it breaks, in a position no tool can rescue: you do not know where to look, because you do not know what is where. The usual route is to call the same model and say fix it, and that works while the problem is small. Once the program grows past what fits in one conversation, that route closes too.
Licence ambiguity. These models were trained on public code and can produce a fragment resembling existing code under a restrictive licence. Someone who does not read the code has, in practice, no way to notice. That GitHub added a setting to block suggestions matching public code shows the vendor itself treats the concern as real.
And a cost you pay yourself. In the same survey, 20 percent of respondents said they have become less confident in their own problem solving. We unpack the mechanism in coding with AI: learning comes from being stuck, and a tool that removes being stuck has removed the thing that was teaching you.
What day one shows you, and what it does not
-
1
It works
The page loads, the button works, what you asked for is on the screen. The only layer visible on day one.
-
2
The edge cases
Empty input, very large input, two people at once. These arrive with real users, not with your own testing.
-
3
Access control
Who is allowed to see or change what. Its absence throws no error, and to the app owner everything looks normal.
-
4
Maintenance
The day something breaks and you do not know where to look, because you never knew what was where.
-
5
Licence and ownership
Where this fragment came from and on what terms. Someone who has not read the code has, in practice, no way to find out.
None of the layers below the waterline throw an error, and that is the hard part: a program that works is no evidence that a program is sound.
Our position: vibe code the draft, engineer the product
Arguing whether vibe coding is good or bad is a fruitless argument, because the answer depends on something neither side states: what is this code going to be holding.
Our practical rule is a question rather than a principle: if this program did entirely the wrong thing tomorrow, what would be lost? If the answer is "nothing, I would run it again", vibe code it and do not waste your time. If the answer includes somebody money, somebody data or somebody reputation, that code has to be read; whether by you or by whoever you are paying.
The practical line we hold is three things. Wherever there is user data, the code gets read, no exceptions. Wherever there is money, the same. Wherever something is meant to live longer than a season, the same, because after three months nobody remembers what they said in the prompt.
On the other side, for getting an answer about an idea, for a tool only you run, and for seeing what something would look like, this method is the fastest thing available to you, and refusing to use it is no virtue.
One last point for anybody handing work to a freelancer or an agency: asking "who read this code" is not a rude question, and it is not hard to answer. If you get no answer, that is the answer. How we do our own work here is written up in app and software development.
Vibe code the draft, engineer the product
-
1
The draft
Prompt, look at the result, move fast. Code quality is not a criterion here at all.
-
2
Decide: keep or throw away
One question: if this did entirely the wrong thing tomorrow, what would be lost? The answer decides which way the path goes.
-
3
Rewrite with review
The same feature, this time in small changes that get read, with a test defined before the code.
-
4
Before launch: access, input, keys
The three that never error and are always checked by hand. For every key, read that service own documentation, not a general rule.
Step three is where most projects break: not because it is hard, but because the prototype works and nobody sees a reason to touch it.
AI in this kind of work
This whole lesson is about a way of working with AI, so this block covers what decides how expensive that way turns out: which tool you vibe code with and what you keep for yourself. Our position in one sentence: <strong>a tool that shows you every change, even when you do not read it, is safer than one that shows only the result, because on the day you have to read, there is something to read.</strong>
Tools that actually help
- Cursor An editor with a built-in agent. For this way of working its real advantage is that it shows changes as a diff inside the editor; so if you decide to read one day, it is right there. Its own pricing page shows a free plan with limited requests and a professional plan at twenty dollars a month. We claim nothing about access from Iran: we found no supported-countries list and we have not tested it ourselves.
- GitHub Copilot For an Iranian reader its access story is unexpected: GitHub own trade-controls page says a US Treasury licence covers its cloud services for developers resident in Iran, free and paid. We quote that and make no claim about payment. One of its features bears directly on this lesson: suggestions matching public code can be blocked, and for somebody who does not read the code that is the only practical defence against licence ambiguity.
- Claude Code A command line agent that sees the repository and can change several files at once. That same power is what takes vibe coding from a small app to a real project, and in the same proportion makes not reviewing more expensive. It installs free but does not run without a Claude subscription or an Anthropic Console account, and Iran is not on Anthropic supported-countries list.
- Gemini Suited to the second step this lesson insists on: after you vibe code something, take it and ask for an explanation so you understand what you built. Its study mode also asks questions instead of handing over answers. Google own page says the Gemini web app works in more than two hundred and thirty countries and territories, and Iran is not on that list.
Where it backfires
The risk specific to this method fits in one sentence: none of the things that are wrong produce an error. An access check never written does not error. Unvalidated input does not error. A fragment carrying a stranger licence does not error. The only feedback this method gives you is that the program ran, and that feedback is silent about exactly the things that cost money later.
The Firebase example in the costs section is the most concrete form of this, and its source is Google own page: a Firebase key in client-side code is fine because it does not control access, but the same page says the real protection is Security Rules, and it says the Gemini API key must never be in your code. Two keys, two opposite rules. No model tells you which is which unless you ask, and someone who does not read the code does not know there is anything to ask.
Two practical ways to reduce it: before launch, instead of "does it work?" ask "what happens if somebody changes this?"; and for every service that hands you a key, read that service own documentation page about that key rather than a general rule. For how each of these tools can be paid for from Iran, see the buying guide.
Sources: Stack Overflow 2025 Developer Survey: AI Wikipedia: vibe coding (the definition the survey used) Google: API keys for Firebase, and what actually protects data OWASP Top 10: security misconfiguration GitHub Copilot plans GitHub and Trade Controls Cursor pricing Anthropic: supported countries Google: where the Gemini web app is available
Where this advice stops
This lesson is neither a security guide nor a legal guide, and neither section should stand in for real advice. Three things are deliberately absent: a list of build-and-publish tools, which change every month; any number for how much time this method saves, because we have no source we would defend and we have not measured it ourselves; and any specific story of an app that leaked because of this method, because every account we found either had no primary source or could not be verified. What is here is reasoning from mechanism, and every technical claim is sourced to the vendor own page. One more boundary, stated honestly: the line between vibe coding and AI-assisted coding is not a sharp one, and in practice everybody draws it somewhere different. What we offer is a test rather than a definition: if you cannot explain what the code does, you have not read it.
From our own work
That "a key in client-side code" is not the only shape of the problem is, for us, an architecture decision rather than an opinion. The SEO tools on this site connect to an outside data service, and that service username and password are stored in a WordPress option; every call is made by PHP itself and the visitor browser never talks to that service. On the day this lesson was checked we tested that rather than recalling it: the name of that credential appears only in PHP files under the plugin includes directory and in no JavaScript file; main.js contains it zero times; and in the output of the public tools page, the only place that service name appears is the page own copy saying where the data comes from. In other words, you can name a service in your page text and never let its credential leave the server. You can run the same test on your own site and it takes a minute: search your page output and your JavaScript files for the name of every key that exists in your code.
Real follow-up questions
Can you build a real app without knowing how to program?
Something that works, yes. Something you can rely on depends on what it is holding. While there are no real users, no real data and no money involved, that is fine; from the moment there are, somebody has to read the code, and if that somebody is not you it has to be someone.
How do I make vibe-coded code secure?
Not with one scan or one prompt, because the problem is usually not something that is there but something that is not, and a tool does not find what is absent. The smallest thing that genuinely helps: for every piece of data you store, write down who is allowed to see it and change it, then find that in the code; and for every key in the project, read that service own documentation about that key.
Is vibe coding going to end programming jobs?
We do not forecast, and anybody who hands you a definite number did not get it from anywhere. What can be seen is this: the work with market value was never typing code, it was deciding what gets built and why it is built that way. Those decisions are still human decisions, and in the same survey 75.3 percent said that even if AI could do most coding tasks, they would still ask a person when they do not trust its answers.