The test suite was green. Ninety percent coverage. The team was proud of it, and honestly they had earned the right to be proud of something, because they were shipping faster than any team that size I’d seen in a while.
I was three days into the review. Five engineers, every AI coding tool on the market, multiple merges a week. They brought me in expecting a rubber stamp before their next funding conversation.
I pulled thirteen merged PRs. I found twenty defects.
Not style nits. Structural failures.
Type mismatches between the ORM and the actual production schema. Tests that mocked the exact thing they were supposed to be testing. And an authorization gap where, under the right conditions, one tenant’s query could reach another tenant’s records.
In a HIPAA regulated platform.
Nothing had failed. No alarms, no red builds. The agents had been working beautifully, confidently, quickly, and in exactly the wrong direction.
That’s the part nobody tells you.
Agents are amplifiers, not saviors
Everyone is selling the same dream right now. Embed agents into every process, clear your backlog, ship faster than your competitors or die.
Here’s what actually happens.
Agents take what you already have and produce more of it. Solid foundation, they scale your speed. Rotting foundation, they scale the rot, at a velocity no human team could match.
You cannot agentify chaos. You cannot automate a system that doesn’t know its own rules.
And if your codebase can’t pass its own tests, honestly pass them, not theatrically pass them, then an agent is just an expensive way to break things in production.
In every regulated codebase I’ve reviewed, the damage arrives through the same three doors. Here they are.
Door one: schema drift, or the schema you stopped believing in
Your developers use an ORM. It’s convenient, it’s fast, and the schema in your code hasn’t matched the schema in production for six months.
Columns missing. Types wrong. Constraints your code assumes exist that simply don’t.
A human might catch this. They’ve seen the production logs, they remember the migration that got half applied last spring, they have a nagging feeling.
An agent has no nagging feeling.
It reads your model file. It treats that file as truth. It writes a query against that false truth.
Then your production environment throws 500s at 9am on a Monday.
You can’t ask an AI to respect a schema you’ve been ignoring. You need automated drift detection and a source of truth that actually stays true.
Door two: the self-mocking test, or tests that lie to you
This one is my favorite, and it’s the one that scares me.
You mock the database. Fine, reasonable. But then you mock the service logic too.
So the test asserts that when you call the function with X, it returns Y. Because you told the mock to return Y.
It passes. Every time, forever. It proves nothing.
Now point an agent at that codebase. It sees green, concludes it’s doing excellent work, and rewrites the core business rule.
The test still passes. Because the test was never testing anything.
This is how healthcare software quietly goes wrong before it loudly goes wrong. You believe you’re compliant, you believe auth is enforced, and then someone gets a record that isn’t theirs and the belief is all you had.
Door three: the missing gate, or no standard at the door
Standardization is the enemy of vibe. It is the best friend of the agent.
Most teams I review have no lint gate. No static analysis, no enforced style. Every developer writes their own dialect.
An agent reads that inconsistency and does the natural thing. It blends. It picks up the habits of your least experienced engineer and reproduces them at scale.
Without a gate, an agent can generate a quarter’s worth of technical debt in an afternoon.
It’s a high speed printer handed to someone who can’t spell. You don’t get quality, you get typos, faster.
Why this is different in healthcare
In most industries a bug is an annoyance. A support ticket, a bad week.
In healthcare a bug is a clinical risk.
If an agent hallucinates against a mismatched schema and a value lands in the wrong field, that’s a chart. If it skips an auth check because the test that covered it was a mock, that’s a breach.
Which means a notification obligation, a letter to OCR, and a very different conversation with your board.
HIPAA does not grant an exception for moving fast. The regulators will not be charmed by your agentic workflow.
Trust is the only currency you actually have. Lose the clinicians and you have no product. Lose the regulators and you have no company.
Harness first. Agents second.
The fix is simple. It is not easy.
Build the harness before you build the agents.
Integration tests that hit a real database, not a mock of one. Schema validation on every build. A lint gate that is non negotiable and enforced in CI, not in a Slack norm. Branch protection that actually protects the branch.
Then, and only then, let the agents in.
On a foundation like that they are genuinely extraordinary. They compound good engineering the same way they compound bad.
That’s the whole argument. Agents don’t have judgment. Your harness is the judgment.
Schema drift, self-mocking tests, no gate at the door. Close those three and the green checkmark starts meaning something again.
Build it, or you’re just automating your blind spots.
I’ve spent 25 years building software in regulated environments, mostly healthcare, mostly the systems that break in ways nobody notices until they very much do.
At Vantage IO, the review above is the work. We look at your merged PRs, your schema, your test suite, and your auth boundaries, and we tell you what an agent would do with them.
If your test suite is green and you’re not entirely sure you believe it, that’s worth a conversation. No pitch, just a look under the hood. Book a free call.
