We spend a lot of time building with AI — and reviewing systems that were built with it. Here's what we've learned.
AI can get you started. It won't get you to production.
AI is a powerful tool for generating code quickly. But without strong technical guidance, it rarely produces systems ready for real users.
It makes assumptions, fills in gaps, and optimizes for "something that works" — not necessarily something secure, scalable, or maintainable. It doesn't stop to ask questions; it just moves forward and makes decisions for you.
That's fine for a prototype. It's risky for a product.
It works best when the problem is already well understood
If you ask AI to build something like a blog platform, it will likely do a decent job — because patterns and expectations are well established.
But most products aren't like that. If you're building something new or specific to your business, there's no template. Requirements aren't obvious, and edge cases matter.
AI can still help — but only if you can clearly define what the product should do, how users interact with it, and how it should behave. That takes product thinking — planning, defining features, and designing the experience — not just generating code.
What we're seeing from clients
AI-generated prototypes
We often see mockups or clickable prototypes created with tools like Figma AI. They're useful for communicating ideas, aligning stakeholders, and getting early buy-in — but they're not software.
They represent a small slice of the product. It's easy to feel halfway there, but in reality, you're much earlier.
AI-generated code
We also review codebases that have been partially or fully generated using AI. Sometimes, they're a reasonable starting point.
But as features are added and modified, the code often becomes difficult to work with. Patterns are inconsistent. Edge cases are missed. Decisions are made without considering long-term impact.
It might look fine on the surface. Underneath, it's fragile.
This is where most AI-built products start to break down
Early progress feels fast. Features appear quickly. The product starts to look real.
But as soon as you try to extend it — add new functionality, adjust behaviour, or prepare for real users — the limitations show up.
Changes become harder. Small tweaks break other parts of the system. Confidence drops. This is the point where "something that works" needs to become "something that's built properly."
How experienced teams actually use AI
Strong developers absolutely use AI — but differently. They don't generate entire systems and accept the result. They:
- Break problems down into smaller pieces
- Define how each piece should work
- Consider architecture, scalability, and security
- Review and refine the generated code
- Correct mistakes (there are always mistakes)
- Ensure the system remains maintainable
AI speeds up execution. It doesn't replace judgment. In many ways, it makes experienced developers more effective — and inexperienced ones more dangerous.
The risks of launching a vibe-coded product
AI-generated systems can be great for prototyping and early validation. But launching them without proper engineering introduces real risks:
Security Issues
Exposing user data or system vulnerabilities that weren't caught during AI-assisted generation.
Scalability Issues
Working for a handful of users, but failing under real growth when traffic and data volumes increase.
Maintainability Issues
Becoming difficult to change or extend as the product evolves and new requirements emerge.
These are the kinds of issues that arise when real users and real data are involved.
What it looks like to move from prototype to production
At some point, most teams need to transition from "something that works" to "something that's built properly." That's where we typically come in.
We don't assume everything needs to be thrown away. Instead, we start by reviewing what you've already built: your product idea and requirements, your UX and user flows, and any existing code or prototype.
From there, we give a clear, honest assessment:
- What can be used as-is
- What needs to be improved
- What should be rebuilt
Then we define a path forward:
Refine the Product Definition
Clarify what the product should do, how users interact with it, and what success looks like.
Structure the System Properly
Establish architecture, security, and scalability foundations that can support real growth.
Build in Phases
Start with a solid foundation and add functionality incrementally, validating as we go.
Use AI in a Controlled Way
Accelerate development and support implementation — never to replace critical decisions.
The goal is to turn what you've started into something that can be launched, scaled, and maintained.
When to bring in a development team
Most products eventually need a dedicated development team. The worst time to start looking for one is when things are already breaking.
If you're building with AI today, the best time to get input is earlier:
- Before launch
- Before handling real user data
- Before the system becomes difficult to change
Even a quick review can help you understand where you stand. That's why we offer code review engagements as a starting point — a focused, standalone review that evaluates what's working, what isn't, and what it will take to move forward.
The bottom line
AI is a powerful tool. It can help you prototype faster, explore ideas, and build early versions of your product.
But it doesn't replace:
- Clear product thinking
- Strong technical decisions
- Experienced developers
Used well, AI accelerates good teams. Used without that foundation, it creates problems faster than you can see them.