AI Is Removing the Need for Entire Roles
Agents let one owner direct more execution. The useful team boundary increasingly follows a change in judgment, rather than another pile of tasks.
A change can take twenty minutes to implement and still take two days to finish. Someone notices what needs to change, explains it, gets it into the queue, answers a question, and waits for a result. The implementation comes back close enough to reveal what the explanation missed. Another round begins.
That is a familiar cost of dividing software work. It can be worthwhile when the person receiving the request contributes expertise, capacity, or judgment that the requester lacks. But when an agent can perform the implementation under the direction of the person who noticed the problem, the economics change. The handoff has to earn its place.
The opportunity is larger than getting tickets completed faster. A person who understands the intended outcome can carry more of it through without assembling a separate human role for every supporting task. The useful boundary increasingly follows a change in judgment, rather than another pile of implementation work.
Why We Divided The Work
Software teams distribute work partly because there is too much for one person to do, and partly because there is too much for one person to know. Someone understands the customer workflow. Someone knows the platform. Someone maintains the build system. Specialization supplies both execution capacity and different kinds of judgment.
It also manages cognitive load. A developer working on an interaction should not have to keep every dependency upgrade, deployment detail, and account request in the foreground. Giving those responsibilities clear owners allows each person to concentrate.
But division creates its own cognitive load. People must explain intent, negotiate priorities, resolve conflicting assumptions, and keep their understanding aligned as the product changes. The receiving person needs enough of the mental model to make good decisions; the sending person needs to discover where that transfer was incomplete.
Team Topologies treats these as organizational design problems. Its approach emphasizes cognitive limits, end-to-end ownership, and the delays created by dependencies between teams. Close collaboration has a cost; a well-defined service can reduce how much coordination its consumers need.
Agents change that calculation by supplying more execution capacity under one person’s direction. A boundary established because implementation required several people may persist after the reason for it has weakened.
The Ticket Already Looks Like An Agent Task
A sufficiently specified ticket has a familiar shape: an objective, relevant information, constraints, and a way to determine whether the work is complete. Those are also the ingredients of a useful agent assignment.
Stripe’s account of its Minions coding agents makes this concrete. In February 2026, Stripe reported more than a thousand merged pull requests per week containing entirely agent-written code. A typical run began in Slack and ended with a pull request that passed CI and was ready for human review, without interaction during the intervening work. Engineers could start several runs in parallel, including small fixes arising during an on-call rotation.
Prepared environments, internal tools, repository guidance, and automated feedback make that possible. Stripe gave agents access to the tools and information its engineers already use.
If a role’s contribution is receiving a bounded task, implementing the supplied direction, and returning it for review, agents increasingly compete for that work. Technical competence remains necessary, but a separate human implementer is no longer the only way to supply it. Essential work does not necessarily require a dedicated person to perform it.
Stripe retains another engineer’s review after the initiating engineer examines the result. That handoff supplies independent scrutiny. It has a different justification from assigning another person to carry out an already understood change.
Maintenance Without Constant Attention
The same shift reaches work that rarely appears in a product demonstration. Dependencies need upgrades. An API schema needs correction. A build configuration needs to follow a new convention. These tasks matter even when they do not require the product’s direction to be reconsidered.
AWS’s account of agent-assisted Java upgrades describes agents updating dependencies, replacing deprecated APIs, attempting builds, and running tests. The surrounding campaign still requires people to classify applications, sequence shared dependencies, and handle changes the tool cannot complete. The work moves toward directing and verifying a process rather than manually performing every transformation.
Scripts, provisioning systems, and self-service platforms have reduced this burden for years. Agents extend the range of work that can proceed under established rules, returning when an exception needs a decision.
That makes broader ownership practical. One person does not need to watch every upgrade while it runs. They need to know what passed, what failed, and what requires attention. Delegating upkeep frees attention for the decisions that shape the product. A system that reports every intermediate action gives that attention straight back to coordination.
Keep The Decision Close To The Result
That attention matters most when the direction is still changing. A designer sees that a workflow feels wrong. An engineer notices that a proposed boundary makes cancellation awkward. The next useful instruction depends on examining a concrete result.
Directing an agent still requires explanation and correction. The advantage is that the owner can keep those corrections inside the same working session. They can inspect a result, reject it, and try again while the reason for the change is still fresh. Another person does not have to reconstruct that reasoning and fit the revision into their queue.
A short wait for an agent can be cheaper than that transfer. Keeping each person busy and reaching a sound decision quickly are different goals. An organization can keep everyone occupied while the product spends most of its time waiting. As execution gets faster, those delays become a larger share of the cycle.
The two advantages reinforce each other. Delegated maintenance gives the owner room to think. Direct iteration lets them use that attention without repeatedly translating their evolving understanding for someone else.
Organize Around Judgment
Crossing into another domain can still impose substantial cognitive load. Moving from refining and testing software to producing a demo requires a different standard of judgment. “Does this behave correctly?” and “Does this communicate why anyone should care?” are different questions. An agent can produce both artifacts before one person can comfortably evaluate both.
A handoff to someone who understands the audience can therefore earn its place. So can an independent tester who challenges the builder’s assumptions. Each brings judgment the owner may lack or struggle to maintain alongside other responsibilities.
That boundary does not establish the need for several people executing tasks on each side. A senior engineer can direct more implementation while retaining the craft in the system’s design, corrections, and standard of reliability. A product owner can extend their reach in the same way. Each can get more work done without becoming qualified to judge everything.
Better orchestration could move these boundaries further, letting owners supervise through verified outcomes and meaningful exceptions. The next expansion depends on making that supervision trustworthy and cognitively manageable.
The amount of implementation work becomes a weaker reason to add people. The need for additional judgment becomes a stronger one. Teams should form around the expertise, attention, and continuity the work requires, rather than the volume of manual execution it once demanded.
When someone understands what needs to change and can now direct it through implementation and correction, another queue between intention and feedback needs a better justification than that it used to be necessary.