Friday afternoon, three hours with Claude, and the old Excel sheet has turned into a web app. It looks good, the math checks out, the team loves it. We know that feeling: we went through exactly this with our own estimation tool.
Then Monday comes around. Someone asks: “Couldn't we give this to our customers?” IT asks: “Who's going to maintain it?” And you start wondering: What would it actually cost to turn this into real software?
That's what this post is about. Not whether AI makes software development cheaper (short answer: yes, but maybe not where you'd expect), but the honest math behind it, with real numbers from our projects.
- A simple vibe-coded prototype costs “almost nothing” these days. Production-ready software still costs money, but the line items have shifted.
- AI mainly lowers the cost of writing code. Architecture, security, review and operations stay, and some of them may even grow. Don't forget that vibe coding without tight boundaries often leads to bloated apps. Feature overload, if you will.
- Our real projects ranged from €6,000 (prototype) to €90,000 (complex application with permission management). That's still a wide range, but AI pushes it down, if the setup is right.
- The lever isn't a single tool but an AI Engineering Framework: shared standards, guardrails, a reference architecture.
- The resources you free up don't belong in more features, they belong in research and design. Products rarely fail because of the code. They fail in the market.
Your prototype is not your product
When we vibe-coded our Excel estimation tool into a web app, we ended up with a working application: 918 lines of code in a single HTML file, correct PERT calculations, a decent-looking UI. The cost: a few hours and a Claude subscription. A nice experiment.
The first look under the hood told a different story: XSS vulnerabilities from unsafe innerHTML, everything in global scope, no validation (the best case was allowed to be larger than the worst case), no tests, no documentation. For an internal single-user tool: totally fine. For anything that involves multiple people, real data or an IT department: not deployable.
You can already hear the naysayers: “See, AI just can't do it…” But that's too sweeping. What happened here is the difference between a quick-and-dirty prototype and real software. A prototype proves that an idea works. Software has to keep working next year too, when the intern uses it, an attacker probes it and a colleague wants to build on it.
What software really costs: one tool, three levels
Before we get to the AI question, let's set a baseline. We'll stick with the example you already know: an Excel tool for project calculations that has grown over the years and is supposed to become real software. Depending on what “real software” means, we're talking about very different projects. The price ranges come from real projects in our practice, broken down in more detail in our cost article:
| Level | What's added | Budget |
|---|---|---|
| “S”: the validated prototype | Workshop, calculation logic cleanly implemented as a web app, simple UI, mobile-friendly, hosting. A small group of users, no roles, no integrations. | €6,000–9,000 |
| “M”: the department solution | Login and central data storage in a database, multiple users working at the same time, integration with existing interfaces (e.g. project data from the ERP), frontend based on your design template. | €10,000–20,000 |
| “L”: the company-wide software | Integration with central user management, three levels of user roles with their own permissions, data versioning, three languages, a test environment without live data, automated deployment, on-premise operation. | €80,000–90,000 |
What stands out: the core function (calculate, save, display) is practically the same at all three levels. What multiplies the price by more than ten is everything around it: authentication, roles and permissions, data versioning, integration into existing IT, deployment, a test environment.
And those are exactly the line items that tend to get overlooked.
Where the money goes today (and where it no longer goes)
The good news: AI-assisted development really does change the math. Pure implementation (typing out components, forms, CRUD logic) has become a lot faster. In our home-turf stack (TypeScript, React, Next.js) this works particularly well, because the models know this ecosystem inside out and the TypeScript compiler often catches errors at compile time.
The not-so-good news: the items that have always made the difference between “S” and “L” don't get cheaper with AI. Some of them get more expensive:
- Reviewing instead of writing. When AI produces 2,000 lines in an hour, the bottleneck becomes the question of who understands those lines and takes responsibility for them. Unread code isn't a saving. That kind of thing usually comes back to bite you sooner rather than later.
- Security and compliance. Secrets in the code, unvetted dependencies, missing access controls: the classic prototype sins scale right along with the speed of code generation. The deeper your tool is woven into your business, the more critical these points become.
- Architecture and consistency. Four teams with four AI setups build four different solutions to the same problem. Every app becomes an island, and every island needs its own maintenance.
AI hasn't lowered the cost of software. It has flipped the cost structure. Writing code used to be the expensive part, and everything else came on top. Today writing is cheap, and everything else is the project.
Part of the solution: an AI Engineering Framework
This is where agencies could easily say: “That's why you need professionals.” But that's only half true. What teams actually need is a setup in which AI speed and production quality aren't at odds. We call it an AI Engineering Framework. It consists of three building blocks, which we use with a major car manufacturer, for example. A nice side effect: you stay independent of any particular AI model.
1. Team standards
An AGENTS.md with your conventions, the open standard that Cursor, Copilot and Codex read natively. Claude Code relies on CLAUDE.md, but it's easy to point it at AGENTS.md. That way your conventions live in one central place instead of being scattered across four different tools. What currently lives in the heads of individual developers gets documented and versioned. That lowers review costs, because the AI builds the way your team builds from the start.
2. Technical guardrails
Automated checks in layers, ordered from cheap to expensive: pre-commit hooks, static analysis, supply chain checks, AI review, human review. Each layer catches a different class of errors. One rule is non-negotiable: AI-generated code never goes into production unreviewed.
3. Reference architecture
A forkable setup with auth, tests, CI/CD and security checks, already wired up. New projects start from a proven foundation instead of an empty file. The very items that made project “L” expensive (authentication, roles, deployment) are already solved here.
The effect on the budget: the path from prototype to software is no longer a fresh start, you begin with a solid foundation. The €80,000 “L” category doesn't disappear, but it moves closer to the €20,000 category. And above all, it becomes predictable.
What would the path look like for your prototype, in actual numbers?
In a first call, we'll look at your setup and tell you honestly which building blocks are worth it, and which aren't.
Book a callThe second shift: the money moves from code to product
So far it sounds as if the path from prototype to software is mainly an engineering problem. But that's only half of it. Because the most uncomfortable truth is this: most products don't fail because of the code or the design. They fail because nobody needs them.
And this is where AI prototyping gets really interesting. When a prototype takes days instead of weeks, there are two ways to use the time you've gained: build more, faster. Or find out faster what should be built in the first place.
Test hypotheses instead of stacking features
Remember project “S” from above, the €6,000–9,000 prototype? For the same budget, we can now build much more complex prototypes with AI support. But whether your target audience actually “buys” the result is a different question entirely, and no prototype, however fast, answers it on its own.
So our recommendation is pretty simple: don't put the freed-up resources into more features, put them into (user) research. Talk to your target audience, form hypotheses and test them, ideally with prototypes you vibe-coded yourself. That's exactly their sweet spot. Whatever holds up, we then turn into a reliable product. That way you don't produce junk faster, you produce validated knowledge about your market faster. This is exactly what our Lean Inception and Design Sprint workshops are for.
Your brand doesn't belong to the AI
The second thing that tends to fall by the wayside when you build fast: the interface. Have you noticed that software products look more and more alike? That's not just a gut feeling. A research team at Indiana University analyzed around 200,000 screenshots of 10,000 websites a few years ago: layout differences between websites shrank by more than 30% between 2010 and 2016, and the web was at its most diverse from 2008 to 2010 (Goree et al., CHI 2021). The main driver back then, without any AI: shared libraries like Bootstrap with their default layouts.
That was before AI coding. Today, millions of developers generate their UIs with the same models, trained on the same patterns and suggesting the same defaults. There are no solid studies on the AI era yet, but the mechanics are the same as with the libraries, just at a completely different scale.
For your product, that means: if you just let the AI do its thing, you get the internet's average interface. Functional, tidy, and interchangeable. Your brand shouldn't get steamrolled by the AI. Instead, the AI should work inside your design system. Technically, that's easy to solve: an AI setup connected to your design system (via MCP, for example) makes sure agents reuse your components instead of inventing new variants with every feature. By the way, this is a core building block of the framework.
The more unique your business, the less autopilot helps
There's a pattern behind this worth being aware of: AI is really good at things that have been built many times before. Login, dashboard, checkout, CRUD: it has seen millions of variants of those in training. Your internal domain logic it has (hopefully) never seen. The pricing tiers your sales team negotiated over the years, the edge cases in your production planning, the rule for why customer A is billed differently from customer B: that's exactly where the model guesses instead of knowing.
That's not bad news, quite the opposite. Technically, even a unique business consists mostly of standard building blocks, and AI builds those quickly and cheaply. But the part that sets you apart from the competition is also the part where vibe coding helps the least. AI commoditizes what's interchangeable. Your value moves into exactly the parts it can't do: your domain, your design, your understanding of your audience. All the more important that these parts are built, tested and owned properly.
We've been working in the stack AI loves since 2012
One last point to round things off, and admittedly it plays into our hands: in August 2025, TypeScript became the most-used language on GitHub for the first time, ahead of Python and JavaScript, with around 2.6 million monthly contributors and growth of more than 66% in a single year (GitHub Octoverse 2025). GitHub names the driver itself: AI. Typed languages give agents guardrails. The 2025 GitHub study found that 94% of compile errors in LLM-generated code were type-check errors. Exactly the kind of errors TypeScript catches before they reach production.
In other words: the ecosystem in which AI coding works most reliably today (TypeScript, React, Node.js) is the ecosystem we've been building software in since 2012. We didn't have to switch stacks for the AI era. The AI era came to our stack. Phew :)
What does this mean for you?
You have a prototype that has proven itself? Then don't let it die in a drawer, and don't quietly push it into production either. The most elegant next step: let the AI document the requirements itself (“Summarize all requirements from our conversation, I want to show them to a software company”), then get an honest assessment from us. Our Vibe Coding Audit checks architecture, security and maintainability before risks turn into expensive problems.
You haven't built anything yet, just have an idea? Best possible starting point. Before a single prototype exists: form hypotheses, understand your target audience, then test small. A Lean Inception or Design Sprint workshop clarifies in a few days what your product needs to prove, before you spend money building in the wrong direction.
Your team is already building with AI? Then the question is no longer whether, but how consistently. When everyone has their own setup, secrets sit in the repository or pull requests grow to a thousand lines nobody reads anymore, that will become your core problem. That's exactly what the framework is for, from a one- or two-day workshop all the way to rollout.