Code Is Cheap Now. Software Isn't.
AI made typing cheap. It did not make software cheap. The part that was never code just got more expensive, and a lot of people building things right now haven't noticed.
Heartbyte Team
Engineering & Strategy
A 17-year-old built a working SaaS prototype in a weekend last month. Auth, dashboard, Stripe checkout, the lot. Two years ago that was a junior team's quarterly sprint. He did it between Friday night and Sunday afternoon with Cursor and a Red Bull.
Meanwhile, we're quoting clients for systems that do roughly the same thing, and the quotes are not weekend money. They're a real engineering bill, with real engineers, on a real timeline.
"If a teenager can build it in 48 hours, why does your version cost what it costs?"
It's one of the most fair questions a client has ever asked us, and it deserves a real answer. The short version: code is not software. AI made code cheap. The part that isn't code did not get cheaper, and in some ways it got worse.
What AI actually made cheap
AI didn't make "software" cheap. It made typing code cheap. Turning an idea into lines that compile and sort of run is close to free now. The thing that used to drive every engineering quote, somebody sitting there writing the lines, is gone.
That's a huge speed-up and we're not pretending otherwise. We use these tools every day and we ship faster because of them. The demo you wave at your co-founder over coffee, the landing page, the CRUD app, the Telegram bot, the prototype that handled three users, that part is close to free now.
What nobody who's only built demos wants to hear is this: that part was always the easy part. Building a working demo was never the expensive bit. It was maybe 10% of the work, dressed up to look like 90% because it was the part you could see.
What got cheap
- ▸ Writing the first version. Boilerplate, CRUD scaffolds, UI mockups, glue code. The "type the obvious thing" phase.
- ▸ Translating between formats. SQL to ORM. API spec to client. Mockup to component. The mechanical conversions that ate hours.
- ▸ Looking things up. Stack Overflow archaeology, library docs spelunking, syntax recall. The "how does that one obscure function work again" tax.
- ▸ The first 80%. Anything that looks like "shape the rough thing." A real, measurable speed-up.
That's the cheap part, and it's a real list. It's just not software.
What software actually is
Software is code that has to keep working. Those last three words do most of the work in that sentence. A demo doesn't have to keep working. A demo has to work once, on the laptop of the person showing it, for the length of a meeting. That bar is nearly free to clear now.
Software has to clear a much higher bar. Software has to:
What software has to do (that demos don't)
Survive the user who pastes 50,000 characters into the name field.
And the one who uploads a 4GB PDF. And the one who clicks submit eleven times in two seconds. Every edge case a demo never sees is a Monday morning support ticket waiting to happen.
Stay fast when the database hits 100,000 rows.
The query that runs in 40ms with 10 rows takes 12 seconds with 100k. The demo never noticed. Production will.
Authenticate, authorise, audit.
Who can see what. Who can do what. Who did what last Tuesday at 3pm, and is that going to be a problem in the next compliance review. None of this is in the demo.
Survive the third-party API changing its mind.
The payment gateway changes its webhook format. The mobile OS drops an upload format. Your code has to catch that, fall back, alert someone, recover. Nobody writes that on day one. Everyone needs it by year one.
Tell you when it's broken.
Monitoring, logging, alerts, dashboards. The plumbing that means a problem hits an engineer at 2am instead of a customer at 9am. Demos have none of this. Software lives or dies by it.
Be understandable to the next engineer.
The one who joins in a year. The one who joins after you've forgotten why you wrote it that way. Good docs, clear names, a sensible structure. Code that only the person who prompted it can read is a liability, not software.
Keep doing all of this for years.
Dependencies update. OS versions change. Browsers drop old APIs. Security patches land. "It works today" is one point on a timeline. Software is the whole line.
None of that got cheaper. AI doesn't own production. It isn't on-call at 2am. It has no relationship with your client. And it doesn't get audited.
The cruel inversion: cheap code creates expensive software
When code was expensive, you wrote less of it. Every line cost something, so you thought twice before adding it. The codebase stayed small because adding to it hurt, and that pain did most of your architecture work for you.
Now you can generate fifty files in twenty minutes. Every one of them has to be understood, tested, wired in, secured, and maintained for years. The cheap part grows with the number of prompts. The expensive part grows much faster, with the amount of code.
"You used to be limited by how fast you could type. Now you're limited by how fast you can think clearly about what you typed. The bottleneck moved. It didn't disappear."
We see this every month. A founder shows up with 30,000 lines of AI-generated code and a feature that "almost works." Login is handled in three places. The database has six migrations that contradict each other. There are four different ways to make an HTTP request, all written by the same person, and not one of them handles an error. The code "works" if you mean the happy path renders. It doesn't work in any way a paying customer would recognise.
Rebuilding from scratch is almost always faster than untangling it. The cheaper code got, the more of it people made, and the more of this we see.
What got more expensive
Strange as it sounds, three things in software got more expensive in the AI era, not less. All three come down to judgement, not typing.
Knowing what to build in the first place.
AI will happily build the wrong thing at record speed. It won't push back. It won't tell you your spec contradicts itself. It won't say "your second feature breaks your first one." Knowing what to build, what belongs in v1 and what doesn't, what's a real need and what's just a nice idea, has never been worth more. Everything around it sped up, which makes the wrong calls a lot more expensive to undo.
Owning the thing in production.
A model can write a deploy script in three seconds. It can't be the human who gets paged when that script fails at 1am on a public holiday. Owning production, the simple stance of "if this breaks, I will fix it before users notice," is a human job. The demand for it went up, not down, because there's now more code running in more places than ever.
Maintaining what already exists.
Code rots whether you wrote it or a model did. Dependencies update. New threats show up. Languages get new versions. The team that wrote it leaves. None of that is cheaper now. If anything, there's ten times more code in the world than before, and ten times more maintenance debt with it.
The pricing flip
The old engineering bill worked like this: pay engineers a lot to type a lot. Most of the hours went into writing the code itself. The expensive parts, architecture, judgement, ops, maintenance, were tucked in around the edges and rarely shown as a line item.
The new engineering bill is split differently. You pay engineers less to type, and more to think about what's worth typing, to read what got typed, to fit it into something that holds together, and to keep it alive in production. The total is about the same. The shape changed.
Two ways to read a quote in 2026:
The quote dropped 70% "because AI."
Ask what got cut. Almost always it's the parts that aren't typing: testing, monitoring, hardening, docs, maintenance after launch. You're being quoted for a demo, not software.
The quote barely moved, but the deliverable did.
The vendor is using the saved typing hours on the parts that always mattered: better architecture, more testing, real monitoring, proper docs. Same bill, a lot more software per hour spent.
If you're shopping for a software vendor right now, ask one question out loud: "What are you doing with the time AI saved you?" A good answer has the words "testing," "review," "ops," and "maintenance" in it. A bad answer is "passing the savings on to you" and nothing else. The savings are real. So is the work they don't cover.
The teenager and the real quote
Back to the 17-year-old. His weekend SaaS prototype is real. It works, it runs, and three of his friends signed up. Impressive, and a year ago it would have been impossible.
It also has no real login beyond hardcoded sessions, no rate limiting, no logging, no backups, no monitoring, no automated tests, no plan for database changes, no admin tools, no compliance, no error recovery, no second engineer who can read it, and the main database table is called stuff. The first time it gets 50 users, half of it falls over. The first time someone deletes an account, the leftover records will haunt every report he writes from then on.
Our client's quoted version has all of those things. That's not bloat. That's the difference between a thing that works on a Sunday and a thing that's still working in 2031.
"Code is the part of software that looks like software. Software is everything that makes the code keep being software a year from now. The first one got cheap. The second one didn't, and probably won't."
Anyone telling you otherwise is selling you a demo and calling it a product. The demo is real, but it's not a product yet. Knowing the difference is the most expensive skill on the market right now, and the one most worth paying for.
Got a working demo and a feeling that something's missing?
We help founders and teams turn AI-generated prototypes into real software, the kind that survives real users, real data, and real production traffic. No rebuild if it can be rescued. Honest scoping either way.
Talk to Us About Your ProjectHeartbyte Team
Heartbyte is a bespoke software development company based in Malaysia. We build web, mobile, and custom software for ambitious businesses — with 15+ years of combined engineering experience and zero change request fees, guaranteed.