Your AI Tool Became Your Team’s Choice Architect

The choices still feel like yours. The design behind them belongs to someone else. AI-generated image.

I cannot remember the last estimate my team argued about, and once I noticed that, I could not un-notice it. The numbers still get set every sprint. They arrive in the planning tool already filled in, plausible, formatted in our own vocabulary, and we nod them through.

Richard Thaler and Cass Sunstein have a name for what is happening in that room, and it is not automation. In their 2008 book Nudge, they called it choice architecture: the practice of organizing the context in which people make decisions. Their central and genuinely uncomfortable claim is that every menu is designed by someone, and no menu is neutral.

Disclosure: I used AI tools for research support and to generate the illustrations; the writing and analysis are my own.

When Artificial Intelligence (AI) drafts your backlog, orders your stories, and pre-fills your estimates, it has quietly become your team’s choice architect. The team still chooses. It just chooses from a menu the tool composed.

I want to argue that this, not job loss and not hallucinated code, is the most under-examined thing AI is doing to Agile teams. Not because the tool decides for you, but because it designs the space in which you decide, and almost nobody on the team can see the design. You are still making choices; you are just making them inside an architecture you did not build and cannot inspect.

When I wrote recently about Agile Principle 11 and self-organizing teams, I traced one version of this: how an AI-drafted backlog moves decision-authorship from the team to the tool, and why a pre-filled estimate is a different act from one the team produced. That piece named what happens to a single principle. This one is about the mechanism sitting underneath it, the one operating across every ceremony at once.

The default effect on the backlog was one symptom. Choice architecture is the disease. And the honest version of this argument admits a real trade-off: the same design that costs you authorship is often the design that makes you faster.

Every Menu Has an Author, and It Stopped Being You

Thaler and Sunstein’s most-studied instrument is the default, a pre-set course of action that takes effect when the decision-maker specifies nothing. Defaults are powerful because they work with status-quo bias and the ordinary human preference for inaction. Leave the box checked and you have chosen, without ever experiencing yourself as choosing.

The reason this matters for software teams is that AI tooling is a default-generation machine. GitHub reports that developers accept roughly 30 percent of Copilot’s suggestions, and in the company’s own controlled study, task completion time dropped from about two hours forty minutes to roughly one hour eleven.

That speed is real. It is also the exact mechanism by which the menu stops being yours.

Here is the part that should unsettle any experienced practitioner. Research by Ziegler and colleagues, published in Communications of the ACM, found that Copilot’s acceptance rate correlates with a developer’s perceived productivity, and that the least experienced developers accept the most suggestions.

Earlier work by Vaithilingam and colleagues found developers felt time had been saved even in cases where no time savings were measured. The feeling of a good decision and the fact of one have come apart, and the tool is standing exactly in the gap.

Why You Feel More in Control the Less You Are

The seductive counterargument is that AI increases your control. You approve or reject a hundred times an hour; your hand is on every choice. At the level of individual keystrokes that is true, which is precisely what makes the loss so hard to see.

But approving a suggestion someone else generated is not the same act as generating it. If the menu was composed by the tool, clicking accept is a diner’s freedom, not a chef’s. You are choosing among dishes; you are not deciding what is on the menu.

The sensation of agency is loudest exactly where authorship is thinnest, and that gap is not a personal failing. The International AI Safety Report 2026 names automation bias as a force that undermines “the authenticity of people’s judgement and their agency to act independently.” It cites a study in which a writing assistant shifted not only the text a person produced but the opinions they personally held toward the model’s.

There is a second, distinct mechanism worth separating out, because conflating the two is how teams misdiagnose the problem. Anchoring is not the default effect. A pathology study in 2026 found that AI advice produced a measurable degree of anchoring on the system’s output, and that the effect intensified under time pressure.

A pre-filled estimate does not just make acceptance easy; it sets the number your discussion now orbits, before your team has formed a number of its own. Defaults capture the choice you skip. Anchors bias the choice you think you are still making.

This Is Not Just Automation Bias With a Better Vocabulary

I can hear the objection, because I have made it myself. Is this not simply automation bias, already well documented, dressed up in behavioral-economics clothing? It is not, and the difference is the whole practical point.

Automation bias is about trusting wrong output. Choice architecture operates even when the output is right. Defaults, anchoring, and the ordering of a backlog are structural levers that move authorship regardless of whether the AI’s suggestion was correct.

A team can accept a genuinely excellent AI-drafted plan and still have surrendered the authorship that Principle 11 assumes, because emergence requires the team to be the origin of the plan, not merely its approver. The problem is not that you might rubber-stamp a mistake. The problem is that you rubber-stamp, full stop.

This is why the framing that treats AI as an autonomous teammate misses the danger. Henrik Kniberg, whose Spotify model shaped how a generation thinks about team autonomy, now argues for giving AI “tools and autonomy” and warns that anyone clinging to manual backlog management risks becoming the bottleneck.

I take the productivity case seriously. But “grant the AI autonomy” quietly skips the question of who authorized the tool to set the team’s defaults, and the honest answer is that nobody did. It happened through the ordinary structure of the situation, which is exactly how Thaler and Sunstein said it always happens.

The Architecture Was Built for Throughput, Not for You

Thaler and Sunstein argued that since being nudged is unavoidable, choice architectures should be designed deliberately, for the decision-maker’s benefit. That is the sentence to hold against your current toolchain.

Your AI backlog tool was not designed for your team’s decision-ownership. It was designed for throughput, engagement, and the vendor’s demo. The architecture you now decide inside was optimized for someone else’s goal, and you inherited it without a vote.

The costs of that are starting to surface in the delivery data. The DORA Report 2025 introduced a rework-rate metric specifically because AI-generated code turns unplanned production fixes into a critical blind spot. Telemetry from Faros AI shows median pull-request review time up 441 percent while 31 percent more pull requests merge with no review at all.

Notice where governance sits relative to all this. Organizations govern what AI is permitted to do: the compliance rules, the platform guardrails, the model-risk sign-offs. None of that touches the choice architecture the tool imposes on a Tuesday standup.

Governance operates one altitude above the place where the actual decisions get shaped. Which means the most consequential design in your process is also the least governed.

Noticing the Architecture Is the Job

If being nudged is unavoidable, then the practitioner’s real work is not to escape the architecture. It is to see it and redesign it on purpose. That reframing is oddly freeing, because a design you can name is a design you can change.

The first move is to make authorship a visible, deliberate act rather than a background assumption. Before a team accepts an AI-drafted estimate, someone states the team’s own reason for the number, in the team’s own words. If nobody can, that silence is the signal that the team is ratifying rather than deciding.

This is where backlog refinement earns its keep as the place where the product and technical stories get reconciled. Not as a ticket-tidying meeting, but as the site where a team either exercises authorship or quietly hands it away. The friction you feel there is not waste; it is the sound of a team being the origin of its own plan.

Someone has to own that redesign, and it is not going to be the tool. It is the human whose center is judgment, the one role whose accountability AI clarifies rather than absorbs. The Product Owner, or whoever holds outcome accountability on your team, is the natural architect of the team’s own choice architecture, because they are the person who has to face a stakeholder later and explain why the pre-filled plan produced the wrong product.

That is a role that cannot be defaulted away, which is exactly why it should be the one deciding which defaults the team keeps.

The Menu Is Not the Meal

None of this is an argument against the tools. The speed is real, the leverage is real, and pretending otherwise would be its own kind of dishonesty. The argument is that speed delivered through a default you did not design is not free, and the bill arrives later, in plans nobody can defend and estimates nobody owns.

The hard part is that resisting this costs effort in the exact place the tool promises to remove it. Keeping your team the author of its own plan means protecting slower conversations, cheaper overrides, and the small friction of stating your own reasons, precisely when the whole appeal of the AI is that it spares you all three.

That is a genuine trade-off, not a free lunch, and treating it as free is how good teams mistake the menu for the meal. So here is the question I would sit with before your next planning session: on your team, who is the choice architect right now, and when exactly did anyone decide it should be the tool?

Related Reading

The Product Owner Is the Only Scrum Role AI Makes Harder. The role whose accountable judgment makes it the natural architect of the team’s own defaults.

Backlog Refinement Is Sensemaking, Not Ticket Tidy-Up. The ceremony where a team either exercises authorship over its plan or quietly surrenders it.