The first week, I shipped a SaaS platform. The next six months, I shipped the parts that made it true.
- My commit history, if it could talk
This spring I wrote that vibe coding won't save you. The fantasy is that you can skip the hard parts. The real opportunity is doing the hard parts better.
This post is the receipt. A SaaS product I've been building this year started as a vibe-coded project. By the end of September it had about 1,000 commits, 330 merged pull requests, roughly 1,900 backend tests, and a production environment. Getting from the first to the second took a different approach from the one I started with.
I've now brought AI into a project the wrong way and the right way, on the same codebase, a few months apart. The difference wasn't the model or the tools. It was the guardrails around them.
Week One Felt Incredible
The first commit landed on March 27. By the end of the next day, the project had:
- A .NET solution laid out in clean architecture.
- A database schema with row-level tenant isolation.
- Azure infrastructure in Terraform.
- A CI/CD pipeline.
The day after that, it had authentication.
One commit on day one added 443 files and 133,000 lines. That included an entire dashboard theme I'd pulled in as a starting point, complete with pages for a logistics app: fleets, warehouses, vendors. None of it had anything to do with my product.
The commit log from those first days reads like someone sprinting: "checkpoint," "saving settings," and a day with a dozen fix: commits, most of them chasing authentication problems. More than 90 percent of March's commits went straight to the main branch. About 15 percent touched a test.
It felt like the future. In a sense it was. I had a working skeleton of a real product in days.
It also left a mess: a template dump I'd pulled in without trimming, and a lot of generated code nobody had read closely.
Here's the part that matters, though: the architecture was there from day one. The discipline wasn't. The project had clean layers, written specs and an instructions file for the AI. What it didn't have was any way to catch the code being quietly wrong.
The Bill Came Due Quietly
None of the serious bugs announced themselves. That's the pattern I want other developers to see, because it's the pattern that makes vibe coding feel safe when it isn't.
The tenant filter that returned nothing
The product is multi-tenant. Each customer company sees only its own data, and the database enforces that with row-level security. Every query has to tell the database which tenant is asking.
On day two, some of the analytical queries were written to use raw database connections. Those connections never told the database which tenant was asking. So under a properly restricted account, four tables returned zero rows. No error was raised. The results were just empty.
Nobody noticed for more than three months. The development database account had more privileges than it should have. The background worker had a privilege that let it skip the security rules. And the test harness ran as a superuser. Every environment I had was powerful enough to hide the bug.
The first honest reader was the new testing environment in July, set up with a properly restricted account. The alert feed was silently empty. The fix was a day's work. Finding it took the first environment that behaved like production.
The tests passed. The database said no.
In June, a change broke a unique rule in the database. Every unit test passed, because the unit tests ran against an in-memory stand-in for the database, and that stand-in doesn't enforce unique rules. Someone caught it only because they happened to run the integration tests by hand.
That one was the turning point. More on that below.
The comment that described code that didn't exist
In July, while replacing the authentication system, I found a code comment explaining how the invite flow linked accounts by email address. It was clear, specific and confident. That logic didn't exist anywhere in the codebase.
That's a very vibe-coded kind of bug. The AI described what the code was supposed to do, and nobody checked that it did.
The worker that never started
When production was finally set up in July, the background worker crashed every time it started. The scripts that set up the database account never granted it permission to create a schema it needed. Nothing was wrong with the code. The environment around it was.
The Turning Point Came in Two Steps
The first step was habit. In April most changes started going through a pull request and a review, and by May every one did. Tests started showing up alongside the code instead of later.
The commit history shows it:
- Commits straight to main: over 90 percent in March, about 20 percent in April, zero in May.
- Commits that touched a test: about 15 percent in March, around 40 percent in April, nearly 90 percent in May.
That helped, but habits are still intentions. The unique-rule miss on June 3 showed the gap: the process was better, and a real database bug still slipped past every test that ran automatically.
The second step was enforcement. That same day, the project got a merge gate, a single command that has to pass before anything merges:
- It builds the solution.
- It runs the unit tests and the architecture tests.
- It runs the integration tests against a real Postgres database.
- It runs the frontend tests.
It also got a written rule: anything touching database constraints, tenant isolation, raw SQL or migrations needs a test against a real database. An in-memory fake can't prove any of those.
The gate got slow as the suite grew, so in September I split it to run in parallel. It went from 38 minutes to 15.
The gate didn't stop the work. About half of the project's 330 pull requests merged after it existed. More important, it's what let me keep handing AI large pieces of work, because I no longer had to trust that the result was right. I could check.
The Process Paying Off
The best evidence that the new approach worked is a bug that never reached production.
The product pulls search-ranking data from a third-party API. The code that read that data was first written against the vendor's documentation, not real responses. It was flagged as unverified from the start, and it stayed out of production until someone could check it.
When I tested it against real captured responses, four defects turned up. One read the wrong ranking field. A customer ranked third in local search results would have been reported as fourth, and that trips a critical alert: "no longer in the top 3."
That was caught in August, fixed, and the integration went live in September with the corrected code. In March, that bug would have shipped.
What I'd Tell Myself on Day One
Vibe coding is a great way to find out what you're building. I don't regret the first week. It got a real product skeleton in front of me fast, and a lot of it survived. The mistake would have been believing the skeleton was the product.
The dangerous bugs are the quiet ones. Most of the bugs above didn't look like failures at all. Empty results, passing tests, a confident comment. AI-generated code fails politely, and polite failures hide longest.
Your test environment is probably more forgiving than production. Two of these bugs hid behind things that were too permissive: a privileged database account, a superuser test harness, a fake database that doesn't enforce rules. If production is stricter than anywhere you test, production is where you'll find out.
Know where to trust it and where to push back. I'd trust AI with scaffolding, first drafts and the shape of a feature again tomorrow. Where I push back now is anywhere a mistake would be silent: data access, tenant isolation, third-party data, anything that still "works" when it's wrong.
Guardrails are what let you let AI run. "I'll be careful" didn't survive the first week. A merge gate that refuses to pass did. The gate didn't limit what I could hand off. It's what made handing off large pieces safe.
Architecture isn't the same as correctness. Clean layers and well-named folders made the early code look professional. They didn't make it right. The tests against a real database did that.
The vibe-coded version showed me what the product could be. The version customers can trust came from doing the hard parts: real databases in the tests, environments that behave like production, and a gate that doesn't care how confident the code looks.
