The Engineer’s New Job is to Design the Environment Where the Agent Can Work
For years we thought the goal of software engineering was to write better code.
Learn new languages.
Master frameworks.
Design cleaner architectures.
Optimize systems.
And of course, keep writing.
But OpenAI just published one of the most interesting papers I’ve read this year because it raises an uncomfortable possibility:
What happens when writing code stops being the engineer’s main activity?
Not because code disappears.
Because someone else is writing it.
The OpenAI Experiment
OpenAI published an internal analysis on how it built a product using Codex.
The numbers are hard to ignore.
Approximately:
-
1 million lines of code generated
-
1,500 pull requests
-
a relatively small team overseeing the process
-
practically zero lines written manually
The official conclusion wasn’t:
“Agents replace engineers.”
It was something much more interesting.
Engineers started spending less time writing code and more time designing the environment where agents could produce good code.
OpenAI calls this:
Harness Engineering.
Code Stopped Being the Main Product
When an agent generates thousands of lines per day, a new problem appears.
Speed is no longer the bottleneck.
The quality of the environment is.
If an agent has bad context:
it produces bad code.
If documentation is out of date:
it produces bad code.
If the architecture is inconsistent:
it produces bad code.
If the rules aren’t clear:
it produces bad code.
The problem is no longer the ability to generate.
It’s the ability to guide.
The Agent Only Sees What It Can See
This was probably the most important observation in the paper.
Humans operate with implicit knowledge.
Agents don’t.
Humans can infer.
Agents depend on available context.
From the agent’s perspective:
What isn’t documented doesn’t exist.
That forces us to rethink many traditional practices.
For years we tolerated repositories where knowledge lived in:
-
Slack
-
informal conversations
-
scattered documentation
-
tribal knowledge
-
the memory of senior developers
Agents immediately expose those weaknesses.
AGENTS.md Could Become the New README
One of the patterns described by OpenAI is the use of explicit files to explain how a system works.
Not just what it does.
How to think about it.
What components exist.
What constraints must be respected.
What conventions to follow.
What errors to avoid.
Essentially:
An operating manual for agents.
Something that looks much more like an operating system than traditional documentation.
The New Skill is Readability
For decades we optimized code for humans.
Now we must optimize systems for humans and agents simultaneously.
That means:
More explicit architectures.
More consistent naming.
More predictable interfaces.
Clearer dependencies.
Documentation closer to the code.
Not because humans need it.
Because agents need it.
And curiously, that usually benefits humans too.
The Best Engineers Start to Look Like Context Architects
This changes the nature of the work.
When we observe the most effective engineers working with agents today, we see less time spent on direct implementation and more time spent on:
-
defining constraints
-
structuring repositories
-
designing workflows
-
improving documentation
-
building internal tools
-
creating feedback loops
-
improving observability
The work increasingly resembles designing a production environment for artificial intelligence.
Observability for Agents
Another interesting finding is that agents generate an enormous amount of activity.
Much more than an individual developer.
That makes observability critical.
We need to understand:
-
what decisions the agent made
-
why it made them
-
what context it used
-
what tools it executed
-
what failed
-
what worked
Traceability stops being a luxury.
It becomes basic infrastructure.
Tests Change Function
Traditionally tests validated code.
Now they also validate agents.
A successful test no longer means only:
“The functionality works.”
It also means:
“The agent understood the problem correctly.”
The test suite starts to act as a behavior correction mechanism.
It’s a subtle but important shift.
Technical Debt Builds Faster
There’s another rarely discussed consequence.
Agents produce a lot of code.
And any system that produces code quickly can also produce technical debt quickly.
OpenAI describes something that many organizations will start to discover over the coming years:
The speed of creation increased.
But the speed of maintenance didn’t necessarily increase in the same proportion.
That’s why a new responsibility appears.
Not just build.
Also delete.
Refactor.
Simplify.
Compress complexity.
Do garbage collection on previous decisions.
Harness Engineering Surprisingly Resembles DevOps
While reading the paper it reminded me of something that happened more than a decade ago.
When DevOps appeared, many people thought it was about automation.
It was really about systems.
Pipelines.
Observability.
Processes.
Feedback loops.
Harness Engineering seems to follow the same trajectory.
It’s not a discipline centered on models.
It’s a discipline centered on systems.
The model is just one of the components.
The Wrong Question
The industry remains obsessed with one question:
Will agents replace developers?
OpenAI is suggesting something different.
The right question might be:
What new responsibilities emerge when code stops being the scarce resource?
Because if generating software becomes cheap, then other things become valuable.
Context.
Architecture.
Constraints.
Documentation.
Observability.
Governance.
Readability.
The Real Signal
Many will interpret OpenAI’s paper as evidence that agents are replacing human programming.
I think the important signal is different.
Engineering is moving toward a higher level of abstraction.
The best engineers will continue building systems.
The difference is that they’ll write fewer lines of code and spend more time designing the environment where other systems — agents included — can work correctly.
If DevOps turned infrastructure into software, Harness Engineering might end up turning software engineering into context engineering.
And that’s a much deeper transformation than it appears at first glance.