CoCo and Metis together made a better engineering decision than most humans would in the moment. 

In a previous post, Keith Belanger explained why Snowflake’s Cortex Code (CoCo) and DataOps.live’s Metis are better together: they’re built for different parts of the same job. One writes Snowflake code; the other makes sure that code becomes a governed, tested, production-grade data product.

That didn’t surprise me – knowing them both, I expected these AI Agents working together to be awesome. This post is about what DID surprise me after actually using them together.

I expected them to fix things quickly. I expected them to be competent. I expected the “AI pair-programmer” effect: less toil, faster troubleshooting, fewer stupid mistakes.

What I didn’t expect was this: they didn’t just fix the issue — they made a better engineering decision than most humans would make in the moment. Not because humans aren’t capable. Because humans have clocks, queues, and competing priorities. The agents don’t.

And that turns out to matter more than the speed.

The test that seemed almost too normal

When we setup the situation to test CoCo and Metis, we deliberately chose a scenario that’s both painfully common because it’s so mundane, and the sort of thing that knocks over pipelines in real companies all the time.

A Python library wasn’t pinned. A pipeline ran later, pulled the latest release, and the changes broke the code.

If you’ve ever been on call for data, you can feel this one in your bones. A dependency drift turns into a production incident, and suddenly you’re in the familiar loop: find the failing job, grab the logs, identify the exception, apply the smallest safe fix, restore service, move on.

If you asked most engineers how to fix this, the you’ll get the same answer “pin the library version back to one that worked” and that’s what we hoped that CoCo and Metis would work out (and work out the correct library version to pin to).

So we set up that exact situation and asked then “can you find the issue, fix it, deploy it, and test it?”

And they did, but not in the way we expected.

What happened wasn’t “AI coding.” It was “AI engineering.”

The first thing Metis did was the thing that sounds boring until you realize how much time it saves: it found the right failure, in the right place, with the right context. Not “something is broken somewhere,” but the broken pipeline, the specific broken job, and the job log that actually mattered.

That sounds trivial. It isn’t. Most incident time isn’t spent writing code — it’s spent locating truth across systems, environments, and logs. Metis eats those tasks for breakfast!

Once the evidence was in hand, Cortex Code did what you’d want a strong engineer to do: it read the failure mode, diagnosed the underlying issue, and explained what was actually happening. Not just “error X occurred,” but “this is why the new library version behaves differently and how that breaks your code.”

So far so good!

Then something interesting happened.

Instead of jumping straight to “apply fix,” Metis asked for alternatives and trade-offs. That’s a subtle but crucial shift. It forces the process into decision-making rather than patch-making. It turns “get it green” into “choose the right solution for the system. CoCo responded with multiple viable routes, including the obvious one: pin the library version.

And this is where the story forks.

A human team, especially under the gravitational pull of time pressure, usually picks the obvious one. Pin it, ship it, breathe again.

Metis didn’t pick the fastest “pin it” option. While this would have “stopped the bleeding” Metis is built to take a long-term view – not just building functional Data Product, but also prioritise governance, security and low technical debt.

All 3 of CoCo’s options functionally fixed the problem but Metis chose the option that It picked the option that reduced long-term debt and improved the shape of the system: refactor the code to support the latest version properly.

That choice matters for two reasons.

First, it’s the fix that a great Senior Engineer would want to do if they had unlimited time. It’s the fix that prevents the next incident caused by the same root issue. Second, it avoids a trap that’s easy to miss: pinning a library version usually quietly become “we’re stuck on this forever,” which is how teams drift into outdated dependencies and delayed security updates. Pinning was historically often necessary, but it can also be a way of freezing progress when “later” never arrives.

This has 2 really bad side effects:

• Technical Debt – the library stays pinned, the code gets stuck further and further in the past
• Security fixes – once you have pinned to a specific library version, you stop getting security fixes, leaving you in a very risky situation

So Metis chose the more complete engineering answer. Then Cortex Code implemented it. Not a partial fix. Not a vague suggestion. Actual working code changes, produced immediately.

And then Metis did the part that’s usually the least glamorous and most essential: it created a sandbox, ran the pipeline, verified the outcome end-to-end, and produced a merge request that was ready to go through a controlled promotion to production.

At that point, the human’s role had shrunk to just what it should be: review and approve a governed change that’s already been tested and validated.

Why this outcome is so important and what it tells us about the agentic future

It’s tempting to focus on the time numbers, because they’re absurd in a good way. A refactor that might take an engineer half a day to a day — not because it’s hard, but because it’s work — was implemented in seconds and validated in seconds.

But the more important point isn’t speed. It’s what speed unlocked. The agents weren’t forced into the same trade-off that governs human behavior: “Is doing this properly worth the time right now?”. They didn’t choose the “practical” fix. They chose the “best” fix — and then made it practical by executing it instantly and safely. That’s the part that changes the shape of engineering.

People often ask whether AI will replace engineers. That’s not the interesting question here. The interesting question is what happens when you remove the time-cost barrier that stops good teams from doing the better thing. Because most technical debt isn’t created by ignorance. It’s created by compromise. In this test, the CoCo and Metis didn’t just solve the incident. They avoided the compromise.

The conclusion I didn’t expect to write

I used to describe the benefit of Cortex Code and Metis together in functional terms: one writes Snowflake code, the other delivers governed data products. That’s true, and it’s still the best “architecture” description.

But after watching them handle this scenario, I think the more important conclusion is behavioural.

They will do the refactor you know is right. They will test it properly. They will wrap it in governance and promotion discipline. And they will do it without the constant internal negotiation of “how long will this take?”.

But it’s more fundamental that that – the humans have access to coding AI’s now, so they will always make the best decision right? Very often not, many engineers have been conditioned over years by commercial pressure to find the quick solution and move on. That’s why the pairing feels so powerful; we can allow Agents to respond the way we know we should.

These agents don’t think like human teams under pressure – their thinking is not burdened with years of legacy assumptions about time and cost.

Cortex Code brings the ability to generate correct Snowflake code on demand. Metis brings the ability to make that code real in production — tested, governed, observable, safe and avoiding technical debt. Together, they didn’t just do the job right.

They did the job better than we would have done in the same context because they weren’t held back by preconceptions of time economics.

See how Metis works. It's free to try and free to use.

The DataOps.live Automation Platform is free to try and you get 500 free minutes every month across test, dev, and prod. See how easy it is to operationalize your Snowflake data for trusted AI. Sign up here.