I’ve argued before that, in the future an engineer’s work won’t be to code, but to contract, inspect, test, benchmark, deploy, and monitor what AI produces (i.e., in the future, software engineers will become managers of agentic machines). That was a prediction about where the profession is heading. What follows is my understanding of what that mindset looks like for the individual.
The elite software engineer of the future is what I call a meta engineer. Their focus isn’t the software, per se. It’s the conditions under which AI agents produce software accurately and without supervision. In this future, the complexity doesn’t disappear, it simply moves. Now, it’s the environment and context that needs engineering, not the software itself.
The goal isn’t better prompting on a (particular) task. It’s an agent’s ability to one-shot the task, with high accuracy. It’s providing enough context, and enough direction, that the work comes back right the first time, with no questions asked and nothing to correct. Those two ingredients are what you’re actually building. Loop engineering is part of it, but reinforcement learning is the real unlock. Agents do the work, the environment scores it, and what they learn survives the run, so the next task starts with more “know-how” than the last one had.
Stop Writing Code, Seriously
If you haven’t already, stop writing code! Not “treat code as secondary.” Not “code is a lower-level concern now.” Stop writing it (unless absolutely necessary).
Instead of writing the code, codify the conditions that allow AI agents to write the code for you, in your style, with your preferences. Recognize any aversion to handing off that responsibility as a lack of trust in the environment you’ve created for the agent(s), and fix that! Let agents build all of it: the pipeline, the observability layer, the orchestration, the eval harness. When your hands are on the keyboard producing implementation, one of two things happened. You failed to delegate, or you failed to build an environment where delegation works.
Reading code isn’t writing code. You can’t judge output you can’t read, and judgment is the entire job now. An engineer who never learned to recognize a bad abstraction, a race condition, N+1 query conditions, or a migration that will lock tables under load has no basis for approving anything.
There are honest exceptions. Bootstrapping an environment the first time. Changes that are irreversible or safety-critical. The discipline is to log each one as a defect against your environment instead of accepting it as normal.
Teach the Agent to Fish
Agents produce knowledge while they work. Findings, decisions, constraints discovered the hard way. Captured properly, that knowledge becomes context for the next turn, run, tasks, and agent; and better context produces better work. You’re building a living context layer that becomes your proxy (HOTL, not HITL). This is called reinforcement learning.
Give an agent a fish, feed it for a day. Teach an agent to fish, feed it for a lifetime.
That layer also has the same failure mode as every neglected corporate wiki, with one difference that inverts the severity. A person skimming a stale runbook senses something is off and asks around. An agent treats it as ground truth, acts on it, and writes its conclusions back into the same layer. Bad context doesn’t sit inert. It propagates. Garbage in, garbage out.
Governance is therefore not a separate concern from compounding. Knowledge has to stay current, traceable to evidence or outcomes, actionable rather than merely accurate, and invalidated the moment something contradicts it. Agents can help with this “meta” work too, i.e., maintaining the living context layer.
Documentation debt used to be a low-severity annoyance. In systems with reinforcement learning based on documentation, it’s now a production concern. Compounding data is only valuable when it compounds useful direction, not more information.Get this right and the arithmetic changes. The first agent to touch a problem needed three rounds of correction. The tenth one-shots the same class of work, because everything the first agent learned the hard way is sitting in the layer as guidance waiting for it. Context compounds into accuracy.
The Measure of Success
A day full of typing feels productive. It isn’t anymore. Plenty of good engineers will spend the next decade looking busy while shipping less than the person next to them who stopped typing and built the environment instead.
Start measuring! Take every task you handed to an agent last month. How many came back right the first time, with no questions and nothing for you to fix? Divide that by the total. That’s your one-shot rate, and it’s the only number that tells you whether the environment is any good. Your goal is now to continuously improve that metric.
A missing constraint costs you a retry, so write the constraint. A finding the agents keep rediscovering costs you a round trip, so put it in the context layer and govern it. An eval you never built is a correction you make by hand forever. None of that is prompt craft. It’s environment design, and the score tells you whether it’s working.
Elite engineering in the age of AI is the ability to create the conditions such that an AI agent has enough context and direction to be able to one-shot a task with a high degree of accuracy.
