How Do TPMs Drive Accountability When AI Owns the Work?
2025.16 - 5th Post - To prepare for a future with fewer TPMs, we need better ways to measure how close that future is so we can start to figure out what is left for us to do, and hone those aspects.
This is the 5th post in a series where I’m pondering out loud in public about how AI might reshape or perhaps, in my opinion, replace the Technical Program Manager role.
So far, we’ve looked at how TPMs process messy inputs, synthesize signal from noise, and distribute that signal to the right people in the right way. With each function, AI is starting to take on more of the heavy lifting.
This week, we turn to accountability because even if AI agents are doing more of the work, someone still has to own the outcome. But what does ownership look like when the “doers” aren’t people anymore?
Let’s dig in.
What Happens to Accountability When AI Owns the Work?
A big part of what we do as TPMs is creating, maintaining, and holding accountability. In simple terms, that means making sure work gets done, someone is clearly, consciously responsible for it and they stick their commitment. We call that “accountability” but it can feel so much more sometimes.
In practice, it means chasing down owners, assigning DRIs, tracking deliverables, clarifying scope, and knowing exactly who to ping when a deadline slips or a dependency gets shaky.
On a good day, accountability is just a well-written Jira task with a clear name attached to it. But on most days, it’s wading through ambiguity to find the one person who can actually fix the thing, negotiating scope, and making sure that person knows it’s theirs to own and drive to the finish line and sometimes, even deciding what that finish can look like.
And in large programs with dozens of engineers, multiple functions, and moving parts, accountability isn’t just about who owns what. It’s about how work flows across people. How visibility is maintained. How pressure is applied gently, and sometimes urgently. It’s about relationships, escalation paths, and soft trust built over time. It is ultimately establishing and ensuring the critical path does not collapse.
Lately, I’ve been wondering: what happens to all of that in a world where GenAI lets teams do more with fewer people?
When There Are Fewer People, Does Accountability Get Easier?
In some ways, you might say yes. If you only have one engineer building a feature with an AI pair programmer, there’s no ambiguity about who’s responsible. You follow up with the one human. Clean. Simple.
But as AI agents start to take on more and more of the execution including writing code, testing changes, writing documentation, updating dashboards then the nature of ownership becomes fuzzier. If a sprint finishes early or a bug is shipped to production, who do you turn to for answers? You still need someone accountable. But the agent that wrote the code isn’t going to hop on Zoom and walk you through what happened or even raise their hand and say “I messed up”.
Here is a thought experiment: Imagine a scenario where something breaks in production. Instead of reaching out to an over stretched designer or over capacity engineer, do I go to the EM and say, “Can you deploy two more agents to fix this faster?” Do I ask for more compute power or access to model credits? Do I even need permission from the EM to spin up autonomous help?
Suddenly, my role as a TPM shifts. I’m no longer just making sure people are doing their part but I’m managing the behavior, reliability, and scale of agents? The ask isn’t “Can we get another engineer to help with this?” It’s “Can we spin up five more agents to handle these components in parallel?”
That sounds efficient. But it introduces new risks. If agents are doing more, who owns their mistakes? If things go sideways, will “the AI messed up” be enough? Someone still has to trace what went wrong, why it happened, and how to stop it from happening again.
The Illusion of Simplicity and the Risk of Fragility
The surface promise of AI is that it reduces coordination and to certain degree butts in seats (for my capacity planners) headcount. And that’s true for a narrow slice of work: routine status updates, reminders, syncing calendars, summarizing meeting notes, simple PRs, rudimentary engineering workflows.
But the deeper work of accountability? That gets more complex.
AI introduces a different kind of risk, a fragility of ownership. Work becomes more elastic. You can do more, with fewer humans. But that also means fewer DRIs, less shared context, and more assumptions left undocumented.
In the old world, you could walk across the floor, tap someone on the shoulder, send a slack DM, start a thread, make a phone call, and ask, “Hey, is this yours?”
In the new world, you’re parsing logs and dashboards from three agents, trying to reconstruct how a decision was made and where it started to go wrong.
Worse still, AI is confident. It keeps doing the thing until someone tells it not to. So while TPMs may need to follow up less often, the stakes of missing a check-in become much higher. Mistakes compound invisibly, especially if agents are tuned to be quiet, fast, and autonomous.
Even worse: we risk not noticing. Because there’s no missed meeting, no unread Slack ping, no late-night “sorry, I forgot to update the ticket.” Just silence and steady output until it all falls apart and breaks down.
What We Lose When Accountability Gets Abstracted
We rely more on people than we realize. This is true not just for output, but for explanation. When something goes off-track today, I might ping an engineer and ask what’s going on. And in that moment, I’m not just gathering information. I’m listening for tone. Confidence. Hesitation. I’m triangulating how likely it is that a blocker is real, how serious the issue might be, and whether I need to escalate or simply wait. I am looking for the human signals.
You can’t do that with an AI agent. At least, not yet.
You might get a summary. Or a status flag. But you won’t get doubt. Or frustration. Or relief. You won’t get the human signals that help a TPM read between the lines and make the right next move. That subtlety of those micro-moments of calibration are part of how accountability functions in a team.
And once you remove them, what’s left?
You might say: cleaner data, clearer workflows, maybe even more facts?
But I worry that what you also get is a cold, noiseless trail.
A New Kind of Scope Creep
Here's a scenario I keep returning to: we have a project in trouble. In today’s world, I might escalate and ask for more engineers. I might negotiate scope. I might ask a team to work weekends, or bring in a contractor or borrow resources to help.
In tomorrow’s world, am I going to be asking: “Can we spin up more agents?”
It’s a smaller ask on paper. No calendars to coordinate. No people to burn out. Just compute. Just automation. But here's the danger: the cost is hidden.
Scope creep gets stealthier. Execution scales quietly. Technical debt compounds. Agent overuse becomes the new human burnout. And by the time anyone notices, we’ve shipped something ten times larger than planned, with twice the risk and no one to blame.
This is where the role of a TPM might shift from managing work to managing scale. Not just what gets done, but how much is being done, by whom, and whether that scale is still strategic.
We may need to pause elastic execution not just to slow things down but to ask: Is this still the right thing to build?
Accountability Might Start to Feel Like Escalation
As agents become more autonomous and execution gets cheaper and faster, escalation becomes the dominant mode of TPM intervention.
Today, we follow up with a quick ping or update thread. We check in during standups, clarify in hallway chats, simple slack DM here and there. In the near-future? You step in only when something has gone wrong and the system can’t fix itself.
In that sense, accountability moves up the stack. It’s not about making sure things get done anymore. It’s about curating outcomes, resolving ambiguity, and knowing when to pull the emergency brake. TPMs might become escalation designers, system monitors, and risk curators more than task shepherds.
And that’s not necessarily bad. But it is a big shift.
New Rituals, New Systems, New Visibility
If this is the future we are shifting too, then we’ll likely need new structures to anchor this shift:
AI agent decision logs + trees
Change reason annotations
System-generated status trails
“Explain your state” protocols built into agent workflows
Escalation metadata and rollback rituals
Stands up give way to “agent work order” verification
and much more…
You could even imagine “agent retros” that function like postmortems but faster, synthetic, and searchable.
The TPM’s job? To read between those lines. To trace where human oversight still matters. And to intervene when autonomy becomes a liability.
We’ll go from designing updates for leaders to designing visibility for ourselves.
Final Word
If work becomes fluid scalable via compute, modular via agents then the old accountability model starts to crack.
What replaces it?
Maybe TPMs will need to get good at creating and managing agent budgets instead of people.
Maybe “more resources” becomes a request for more CPU and fine-tuned models.
Maybe scope creep becomes an untraceable scale of actions, each one seemingly harmless until suddenly BOOM technical debt, cost overruns, or worse.
And maybe, above all, we’ll need to admit that accountability in the future won’t feel like alignment but rather it’ll feel like tracing ghosts in the machine.
Final Final Word
A lot of what I am asking and writing might still feel science fiction. Too far out or even inconceivable and to some just plain wrong.
But in a world where more code is being written by AI, tools like Devin get better and cheaper, and the future code will inevitably be written more and more by AI, we must start to imagine what our role as TPMs in that future looks like right now.
Why? Self Preservation, Utility, Employment.
If we can own building this future, we need to talk about what we lose and what new skills we need to grow to replace it. I don’t have all the answers. But I’m going to keep thinking out loud.
Our world is changing and we cannot let lack of imagination be the reason we are all suddenly wondering - so what is my value now?
Until next time.
-Aadil
A Quick Self-Audit (for readers)
Take a moment. Ask yourself:
Have you ever had an accountability miss that cost you trust, time, or sanity?
Could you imagine holding an AI agent accountable the same way you do a peer?
What new rituals would help you feel confident in a team where agents do most of the execution?
How do you imagine escalation changing when there are fewer humans and more autonomous contributors?