Community

translate Automatic translation · View original

Agile leadership: don't make the decisions, design how they are made

Canal De Escalado Y Liderazgo

1 June 2026
Agile leadership: don't make the decisions, design how they are made
Agile leadership is usually explained with abstractions: vision, inspiration, servant leadership. This article proposes something more operational: looking at how the team's decisions are designed and distributed —who decides what, with what information, at what speed— and what happens to that design now that AI makes observing and acting cheap, shifting the bottleneck to judgement. It includes seven practical proposals for starting to map a team's decisions. Your own experiences —with or without AI involved— are welcome in the thread.

When we read about «agile leadership» we always see the same things: inspiration, vision, servant leadership, purpose... All so true and yet so abstract that they serve equally well for managing a software team or coaching a handball team.

But perhaps the difference between teams that work well and those that get stuck isn't in the leader's charisma, but in how decisions are designed and distributed. Who decides what, with what information, at what speed, and what happens when they get it wrong.

This is what we could call «decision architecture.» Traditional leadership is based on making decisions, and I believe agile leadership consists of not making the decisions but designing the system that makes them.

The decision as a flow of the system, not as an attribute of the boss

Normally information travels up the hierarchy and decisions travel down. The problem is that every level crossed adds latency and loss of context. Decisions are made with information that the journey has shaped, and by the time the decision reaches the bottom, reality may have already moved on.

David Marquet, a nuclear submarine captain turned management reference, summed it up with the phrase «instead of moving information to authority, move authority to where the information is».

This is the foundation of agility: «self-organizing teams». But be careful: decentralizing is not distributing decisions and wishing for good luck. Two pillars are necessary: technical competence (those who decide must know how to do it) and clarity of intent (and they must know what for). Without them, it's abandonment rather than decentralization.

Here there is often an uncomfortable truth: agile teams usually don't have a decision map established. If you ask who can decide to change a library, drop a story from the sprint, or delay a delivery, the answers are usually a mix of «it depends», «ask so-and-so», or silence. There is certainly an architecture, because as a self-organizing team, decisions do get made; it's just that nobody has designed it: it has grown on its own, like technical debt.

Not all decisions weigh the same

Jeff Bezos popularized a distinction worth more than many manuals: there are reversible decisions (two-way doors: if you get it wrong, you walk back) and irreversible decisions (one-way doors: you walk through and the door disappears).

The classic mistake of large organizations is to treat every decision as irreversible: committees, approvals, endless analyses... to decide things that could be undone in an afternoon. The symmetrical mistake —less discussed but just as costly— is to treat irreversible decisions with the lightness of reversible ones, which is how you end up with a monolith that's impossible to migrate or a contract you can't get out of.

From this follows a fairly clean design rule:

  • Reversible decisions should sink to the level closest to the information, with permission to make mistakes and learn quickly.
  • Irreversible decisions must rise just enough, slow down deliberately, and be documented.

The interesting thing is that the boundary between the two is not fixed: much of the engineering work (tests, feature flags, incremental deployments, decoupled architectures) consists precisely of turning irreversible decisions into reversible ones. Every time you lower the cost of undoing something, you expand the area in which the team can decide without asking permission. Technical infrastructure is, too, decision architecture.

Deciding without having all the information (that is, deciding)

If you wait until you have all the information, you're not deciding: you're confirming. Real decisions always happen with incomplete information, and the useful question is not «do we have enough data?» but «is it more costly to wait or more costly to be wrong?» For reversible decisions, waiting almost always costs more. Some people use the 70% heuristic: if you have 70% of the information you'd like, decide; the remaining 30% is cheaper to buy by acting than by analyzing.

Here is where a framework from the military fits in and describes agile work surprisingly well: John Boyd's OODA loop —Observe, Orient, Decide, Act. Boyd, a fighter pilot, argued that in a changing environment the winner is not whoever decides best in the abstract, but whoever iterates the complete loop fastest: whoever observes, adjusts their interpretation, decides, acts, and observes again before the context leaves them obsolete.

It sounds like iteration in sprints: inspection and adaptation.

But Boyd's important nuance is often lost: of the four phases, the decisive one is not Decide. It is Orient: the filter of experience, context, culture, and mental models through which we interpret what we observe. Two teams can look at the same dashboard and see different things; the difference lies in orientation. Going very fast with a mistaken orientation is not agility: it's heading straight for the rocks. We'll keep this in mind, because it's exactly the phase that AI doesn't solve for us.

And then AI arrived and stepped on the accelerator

Generative AI is compressing the loop asymmetrically. Observing, increasingly cheap: summarizing, analyzing, detecting patterns in quantities of information that were once unmanageable. Acting, increasingly cheap: generating the code, the document, the prototype in minutes. The loop spins faster than ever...

...and the bottleneck shifts exactly to the two middle phases: orienting and deciding. That is, to judgement.

This changes the economics of leadership. When producing was expensive, value lay in executing well what had been decided. When producing is cheap, value lies in deciding well what to produce —and in validating faster than things get generated. It's the same logic by which, in the post on Scrum and AI, I suggested that the Product Owner evolves into a Product Architect: when AI builds faster than the organization can validate, whoever decides becomes the limiting factor of the whole value chain.

But there is a risk more subtle than saturation, and it's worth naming: automation bias. When a system is right 90% of the time, the natural thing is to stop checking; and then the remaining 10% passes without anyone looking. The trap is that assent looks a lot like judgement: approving the AI's proposal without having been able to evaluate it gives exactly the same feeling as deciding. But it isn't deciding. It's signing off.

Approving the AI's proposal without having been able to evaluate it gives exactly the same feeling as deciding. But it isn't deciding. It's signing off.

The questions this raises (and that I don't manage to resolve)

We acknowledge that this line has open questions:

  • Who is accountable for a decision suggested by AI? The easy answer is «the human who approved it.» But if that human approves forty suggestions a day because the flow doesn't allow for more, accountability becomes a legal fiction. Responsibility without real capacity for review is not responsibility: it's a lightning rod.
  • Does judgement atrophy when it isn't exercised? Criterion is trained by deciding small things and bearing the consequences. If AI absorbs the small decisions, where will the judgement for the big ones come from? We are especially worried about junior profiles: AI is cutting the lower rungs of the ladder by which people have always climbed —minor decisions, cheap mistakes, growing judgement.
  • Are we decentralizing or re-centralizing without realizing it? A curious paradox: we delegate by decentralizing decisions to the teams... and the teams delegate them to the same AI model, with the same biases and the same «orientation.» Decisions that are formally distributed but cognitively homogeneous, lacking the diversity of judgement that was a property of the system that we are not protecting.
  • How much friction is healthy? We are eliminating friction in processes, and in general that's a good idea; but some friction in making irreversible decisions provides a safety mechanism. If AI removes friction, it will need to be reintroduced deliberately. Managing not slowness, but composure: another new craft.

Proposals for gradually modeling a decision architecture made by humans

To offer a few ideas, it may make sense to try:

  1. Take an inventory of decisions. A dedicated retrospective could be enough to start: what decisions do we make recurrently? Who makes them today? Who has the best information to make them?
  2. Classify by reversibility, not by importance. «Important» is subjective and usually means «it makes me nervous.» Reversible/irreversible is operational: reversible ones down and fast; irreversible ones slow and in writing.
  3. Replace instructions with intent. Instead of deciding for the team, provide the context so the team can decide: what is sought, what constraints exist, what is non-negotiable. It's the military commander's intent, and it's what distinguishes delegating from abandoning. Curiously, it's the same discipline that demands writing a good specification for an AI: if you can't make intent explicit, the problem isn't with whoever executes.
  4. Keep a lightweight decision log. ADRs (Architecture Decision Records) are the well-known example in software, but the minimal format works for any field: what was decided, what alternatives were discarded, what was known at the time. It's not bureaucracy: it's what allows you, six months later, to distinguish a bad decision from a reasonable decision with bad luck. Without that record, any review of decisions is a judgement with the benefit of hindsight.
  5. Use AI to open options, not to close them. As a generator of alternatives and devil's advocate («what are we assuming?», «how could this go wrong?») it is extremely valuable. As an oracle that delivers the final answer, it's a machine for manufacturing assent. The practical rule: let AI widen the menu, but the team chooses the dish.
  6. Hold retrospectives on decisions, not only on tasks. Retrospectives usually review what we did and how we coordinated, but rarely how we decided. The idea is to take two or three decisions from the last quarter and evaluate the process, not the outcome: did we have the information it was reasonable to have? Did the right person decide? Did we take an appropriate amount of time? Judgement also needs its own inspection and adaptation loop.
  7. Protect small decisions so that people make them. Even if AI could make them better. It's not inefficiency: it's the training cost of judgement needed to tackle decisions that AI cannot make. Pilots still fly by hand from time to time even though autopilot is statistically better, for the same reason.

In short, in an agile team, leadership is not concerned with making the decisions, but with designing the architecture through which they flow: where they are made, with what information, at what speed, with what safety net, and now, additionally, what role AI plays at each point of that flow.

Without a doubt, this is a sketch of a map that is still under construction. If you are experimenting with how to distribute decisions in your teams —with or without AI involved— suggestions and corrections are welcome.