The developer typing code is already a stock image
For years, we imagined the software engineer as a solitary figure in front of a screen.
Headphones on.
Lukewarm coffee.
Terminal open.
Lines of code.
Religious silence.
That image shaped an entire modern mythology: the developer as a monk of syntax, a keyboard craftsman, a patient translator between human intention and machine execution.
Then AI agents entered the workshop.
And they did not ask for an ergonomic chair.
They did not ask for a beautiful interface.
They did not ask for an emotional onboarding sequence with a polished welcome animation.
They asked for something else: readable context, explicit permissions, understandable errors, test environments, execution paths, guardrails, logs, rules and validation loops.
In other words, they shifted the center of gravity of the profession.
The New Stack article about Netlify and its CTO Dana Lawson makes the point clearly: in the age of AI agents, the software engineer’s role is no longer defined only by writing code, but by the ability to design environments where humans and agents can work together (The New Stack) .
The developer typing code for eight hours is gradually becoming a stock image.
Not because the developer disappears.
Because the visible gesture of the profession becomes less central.
After UX and DX comes AX
First, we learned to design for human users: UX.
Then we understood that we also had to design for developers: DX.
Now a third layer is emerging: AX, for Agent Experience.
Netlify defines Agent Experience as the holistic experience an AI agent has when using a product or platform (Netlify) .
This is a significant shift.
Until now, many companies have treated AI as a tool placed on top of an existing process. Add a chatbot here, a copilot there, a text generator somewhere else. Keep the organization unchanged. Hope productivity falls from the sky.
But autonomous agents are not simply faster tools.
They become partial operational actors.
They read.
They interpret.
They propose.
They modify.
They test.
They fail.
They try again.
They ask for context.
They execute tasks once reserved for highly qualified humans.
Netlify even launched netlify.ai as an entry point designed for agents, giving them onboarding, access and context to build and deploy with its platform (Netlify Blog) .
That detail matters more than it seems.
When a company creates a specific door for agents, it recognizes that agents are becoming a new category of users.
Not human users.
Not classic APIs.
Not scripts.
Non-human operational users, able to act on behalf of a human intention.
Any company that does not design that experience will leave agents improvising in the fog.
The trap: treating the agent like a magical intern
The first trap is treating the AI agent like a magical intern.
Give it a vague instruction.
Ask it to move fast.
Provide no context.
Set no boundaries.
Check no assumptions.
Document no decisions.
Then act surprised when it produces something plausible, fast and dangerous.
This is exactly where Agent Experience becomes strategic.
An agent works well only in a system that gives it the right signals.
In its documentation on Copilot cloud agent, GitHub states that the agent can research a repository, create implementation plans, fix bugs, improve test coverage, update documentation and work inside an ephemeral environment powered by GitHub Actions (GitHub Docs) .
That is a major evolution.
But it does not remove human responsibility.
It increases it.
Because the more an agent can act, the more humans must clarify the frame.
Who validates?
Who authorizes?
Who reviews?
Who arbitrates?
Who decides that a change deserves to ship?
Who takes responsibility when the agent produces an elegant error?
Code becomes raw material.
Value moves toward architecture, validation, security, responsibility, prioritization and judgment.
AI does not forgive ambiguity. It industrializes it.
Many companies will fall into the classic trap.
They will buy tools.
They will launch pilots.
They will stack prompts.
They will organize three spectacular demos for the executive committee.
Then they will discover that nobody thought about roles, responsibilities, permissions, sensitive data, validation processes, psychological safety, access rights, stop criteria, decisions and the real organization of work.
AI does not forgive ambiguity.
It industrializes it.
A poorly defined process handed to an agent does not suddenly become intelligent.
It only becomes faster.
A bad brief does not become a strategy.
It becomes a multiplied error.
Weak governance does not become agile.
It becomes porous.
Anthropic, in its guide on building effective agents, observes that the most successful implementations often use simple, composable patterns rather than overly complex frameworks (Anthropic) .
That point is essential: the challenge is not to build an agentic gas factory.
The challenge is to create a system that can be understood, observed and adjusted.
An AI agent does not need managerial poetry.
It needs clarity.
The new role of the engineer: orchestrating, not just producing
Software engineering is already no longer limited to producing code.
The best technical profiles are becoming designers of hybrid systems.
They know how to write code, but more importantly they know how to:
break down a problem;
formulate an intention;
structure an environment;
provide context;
test assumptions;
evaluate an answer;
identify a risk;
set a boundary;
decide what deserves to exist.
This is where the word “engineer” almost returns to its original meaning.
The engineer is not only the person who builds.
The engineer designs the conditions under which building becomes reliable.
Stack Overflow states in its 2025 survey that more developers actively distrust the accuracy of AI tools than trust them: 46% actively distrust them, compared with 33% who trust them (Stack Overflow) .
That figure tells a healthy story.
Experienced developers do not necessarily reject AI.
They simply restate the obvious: the output must be verified.
The critical skill is therefore not only knowing how to use the agent.
The critical skill is knowing not to believe it too quickly.
The developer becomes an air traffic controller
The most accurate image is no longer the developer leaning over a keyboard.
It is an air traffic controller.
They do not pilot every plane.
They coordinate trajectories.
They monitor signals.
They anticipate collisions.
They give authorizations.
They take back control when the context deteriorates.
They know that a small coordination error can create a disaster.
Tomorrow, the developer will not necessarily be less technical.
They will have to be technically broader.
Less focused on the isolated line of code.
More attentive to the entire ecosystem: repository, tests, security, documentation, dependencies, technical debt, permissions, business context, compliance, costs, user experience, developer experience, agent experience.
The developer becomes the architect of a collaboration space between human intelligence and artificial intelligence.
The real subject is not automation. It is responsibility.
In many AI conversations, the same obsession keeps returning: how much time will we save?
That is the wrong entry point.
Time saved can become time wasted if the organization does not know what to do with it.
Time saved can produce more noise, more useless deliverables, more secondary features, more validation meetings, more security risks.
The central issue is therefore not only productivity.
The central issue is responsibility.
When an agent generates code, who is responsible for the result?
When an agent modifies a codebase, who truly understands the impact?
When an agent proposes a correction, who decides it is acceptable?
When an agent increases production speed, who protects human intention?
In my book, chapter 14 is precisely dedicated to applying innovational intelligence® to artificial intelligence. I emphasize a simple idea: AI adoption must not start with the tool, but with vision, communication, culture, psychological safety and methods.
A miraculous tool has little value in a confused organization.
It can even become dangerous when it creates an illusion of control.
Agents need a mature organization
Agent Experience is not only a technical-team issue.
It concerns the entire organization.
Because behind every agent lies a governance question.
What can it read?
What can it write?
What can it modify?
What can it delete?
What can it trigger?
What must it ask for?
What must it explain?
What must it refuse?
What must it log?
What must it hand back to a human?
These questions sound technical.
They are actually managerial.
They force the company to look at its own gray areas.
Implicit processes.
Undocumented decisions.
Oral validations.
Personal dependencies.
“We have always done it this way.”
Access rights distributed too broadly.
Responsibilities never clarified.
Agentic AI forces the organization to become more explicit.
That is excellent news for mature companies.
It is an uncomfortable mirror for the others.
AX is process innovation
Agent Experience is not just another fashionable acronym.
It is process innovation.
It changes how we produce, test, ship, document, decide and collaborate.
A company that treats AX as a purely IT topic will miss the point.
A company that treats it as a transformation of work will move ahead.
Because behind AX lies a broader mutation: the end of work designed only for humans.
For more than a century, we organized companies around jobs, departments, workflows, meetings, documents, validations and tools designed for humans.
Now part of those workflows will be executed by agents.
Not everywhere.
Not all the time.
Not without control.
But enough to force a redesign of systems.
What must remain human
The strategic question becomes: what part of work must remain human at all costs?
Judgment.
Intention.
Responsibility.
Ethics.
Understanding consequences.
The courage to say no.
The ability to decide that a technically possible feature does not necessarily deserve to exist.
This is probably where the best engineers, managers and leaders will make the difference.
They will not be the ones asking AI to do everything.
They will be the ones able to decide what AI must not do.
They will know how to orchestrate agents, set limits, validate outcomes and protect human intention.
Welcome to the era of Agent Experience.
After UX for humans.
After DX for developers.
Here comes AX for autonomous agents.
For companies, the message is clear: it is better to learn how to pilot agents before they start piloting your executive committee.
References
(The New Stack) = https://thenewstack.io/netlify-agent-experience-engineers/
(Netlify) = https://www.netlify.com/agent-experience/
(Netlify Blog) = https://www.netlify.com/blog/netlify-for-agents/
(GitHub Docs) = https://docs.github.com/en/copilot/concepts/agents/cloud-agent/about-cloud-agent
(GitHub) = https://github.com/newsroom/press-releases/coding-agent-for-github-copilot
(Anthropic) = https://www.anthropic.com/engineering/building-effective-agents
(Anthropic Engineering) = https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
(Stack Overflow) = https://survey.stackoverflow.co/2025/ai
