The Meat Proxy Paradigm
When AI expands what engineers can build faster than what they can judge
By Donovan Crewe · · Artificial Intelligence, AI-Native Engineering, Engineering Leadership, Developer Productivity, AI Agents
There is a new kind of engineer emerging.
They can build things they could not have built two years ago. They can move into unfamiliar frameworks, generate thousands of lines of code, create tests, refactor existing systems and stand up infrastructure they have never personally designed. Give them an AI coding agent and the amount of work they can produce in a day can be remarkable.
But then ask them why the architecture looks the way it does, what assumptions it makes about failure, how it will behave when the system reaches ten times its current load, where the security boundaries actually sit, or why one approach was chosen over another, and something changes. Sometimes they know. Sometimes they do not.
That distinction is becoming increasingly important because AI is changing the relationship between what an engineer can produce and what they actually understand.
There is a term that has started appearing in engineering discussions to describe one extreme of this behaviour: the "meat proxy". The original idea is relatively simple. An AI produces an answer, a human sits in the middle and passes that answer on without really reading, understanding or validating it. The human is effectively the biological interface between the machine and everyone else.
It is a deliberately uncomfortable term, but I think it points at something much more significant happening in software engineering.
The problem is not simply that engineers might forward an AI-generated answer without reading it. The more consequential problem is that an engineer can now use AI to produce sophisticated software without necessarily having the experience required to understand the decisions embedded within it.
That is a much harder problem to see because the software may work.
The code may compile. The tests may pass. The pull request may be approved. The feature may ship on time. From the outside, everything can look exactly as it should.
The engineer may still not understand what they have built.
For most of the history of software engineering, there has been a reasonably strong relationship between what an engineer could produce and what they understood. It was never perfect, but it was useful. An engineer who had spent ten years building distributed systems had accumulated a mental library of failure modes. They had seen systems collapse under load, dealt with race conditions that only appeared in production, worked through difficult migrations and learned that the elegant solution in a design document was sometimes the worst possible solution once real users started interacting with it.
Experience gave them something that was difficult to teach from a textbook. It gave them pattern recognition.
They knew what to worry about before it happened.
AI changes that relationship.
A relatively inexperienced engineer can now ask an agent to design a service, explain the architecture, generate the implementation, write the tests and produce the deployment configuration. The resulting system can look remarkably sophisticated. It can contain patterns, abstractions and technologies that the engineer might never have been able to implement independently.
This is one of the extraordinary benefits of AI-native engineering. It expands what an individual engineer can accomplish, and it has the potential to make engineering teams dramatically more capable.
But it also creates an asymmetry that we need to take more seriously.
AI can increase the radius of what an engineer can build much faster than it increases the radius of what they can reliably judge.
Recent research has described this broader shift as a move from a world in which software implementation was relatively scarce and expensive to one in which code generation is increasingly abundant and inexpensive. As implementation becomes cheaper, the difficult part of engineering moves further towards architecture, judgment, validation, feedback and understanding the consequences of the decisions being made.
That feels increasingly obvious in practice.
The adoption numbers tell us that this is not some distant possibility. JetBrains' 2026 Developer Ecosystem Survey found that 90% of professional developers surveyed were using AI coding agents at work at least weekly, with 68% using them daily. The same research found that developers reported, on average, around 47% of their code was fully written by agents, illustrating just how quickly implementation is moving from something engineers do themselves to something they increasingly delegate. https://blog.jetbrains.com/research/2026/08/ai-coding-agent-adoption-2026
We are already moving into an environment where a significant amount of software is being produced by systems that the engineer did not directly write.
That changes what we should mean by engineering capability.
For decades, implementation itself was part of the learning process. You started with relatively small problems, worked alongside people with more experience, made mistakes, investigated failures and gradually took responsibility for larger systems. Over time, you developed the mental models that allowed you to make decisions independently.
AI changes the economics of that progression.
An engineer can now skip a significant amount of the implementation friction that previously forced them to understand a problem in depth. They can ask an agent to explore the problem, propose a solution, implement it and fix the errors along the way. That can be incredibly empowering, but it can also create the illusion that the engineer has acquired the capability represented by the output.
They may have acquired the ability to produce the output. They have not necessarily acquired the judgment behind it.
This is why I am increasingly interested in the difference between execution capability and decision capability.
The fact that they can execute at that level does not necessarily mean that they can make decisions at that level and that matters because software engineering is ultimately a decision-making discipline. The code is the result of those decisions.
When we ask an agent to implement a distributed workflow, for example, the hard question is not necessarily whether it can produce the code. It almost certainly can. The harder question is whether the engineer directing it understands the tradeoffs around consistency, retries, idempotency, failure recovery, observability and operational complexity well enough to recognise a bad design when the agent proposes one.
A green test suite does not answer that question.
Neither does a clean pull request.
Neither does a high velocity metric.
This is where I think the conversation about AI productivity needs to mature. We have spent a lot of time asking how much faster engineers can become with AI. That is an important question, but it is only half the equation. We also need to ask whether engineers are becoming better at engineering as a consequence of using AI.
Those are not the same thing.
An engineer can use AI all day and become increasingly dependent on it. Another engineer can use AI all day and become significantly better at framing problems, exploring alternatives, challenging assumptions and validating solutions. Both may look highly productive from the outside. The difference is what is happening to their capability.
This is where the idea of meaningful AI usage becomes important.
We should not simply measure whether an engineer is using AI, how many prompts they send, how many lines of code an agent generates or how much time they believe they have saved. Those measures tell us that AI is present in the workflow, but they tell us very little about whether the organisation is becoming more capable.
Meaningful AI usage is different.
It means using AI to improve the quality of engineering work, not simply increase its volume. That might mean exploring architectural alternatives, challenging assumptions, providing better context, identifying failure modes or accelerating implementation while retaining responsibility for the decisions.
The objective is not maximum AI utilisation.
It is maximum engineering capability amplified by AI.
That distinction is becoming central to the idea of Engineering Intelligence.
Engineering Intelligence is not simply the amount of intelligence available to an engineering organisation. It is the ability of an organisation to combine human expertise, AI capability and organisational knowledge to continuously solve problems, learn from outcomes and improve.
That means the AI interaction itself becomes part of the learning system.
Architectural decisions, production failures and effective ways of working with agents should become organisational knowledge rather than remaining isolated inside individual engineers.
The organisation should be learning from all of it.
This is one of the problems we are working on with Atlus Insights.
The goal is not to create another productivity dashboard that tells a manager how many prompts an engineer has sent or how many lines of code AI has generated. That would simply create another layer of activity measurement around a fundamentally different way of working.
The more interesting question is what the interaction between engineers and AI tells us about capability.
Are engineers becoming better at framing problems? Are they learning to provide better context? Are they developing stronger ways of reasoning with agents? Are they validating AI output effectively? Are they learning from previous work and incorporating that knowledge into new projects? Where are individual engineers developing strong AI-native practices, and where are they still relying on the model to do the thinking for them?
Those signals tell us much more about AI maturity than adoption statistics alone.
They also create the possibility of something more important than productivity improvement.
They create a feedback loop for developing engineers.
If we can understand how engineers are working with AI, we can identify where they are strong, where they need development and which behaviours are associated with better outcomes. We can turn those observations into personalised learning, organisational standards and better ways of working. We can capture project and architectural knowledge and make it available to both engineers and the agents working alongside them.
The AI then becomes more than an implementation engine.
It becomes part of the organisation's learning system.
That is the distinction I think we need to make as AI-native engineering matures. The goal is not to create engineers who are exceptionally good at getting AI to write software. The goal is to create engineers who become better at engineering because they have AI available to them.
An AI-native engineer should not be defined by how much code they delegate.
They should be defined by how effectively they orchestrate intelligence.
They know when to ask the agent to implement something, when to ask it to challenge an assumption, when to explore an unfamiliar domain, when to validate an answer and, perhaps most importantly, when they need to understand something themselves before allowing the system to proceed.
That last part becomes more important as the systems we build become more consequential.
If AI makes implementation abundant, human judgment becomes more valuable, not less.
The answer to the Meat Proxy problem therefore is not to slow down AI adoption or put humans back into every part of the development process. That would miss the opportunity entirely. The answer is to build organisations where AI expands human capability rather than quietly replacing human judgment.
This is ultimately the challenge of AI-native engineering.
We are entering a world where the ability to produce software is becoming less scarce. The ability to make good decisions about software is not.
The organisations that understand that distinction will build very different engineering cultures. They will use AI aggressively, but they will invest just as deliberately in judgment, learning, context and organisational knowledge. They will treat every interaction with AI as an opportunity to improve both the individual engineer and the collective intelligence of the organisation.
Otherwise, we risk creating something that looks like an incredibly productive engineering organisation from the outside, while gradually losing the ability to explain why the systems we are building work the way they do.
That is the real Meat Proxy problem.
It is not that AI writes the code.
It is not that inexperienced engineers can build sophisticated systems.
It is that we might mistake the capability of the machine for the capability of the human operating it.
The question for engineering leaders is therefore no longer whether their engineers are using AI.
It is whether their engineers are becoming better engineers because they are.