What Database Teams Can Teach Developers About AI Coding Agents

Let's be honest: every week brings another headline about AI agents writing code faster than human developers. Cursor rebuilt SQLite in days. Software factories churn out PRs in volume. It's enough to make any developer wonder if their job is on borrowed time.

But here's what those headlines miss: speed is the easy part. Getting agents to write code quickly? Trivially solved. Getting them to write code you'd actually trust with production systems? That's the hard problem nobody wants to talk about.

Cockroach Labs recently shared their approach to this challenge, and it's worth unpacking—especially if you're a startup or developer thinking about integrating AI agents into your workflow.

The $160,000 Question

In 2024, Cockroach Labs added Oracle database support to their migration tool, MOLT. The project took nine months and cost approximately $160,000 in engineering time. Solid, professional work by experienced engineers.

Then came April. The team needed to add support for IBM Db2—a database with a rich SQL dialect, complex type system, and native wire protocol. The equivalent technical scope.

They did it in less than two days. The total cost was $4,172.

The catch? No human wrote any of the code.

Before you start mentally drafting your resignation letter, consider what enabled this: it wasn't just smarter agents. It was a system designed around a radical premise—that the bottleneck isn't writing code, it's writing trustworthy code.

Introducing MOLT Sinai: A Coding Hospital

Cockroach Labs didn't just throw agents at the problem. They built what they call MOLT Sinai: a pipeline modeled after teaching hospitals where issues become "patients," merged code becomes "discharge," and human reviewers become "Chiefs of Medicine."

The vocabulary is charming, but the underlying philosophy is serious:

• Issues are patients: Every task enters the system with documentation, gets triaged, and follows a defined care pathway
• Decomposition is diagnosis: Large problems get broken into sub-problems with explicit dependency graphs. Foundation work before type systems. Type systems before row iterators. You can't rush healing.
• Review is rounds: Every piece of work gets examined, sent back for revisions (sometimes 55 times per parent issue), and escalates when needed
• Humans are chiefs: Final authority stays with experienced engineers who can escalate issues to themselves when something looks wrong

This isn't about replacing doctors—it's about building a system where the residents, attendings, and specialists all have clearly defined roles.

Why Throughput Is the Wrong Metric

Here's where most AI coding experiments go wrong: they optimize for "PRs per hour" or "lines of code per day." These metrics feel exciting in demos. They make terrible headlines. They're almost useless for actually shipping software.

Cockroach Labs puts it bluntly: they'd rather agents take 10x longer than land the wrong data in a customer migration. For a company whose entire value proposition is data correctness, this isn't just philosophy—it's survival.

Their question wasn't "how many PRs can we merge?" It was "how many of these PRs would we be embarrassed to merge?"

That's a question more teams should be asking, whether they're using AI agents or not.

What Actually Happened

When Db2 support landed in MOLT:

• 32 sub-issues were opened under the parent issue
• 27 pull requests merged through the pipeline
• 55 times, reviewers sent work back for revisions
• 9 issues escalated, with 2 reaching human intervention
• Test coverage matched their best-tested dialect (PostgreSQL)

The agents weren't perfect. They filed issues against their own work: fixture gaps, type-mapping bugs, isolation-level fixes. They needed oversight. But the oversight was structured, purposeful, and scaled to the complexity of the work.

Compare this to a software factory running agents in parallel with a merge-handling layer. That architecture makes sense when the bottleneck is writing speed. For correctness-critical work? You need something closer to a hospital, not a factory floor.

What This Means for Your Team

Look, most of you aren't building database migration tools. You're building web apps, APIs, internal tools, MVPs for the next big thing. The stakes are different.

But the lesson applies: AI agents excel at volume, humans excel at judgment. The teams getting real value from AI coding aren't just prompting ChatGPT and shipping the output. They're building systems that leverage each for what they're good at.

This might mean:

• Using agents for boilerplate, tests, and scaffolding
• Building review pipelines that catch what agents miss
• Treating agent output as "draft one" rather than "ship ready"
• Keeping humans in the loop for anything touching customer data or core business logic

The developers who'll thrive alongside AI agents aren't the ones who learn to type faster. They're the ones who learn to architect systems that make AI a force multiplier rather than a liability.

The Bottom Line

MOLT Sinai processed the equivalent of nine months of engineering work in two days, at 2.5% of the cost, with quality matching human-written code.

But that headline obscures what actually happened: a team of humans built a rigorous system, defined clear roles, established meaningful checkpoints, and then trusted their agents to operate within that framework.

The agents didn't replace the engineers. They amplified them.

That's not a story about AI replacing developers. It's a story about developers building systems sophisticated enough to use AI well.

And honestly? That's the version of this story worth paying attention to.

Tired of infrastructure that slows you down? Vibe Hosting combines AI-powered deployment with the reliability you need to ship fast without the fear. Domain registration, SSL certificates, and cloud hosting—all in one place.