Code Is Cheap Now. Software Isn't.
AI collapsed the cost of typing. It did not collapse the cost of software. The part that wasn't 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 the most reasonable question 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
Let's be honest about the magic. AI didn't make "software" cheap. It made typing code cheap. The act of converting an idea into syntactically valid lines that compile and superficially run is now essentially a commodity. The bottleneck that used to dominate every engineering quote — somebody, somewhere, has to physically write the lines — is gone.
That's a real, enormous productivity gain. We're not denying it. We use these tools every day and we ship faster because of them. The demo you can wave at your co-founder over coffee — the landing page, the CRUD app, the Telegram bot, the working prototype that handled three users — that part is genuinely close to free now.
Here's the thing nobody who's only built demos wants to hear: that part was always the easy part. Producing a working demo has never been the expensive thing about building software. It was maybe 10% of the work, dressed up to look like 90% of it 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. It's a real list. It's a meaningful list. It's not, however, software.
What software actually is
Software is what you call code that has to keep working. That qualifier carries most of the weight in the 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 duration of a meeting. That bar is now nearly free to clear.
Software has to clear a different 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 ticket waiting to happen.
Stay fast when the database hits 100,000 rows.
The N+1 query that runs in 40ms with 10 rows takes 12 seconds with 100k. The demo never noticed. Production absolutely 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 schema. The mobile OS deprecates 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, alerting, dashboards. The plumbing that means a problem hits an engineer at 2am instead of a customer at 9am. Demos don't have any 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 when you've forgotten why you wrote it that way. Documentation, naming, architecture, a coherent shape. Code that's only legible to the person who prompted it isn't software — it's a liability.
Keep doing all of this for years.
Dependencies update. OS versions change. Browsers deprecate APIs. Security patches drop. The "it works today" demo bar is a single point on a timeline. Software is the integral.
None of that got cheaper. AI does not own production. AI is not on-call at 2am. AI does not have a relationship with your client. AI does not get audited.
The cruel inversion: cheap code creates expensive software
Here's where it gets uncomfortable. When code was expensive, you wrote less of it. Every line had a cost, so you negotiated with yourself before adding it. The codebase stayed small because adding to it hurt. Constraints did 90% of your architecture work for you.
Now you can generate fifty files in twenty minutes. Each of them has to be reasoned about, tested, integrated, secured, and maintained — for years. The cheap part scales linearly with prompts. The expensive part scales superlinearly with 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." Authentication is in three places. The database schema has six migrations that contradict each other. There are four different ways to make an HTTP request, all written by the same person, none of them error-handling. The code "works" in the sense that the happy path renders. It doesn't work in any sense a paying customer would recognise.
Rebuilding from scratch is almost always faster than untangling it. Cheap code, expensive software. The cheaper the code got, the more of it people made, 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 are some flavour of judgement over typing.
Knowing what to build in the first place.
AI will happily build the wrong thing at record speed. It does not push back. It does not tell you your spec is contradictory. It does not say "your second feature breaks your first one." The skill of scoping — knowing what should and shouldn't be in v1, what's a real requirement and what's a vibe — has never been more valuable, because everything around it sped up and made the mistakes more expensive to undo.
Owning the thing in production.
A model can generate a deploy script in three seconds. It cannot be the human who gets paged when the deploy script fails at 1am on a public holiday. Production responsibility — the actual posture of "if this breaks, I will fix it before users notice" — is a human thing, and the demand for it went up, not down, because there's now more code running in more places than ever before.
Maintaining what already exists.
Code rots whether you wrote it or a model did. Dependencies update. Threats evolve. Languages release new versions. The team that wrote it leaves. None of that is cheaper now. If anything, the volume of code in the world just went up by a factor of ten, and the volume of maintenance debt went up with it.
The pricing flip
The old engineering bill broke down roughly like this: pay engineers a lot to type a lot. Most of the hours went into producing the code itself. The expensive parts — architecture, judgement, ops, maintenance — were folded in around the edges and rarely line-itemed.
The new engineering bill breaks down differently. Pay engineers less to type. Pay them more to think about what's worth typing, to read what got typed, to integrate it into something that holds together, and to keep it alive in production. The total is roughly the same. The shape changed.
Two ways to read a quote in 2026:
The quote dropped 70% "because AI."
Ask what got removed. Almost always it's the parts that aren't typing — testing, monitoring, hardening, documentation, post-launch maintenance. 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 to do the parts that always mattered — better architecture, more testing, real observability, proper docs. Same bill, dramatically more software per hour spent.
If you're shopping for a software vendor right now, this is the question worth asking out loud: "What are you doing with the time AI saved you?" A good answer involves the words "testing," "review," "ops," and "maintenance." A bad answer involves the words "passing the savings on to you" with no mention of the other parts. 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. Three of his friends signed up. Genuinely impressive, and a year ago, completely impossible.
It also has no authentication beyond hardcoded sessions, no rate limiting, no logging, no backups, no monitoring, no automated tests, no migration story, no admin tools, no compliance posture, no error recovery, no second engineer who can read it, and the database table is called stuff. The first time it gets 50 users, half of it falls over. The first time someone tries to delete an account, the orphaned 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. The product isn't, yet. Knowing the difference is the most expensive skill on the market right now — and the 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 actual software — the kind that survives real users, real data, and real production traffic. No replatform 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.