How agentic AI is changing the EPD operating model
In my last post, I looked closely at the agentic AI engineering loop: how agentic systems can examine what is happening, narrow uncertainty, propose the next step, and help move real software work forward.
But once agents can participate meaningfully in execution, the operating model around that execution can no longer stay the same. The question is starting to shift from, “can AI help improve the speed or quality of the work?” to “what happens when the work itself starts to change?”
For a long time, the basic way work moves inside product development has looked something like this:
Product writes
Design translates
Engineering implements
QA validates
Analytics measures
Then everyone meets, aligns, revises, and does it again
Even in healthy organizations, a lot of the drag lives in that chain. Work does not just take time because it is difficult. It takes time because it keeps waiting for the next human hop.
Agentic AI is starting to break that pattern. Instead of work crawling through a sequence of handoffs, a person can set the goal, define the guardrails, and give the system enough context to operate. Agents can then do a lot of the first-pass work across the workflow, while humans step in to review, redirect, and make the calls that actually matter.
That is a different execution model.
Making it concrete
Let’s use a B2B dashboard product with a “saved views” feature as our example.
Some customers want to create a filtered view of their data, save it, and share it with teammates. In the old world, the path is familiar. A PM frames the problem and decides priority, design creates flows, engineering starts digging through the codebase, QA gets pulled in later, and a bunch of edge cases surface. Some were in the docs. Some were not. Some live only in someone’s head. So the work starts bouncing around while the team reconstructs how the system actually behaves, where the logic already exists, and which parts are riskier than they first looked.
Now compare that to a more agentic version of the same workflow.
The PM still owns the problem and its priority, the designer still owns the UX quality bar, and engineering still owns system integrity. None of that disappears. But now agents can summarize customer notes related to dashboard view requests, scan the codebase for existing view filtering logic, identify similar patterns, draft a first-pass spec, propose database changes, generate initial tests, and surface likely edge cases before the team gets very far into implementation.
The team still has to decide what is worth doing. It still has to reject bad ideas, catch subtle risks, and make tradeoffs. But the shape of execution changes because the work is no longer bottlenecked by waiting for each function to produce its first draft from scratch.
How the work moves
In the old model, work advances through a chain of functional handoffs.
In the emerging one, the pattern looks more like this: a human sets direction, agents do scoped work across the workflow, and the right humans step in at review points to judge, redirect, and approve.
That may sound like a subtle distinction, but it’s not. It’s a major shift.
When first drafts become cheap across multiple functions at once, the bottleneck stops being draft production and starts being judgment, trust, and making the right call.
Judgment as a bottleneck
If agents can produce ten plausible options in the time it used to take a team to produce one rough first pass, the scarce thing is no longer output. It is deciding what is actually right.
That includes product taste, of course. But it also includes judgment around the technology, priorities, risk, and company direction. Which edge cases matter? Which complexity is justified? Which customer request is loud but directionally wrong? Which polished recommendation is actually nonsense?
The human job is becoming less about generating the first artifact and more about setting direction, applying standards, and protecting customers from a stream of misinformed or half-baked decisions.
What has to get better
This part gets skipped in a lot of the hype.
People see flashy AI coding demos and imagine fast organizational change. The problem is that a lot of software environments were built for humans, and humans have learned how to work around the mess. Agents won’t magically clean it up. They’ll slam right into it.
This problem will show up in a couple big ways:
Documentation
When context is scattered, stale, contradictory, or trapped inside a few people’s heads, it’s annoying and inefficient, but humans can usually limp through. AI will be much less forgiving. If two pieces of documentation conflict, an agent is often going to make poor choices about which one wins, or whether either one is even right in the first place.
Confluence and Notion are helpful to humans, but not nearly as helpful to AI. Sure, agents can access those third-party systems and pull down documentation, but that is often limited by things like the quality of the integration and how long you’re willing to wait for AI to think. It takes time for an agent to query and read dozens of external pages.
For all of these reasons, EPD organizations need to get much more serious about documentation quality and how close it is to the work. Agents get the most leverage from context that is current, well-structured, and just as important, easy to access.
Observability
Agents work better when they can actually trace what is happening in a system. They need readable logs, useful telemetry, and explicit instructions around how to use both.
Don’t have an observability system? Have one but only trained your developers on its UI for an hour a few months back? This won’t cut it.
If an agent is trying to figure out why a KPI dropped 50%, why a feature is timing out under load, or why an exported report disagrees with application data, it needs more than access to your code. It needs an environment where it can ask questions about what’s happening in your systems without guessing. That matters for humans too, of course, but agents will make the gap much more obvious because they very quickly expose just how much of an organization still runs on tribal knowledge and intuition.
Trust
Trust is not all-or-nothing, so the question isn’t whether to trust your agents. It’s which agents will be allowed to do which kinds of work, how that trust will be earned, and how it will be re-evaluated over time. This is more complex than a “human in the loop” solution, since you don’t want humans to end up being the bottleneck for virtually every agent action.
Some output is naturally lower risk: summaries, drafts, first-pass test generation, internal analysis, scoped research, proposed code changes, backlog synthesis. Other work deserves much tighter control: security-sensitive changes, core architecture, pricing, compliance, customer-facing actions, and anything with real blast radius.
The key is that those boundaries should be set based on evidence. There should be more trust when outputs are inspectable, failure modes are understood, drift is detectable, rollback exists, and mistakes are tolerable.
If you cannot tell where the agent helped versus hurt quality, you do not have a trust model. Even then…
Don’t mistake trust for accountability. Agents may help do the work, but a human still owns the outcome. If a team ships something broken, harmful, overbuilt, insecure, or strategically misguided, “the AI suggested it” is not going to be a defensible position. Someone made a call on scope. Someone accepted a recommendation. Someone approved a release. Someone owns the result. That is as it should be.
The org changes too
Once execution changes, the org changes, too. This is where things get more interesting, because the implications are not confined to tooling. They spill into how teams work, what seniority means, how people level up, and why management exists.
Blurred boundaries
Product, Design, and Engineering functions are becoming able to do more across the workflow themselves than before. PMs can do more first-pass technical and analytical work. Designers can prototype and test more aggressively. Engineers can do solution shaping and customer problem analysis.
But the core responsibility of each function also gets clearer. Product still owns prioritization, tradeoffs, and outcomes. Design still owns taste, trust, usability, and coherence. Engineering still owns system integrity, resilience, technical risk, and how not to accidentally burn the place down.
People can do more outside their lane, but the accountability for judgment inside a discipline does not go away.
Seniority
The most valuable people become the ones who can frame a problem clearly, set the right constraints, spot sloppy inputs, and catch misplaced confidence early. Great communication and judgment have always been part of seniority, but we’re moving toward a world where they may matter more than anything else.
Apprenticeship’s comeback
This is one of the parts I think companies are not taking seriously enough.
Juniors probably do not disappear, but the old development path gets shakier. If entry-level growth used to rely partly on getting reps on lower-level work while gradually absorbing context from the people around you, that changes a lot when a meaningful chunk of the grunt work is handled by agents.
Companies will need to be more intentional about apprenticeship, giving juniors opportunities to engage with other engineers while they reason out loud. Otherwise, you risk a weird future where your organization gets temporarily more productive while quietly under-developing its next generation of strong judgment.
Goodbye, weak management
I do not buy the idea that agentic AI somehow makes management less important. I think it will make bad management easier to expose.
If your management value has mostly come from tracking statuses, supervising tasks, or being an approval bottleneck, agentic AI is going to expose that quickly. In an agentic world, management work will look much different: written quality bars, clear escalation paths, codified trust boundaries, solid instrumentation, and constant coaching to improve judgment.
Why this is hard for many teams
Part of the friction is identity. A lot of people built mastery over their work. They like doing that work directly. They like refining their craft. And honestly, that is understandable. Some of the resistance people call “anti-AI” is really attachment to the part of the work that used to feel satisfying in the first place.
There is also a second problem. The shift is not just about new tools. It is about moving from task execution toward problem framing, systems thinking, constraint setting, and judgment. Those skills are not evenly distributed, and they are not skills most organizations have spent years deliberately training at scale.
And to make things more fun, the technology itself is still moving fast while teams are trying to redesign how they work around it. So companies are being asked to change the plane while still flying it.
Ultimately, this transition requires real change management: education, process redesign, organizational alignment, room for experimentation, room for mistakes, and enough seriousness to not let “AI adoption” turn into theater. That competes with near-term priorities, of course. But not investing in that transition has a cost too: slower learning, weaker leverage, and having to watch while faster teams lap your own.
Final thought
The companies that win here will not be the ones that talk the most about AI, buy the most tools, or generate the most internal excitement. They will be the ones disciplined enough to redesign their actual operating model around the reality that:
First drafts are getting cheaper.
Judgment is getting more valuable.
Shared context, observability, and trust are table stakes.
Agentic AI is not just a productivity layer bolted onto the old EPD model. It is creating a new model, which means that management, seniority, apprenticeship, trust, and accountability all have to change with it. This is the harder shift. It is also where the real advantage will come from.
A special thanks to my colleague, Tom Schaal, for his assistance in identifying the change management challenges arising as EPD orgs shift to an agentic world.