# It’s Time to Admit Software Engineering Has Fundamentally Changed: Why evaluation is the feedback loop AI-native engineering learns from

URL: https://dcrewe.com/article/its-time-to-admit-software-engineering-has-fundamentally-changed  
Author: Donovan Crewe  
Published: 2026-08-13  
Categories: Artificial Intelligence, AI Evaluation, AI-Native Engineering, Software Engineering, Machine Learning

> AI makes it far harder to know whether a change to a prompt, model, agent or workflow actually made things better. Using the Cat Council as an example of independent judges whose disagreements are reconciled into a shared definition of quality, this article makes the case for Evaluation Engineering: continuously measuring whether humans, AI and the systems around them are genuinely improving.

For the past two years, we've treated AI as another technology trend.

We've compared models, debated benchmarks, rolled out coding assistants and measured adoption. Every few months another breakthrough arrives, another model claims state-of-the-art performance and another organisation announces that every developer now has access to AI.

But something more fundamental is happening beneath all of that.

AI isn't simply changing how quickly we write software. It's changing how we determine what good software engineering looks like, how we improve it and how we know whether we're actually getting better.

And that means some of the practices we've relied on for decades are going to have to change too.

One of the most obvious examples is evaluation.

Traditional software engineering has always had a relatively straightforward feedback loop. We write code, we test it, we review it, we deploy it and we measure what happens. If we change something, we can generally establish whether the change made the system better or worse.

AI makes that much harder.

We can change a prompt, an agent, a model, a context strategy or an entire workflow and suddenly we're dealing with outputs that are probabilistic, contextual and often subjective. We may know that one output feels better than another, but “feels better” isn't an engineering discipline.

You may have seen a slightly comical video doing the rounds recently featuring me and a rather opinionated group of cats.

It was my attempt to explain a surprisingly important concept in AI evaluation without putting everyone to sleep.

The premise was simple. Give a group of judges the same AI output and ask them to evaluate it independently. Each judge makes their own assessment and, importantly, explains why they reached it. You then bring those judgments together, look at where they agree and disagree, and reconcile the differences into a more reliable assessment of what “good” actually means.

The cats were mostly there because, frankly, a council of cats makes a better video than a slide explaining evaluation methodology.

But the underlying idea is serious and in my opinion one of the most overlooked skills in today's AI workflow.

Most people can recognise an obviously terrible cat. Most can recognise an obviously great one. The difficulty appears in the middle, where reasonable people can look at the same output and reach different conclusions. Without a shared definition of quality, an evaluation quickly becomes little more than opinion.

AI engineering has exactly the same problem.

Consider an AI agent responsible for implementing a feature. What does better mean?

Did it write fewer lines of code? Did it finish faster? Did it require fewer interventions? Did it produce more maintainable code? Did it understand the architecture? Did it introduce fewer security vulnerabilities? Did it use fewer tokens? Did it make better decisions even if it took longer?

The answer is probably some combination of these things.

That is why I think we're going to need to think about evaluation differently.

We've traditionally treated evals as something that happens to AI models. We benchmark a model, compare it against another model and decide which performs better.

But AI-native engineering requires something broader.

**We need to evaluate the system.**

The model is only one component of that system. The context it receives matters. The tools it can access matter. The agents it can orchestrate matter. The state and organisational memory available to it matter. The way engineers interact with it matters. And ultimately, the outcomes produced by the entire system matter most.

This means evaluation is no longer simply about determining whether a model is capable.

It becomes about determining whether the way we're engineering with AI is actually improving.

That distinction becomes incredibly important as we start changing software delivery at a much faster rate.

Imagine changing your model and seeing better results. Is the model better, or did you simply give it better context?

Imagine introducing persistent project memory and seeing fewer iterations. Is the memory improving the system, or are engineers simply learning to use the new workflow?

Imagine introducing a team of specialised agents. Is the organisation delivering better software, or have we simply increased the number of AI calls and the amount of compute we're consuming?

Without good evaluation, we don't know.

We have opinions.

This is where I believe **AI Native Engineering** requires a distinct discipline.

Evaluation Engineering is the practice of continuously measuring whether humans, AI and the engineering systems around them are genuinely improving. It means defining what good looks like, creating representative scenarios, measuring outcomes, understanding disagreement and creating feedback loops that allow the system to get better over time.

And importantly, evaluation doesn't mean removing human judgement.

Quite the opposite.

The Cat Council works precisely because judgement is valuable. The important part is making that judgement explicit, comparing independent perspectives and reconciling differences so that we can develop a more reliable understanding of quality.

The same principle applies to AI.

If three experienced engineers independently assess an AI generated architecture and disagree, that disagreement isn't necessarily a failure of the evaluation. It might be one of the most valuable signals we've found. Understanding *why* they disagree can expose an ambiguity in the requirements, a weakness in our rubric or a genuine trade-off that the system needs to learn to navigate.

Over time, the evaluation itself becomes better.

And that's where this starts to connect to the broader AI-native engineering framework I've been exploring.

If we're building persistent state and organisational memory, we need evaluation to determine whether that context is actually improving outcomes.

If we're helping engineers become more agentic, we need evaluation to determine whether personalised coaching is actually increasing their capability.

If we're building increasingly autonomous agents, we need evaluation to determine whether greater autonomy is producing better engineering outcomes.

If we're changing the delivery lifecycle itself, we need evaluation to determine whether the new approach is actually better than what came before.

Every one of these ideas eventually becomes an evaluation problem.

This is why I think evals are much more important than the industry currently gives them credit for.

They're not just a quality-control mechanism for AI.

**They're the feedback loop through which AI-native engineering learns.**

That also changes how we should think about experimentation.

One of the most powerful things about AI is how quickly we can change the way we work. We can try a new model this afternoon, give an agent another tool tomorrow, restructure a workflow next week and completely change how a team interacts with AI next month.

That speed is incredibly valuable.

But if our ability to evaluate those changes doesn't keep up, we end up with an organisation full of anecdotes.

Someone has an incredible story about what Claude did.

Another engineer has discovered a brilliant prompting technique.

A team believes its new agent workflow is dramatically faster.

A new model feels better.

Those experiences are useful, but they don't tell us whether the organisation is improving.

Evaluation does.

The organisations that pull ahead won't simply experiment faster. They'll build tighter feedback loops between experimentation and evidence. They'll evaluate new workflows against real engineering outcomes, test agents against representative tasks, measure whether coaching actually changes behaviour and compare new models against the work the organisation actually needs them to perform.

The result isn't simply better AI.

It's an organisation that becomes better at understanding what better actually means.

That may ultimately be more important than the models themselves.

Models will continue to change. Tools will come and go. Today's best agent framework will eventually be replaced by something else. If our advantage depends on any particular model or tool, we're constantly starting over.

But an organisation with a strong evaluation capability has something much more durable.

It has a way of learning.

That is the shift I think AI-native engineering requires.

We can't simply build faster. We need to know whether we're building better.

We can't simply make AI more autonomous. We need to know whether that autonomy creates better outcomes.

We can't simply tell engineers to become more agentic. We need to understand what agentic excellence looks like and whether we're actually helping people move towards it.

And we can't simply declare that a new AI system is better because the output looks impressive.

We need to be able to prove it.

[The Cat Council](https://www.linkedin.com/posts/using-ai-to-test-ai-ugcPost-7467647314778750976-tuMm/?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAiVEV8BGTxpyfokpECkeDiDLiv9UaD5Rjg) was a silly way of explaining a serious idea.

But perhaps that's the point.

Before we can ask AI to continuously improve, we first have to get much better at agreeing on what **better** actually means.

That's the real opportunity with evals.

Not simply determining whether AI works, but creating the mechanism through which AI-native engineering learns what better looks like, proves that it has improved, and then does it again.

**It's time to admit software engineering has fundamentally changed.**

And if the way we build software has changed, the way we evaluate engineering has to change with it.
