Extreme Ownership: there are no bad teams, only bad leaders
What I took from Jocko Willink and Leif Babin's book while leading technology managers: owning the team's results, the standard you tolerate, the four laws of combat applied to software teams and why ownership is not doing everything yourself.
Fernando Ghisi · 20 min read
A book worth coming back to
I read Extreme Ownership when I started leading, and it's one of those books I like to come back to from time to time. Each time the reading changes, because my role has changed.
Today I lead technology managers, and that gave me one more layer between me and the team. Results keep coming in, good and bad, but fewer and fewer of them go through my hands. It becomes easy to look at a problem and think it belongs to someone else: the manager, the coordinator, the team next door, the deadline that came from above.
Jocko Willink and Leif Babin's book is against that thought. Both were Navy SEAL officers and led Task Unit Bruiser in the battle of Ramadi, Iraq, in 2006. They later became leadership consultants for companies. Each chapter has three parts: a combat story, the principle it teaches and the same principle applied in a business.
This time, I went back to the book with one question in mind: what changes when my world, the one I answer for, becomes bigger than what I can see?
The book in three parts
The book has twelve chapters, split into three parts. The first is about the leader's mindset: owning everything, believing in the mission and checking the ego. The second brings the four laws of combat, which the authors say apply to any team under pressure. The third is about sustaining victory: planning, leading up and down the chain, deciding without all the information and discipline as a source of freedom.
I'll roughly follow that order, stopping at the ideas that spoke most to my day-to-day work.
The leader owns everything
The book opens with Jocko's worst day in Ramadi. In a confusing operation, with several units moving in the dark, groups of SEALs and Iraqi soldiers end up firing at each other. One Iraqi soldier is killed and others are wounded.
In the debrief that followed, there were plenty of possible culprits: whoever passed the wrong position over the radio, whoever didn't report that the plan had changed, whoever fired first. Jocko asks his team whose fault it was and hears each of them own their part. Then he answers that the only one to blame is him. He was the commander, he owned the plan, and everything that went wrong was in his world.
That is what the title means. The leader owns everything in their world: the plan, the communication, the training, and also the mistakes of the people below them. If someone didn't understand the mission, the mission wasn't explained well. If someone wasn't trained for the situation, training was missing. If the information didn't arrive, the path of that information was someone's responsibility, and that someone was the leader.
The effect is the opposite of what you'd expect. By taking all the blame, Jocko didn't lose his bosses' trust; he gained it. And the team, instead of defending itself, started looking for what each person could change. When the leader points outward, everyone learns to point outward. When they point at themselves, they make room for others to do the same.
In a technology team, that meeting has a name: the post-mortem. And the temptation is the same. The incident happened because the other team changed the API without warning, because the vendor went down, because the alert didn't fire. All of it may be true. But the useful question is a different one: what was in our world that we didn't do? Why did we depend on a warning that might not come? Why didn't we have an alert for this? The blameless post-mortem, which so many teams practice, is related to this idea: nobody points at anybody, and each part looks for what it can change.
There are no bad teams, only bad leaders
The story behind the second chapter's title comes from SEAL training, BUD/S. Trainees are split into crews of six or seven, each with a heavy rubber boat they carry on their heads and paddle in races along the beach. The winning crew rests during the next race. The losing crew runs again.
The boat weighs close to a hundred kilos. If one of the paddlers slacks off, the weight falls on the others, and everyone feels it right away. It's hard to imagine a place where teamwork is more visible.
For a week, boat crew II won almost every race and boat crew VI almost always came last. VI's leader blamed the crew, and the crew fought among themselves. So the instructors made a swap: only the leaders of the two boats changed places. Everything else stayed the same.
In the next race, boat crew VI won. And kept winning. Boat crew II, with the leader who used to be in VI, stayed competitive, because the crew had already learned to work together, but stopped dominating.
The same people, with the same boat and the same fatigue, got a different result. The difference was who led, and what that leader accepted or refused to accept.
The standard is what you tolerate
This chapter has the idea I liked most: when it comes to standards, what counts is not what the leader preaches, it's what they tolerate.
In a technology team, this is easy to recognize. Every team has a speech: quality matters, tests are mandatory, incidents get analyzed, delays get flagged before they happen. The real standard is something else. It's the untested pull request approved because things were tight. It's the post-mortem left for later. It's the delay nobody mentioned.
Every time the leader lets something slide, the team learns what the real standard is. Fixing the speech doesn't help. What changes the standard is to stop tolerating: go back to the pull request, schedule the post-mortem, talk about the delay. Preferably without drama, so it's clear this is the standard and not a scolding.
Believe, and check the ego
The next two chapters complete the first part. They are short to explain and hard to practice.
Believe. To lead, the leader has to believe in the mission. In the book, Jocko receives an order he doesn't like: take poorly trained Iraqi soldiers along on operations. His reaction, and his team's, is resistance. Until he asks himself why the order exists, and understands: the bigger goal was for the Iraqis to take over the security of their own country. With the why clear, he came to believe in it and was able to convince the team. When the leader doesn't believe, their job is not to pass the order along looking like they disagree. It's to ask up the chain until they understand, and, if it still makes no sense, to say so to whoever decided.
Every company has orders like that: the reorganization nobody asked for, the standard tool the team didn't choose, the priority that changed mid-quarter. The team notices right away whether the leader believes what they are saying. And a manager who passes on a decision saying "it came from above" is, without realizing it, saying they don't own it.
Check the ego. Ego gets in the way of everything: it keeps you from owning mistakes, from listening to the team and from accepting a better plan that isn't yours. The book shows how a string of successes can turn into carelessness: an overconfident team starts treating planning as a formality. Confidence is good up to the point where the team stops seeing its own risks. In technology, it's the team that has never had a serious incident and, because of that, thinks it doesn't need a rollback plan.
The four laws of combat
The second part is the most practical. These are four principles the authors call the laws of combat, and they work for any team that has to deliver under pressure.
Cover and move
In combat, one team moves while the other covers it, and then they swap. Neither moves alone, and neither wins if the other loses. The principle behind it is teamwork across teams: each part exists to help the other win.
The business example in the book is of one department that blamed another for delays, until it realized the company's result depended on both. In technology, this shows up all the time between product and platform teams, between development and operations, between the team that changes a contract and the team that consumes it. When each one defends only its own box, everyone loses together. When one team stops what it's doing to unblock another, the company moves forward. This connects with what I wrote about Team Topologies: how teams interact matters as much as what each one does alone.
Simple
Complex plans fail when things go wrong, and things always go wrong. If the team doesn't understand the plan, it can't execute it or adapt it. The book insists: orders must be simple, clear and concise, and each person must be able to explain them in their own words. If they can't, the problem is the plan, not the person.
In technology, the complex plan takes many forms. The roadmap with twenty priorities. The architecture only one person understands. The deploy process with fifteen manual steps. The OKR with so many key results nobody remembers any of them. The book's test is a good one: ask someone on the team to tell the plan in their own words. Whatever comes back is the real plan.
Prioritize and execute
Under fire, with many problems at once, the leader who tries to solve everything at the same time solves nothing. The book proposes a sequence: stay calm, look around, pick the most important problem and execute on it with everything. Then the next one. The authors sum it up as something like: relax, look around, make a call.
Anyone who has been in a big incident knows the scene. Five alerts going off, three channels asking for updates, someone suggesting restarting everything. The incident lead is not the one who fixes the most things: it's the one who decides which problem comes first, communicates that and shields the team from the rest. The same goes for a hard quarter: choosing the priority means saying what waits.
The book has a tip I find precious: the leader needs to step back from the front line to see the whole picture. If their hands are on the keyboard fixing the problem, they aren't seeing the others.
Decentralized command
Nobody can directly lead many people under pressure. The book talks about four to six people per leader. That's why teams are split into small groups, each with a leader who decides at their level. For this to work, each leader must understand the commander's intent: not only what to do, but why, and what success looks like. With clear intent, they decide on their own when the situation changes, without needing to ask.
This is the law that speaks most to the extra layer. If my intent doesn't reach the managers clearly, they'll have to ask me everything, and I become the bottleneck. If it does, they decide, the coordinators decide and the team decides. It's the same idea I took from Bernardinho about getting the form wrong, never the intention: intent is what has to survive the layers.
Decentralized command has an important limit: each leader decides within the intent, not outside it. And they must keep the level above informed, so the whole stays coherent.
Leading up and down the chain
The third part has a chapter that changed how I think about the relationship with the people above me. Leading down the chain is the obvious part: explaining the mission, giving context, training. Leading up is less obvious: if the boss doesn't give the team what it needs, be it a decision, a resource or context, the responsibility for explaining better lies with whoever needs it. Complaining that the boss doesn't understand is outsourcing the blame upward.
Down the chain, the lesson is about context. People at the front don't see what the leader sees. If the team thinks a decision is absurd, it probably lacks information the leader has. The leader's job is to give that information, not to expect the team to trust them in the dark.
Reading this as a leader of managers, the most uncomfortable part is that the reasoning doesn't stop at the first level. If a team is doing badly, the manager owns that. But the manager is in my world. So I own it too. That changes the questions I ask myself when facing a problem. Instead of "what did this manager do wrong?", it becomes:
- Did I explain the mission? If the manager didn't understand why that delivery mattered, they couldn't pass it on to the team.
- Do I believe in it? If I passed on a decision without believing in it, the manager noticed, and so did the team.
- Did I train for this? If the manager didn't know how to run a hard conversation, or had no way to see the problem in time, that's training and context, and both are mine.
- Did I tolerate it? If the problem had been showing up and I let it slide, that was the standard I taught.
These questions don't take responsibility away from the manager. The book is clear: every leader, at every level, owns their entire world. They just keep the conversation from ending with them.
Plan
The third part opens with a chapter on planning, and it's the most methodical in the book. Before each operation, the team follows the same path: understand the mission and the intent, analyze the terrain and the resources, let the leaders of each group plan their part, think about what could go wrong and what to do if it does, brief everyone on the plan in a simple way, execute and, at the end, sit down for the debrief.
Two details caught my attention.
The first is that the leader doesn't make the plan alone. They set the mission and the intent, and the leaders below them plan the parts. That makes each one own their piece, and it makes the plan better, because the people who will execute know risks the leader doesn't see. In technology, it's the difference between the architect who designs everything and hands it over finished, and the team that writes its own RFC starting from a well-explained problem.
The second is the debrief. After each operation, good or bad, the team sits down and asks what worked, what didn't and what changes next time. That's what closes the cycle and makes the next plan better. Many technology teams only do this after incidents. The book suggests doing it after every delivery: a launch that went well also has something to teach.
There's one more practice I like to pair with this: the pre-mortem. Before starting, the team imagines the project has failed and asks why. It's a way of thinking about contingencies without it sounding like pessimism, and it fits well with what the book calls planning for what could go wrong.
Deciding without certainty, and the discipline that frees
The last two chapters close the book with two ideas that seem opposed.
Deciding without certainty. There's never complete information. The leader who waits for certainty to decide misses the moment, and not deciding is also a decision. The book argues for deciding with what you have, watching the result and adjusting. In technology, this recalls the difference between one-way and two-way door decisions. Most decisions can be reversed: a library, a screen layout, the order of the backlog. Treating them as irreversible only slows the team down. Few are hard to undo: the database of a core system, a public API contract, the way teams are split. Those deserve more time and more people in the conversation.
The leader's role here is to say which kind of decision the team is facing. A lot of delay comes from treating everything as if it were the second kind.
Discipline equals freedom. It sounds contradictory, but the book shows that teams with more discipline have more freedom. Well-drilled procedures free the mind for the unexpected. In software, it's the automated pipeline that lets you deploy several times a day without fear, the tests that let you refactor with confidence, the runbook that lets anyone on call act without waking up whoever wrote the system.
What ownership is not
It's possible to read the book the wrong way, and I think it's worth saying how.
It's not doing everything yourself. Owning the result doesn't mean taking the work back. If I start solving the problems of my managers' teams, they stop owning anything, and I go back to being the bottleneck that the extra layer was supposed to remove. Decentralized command is exactly the opposite of that.
It's not self-flagellation. Taking the blame, in the book, is the start of the conversation, not the end. Jocko owns it and, in the same meeting, presents what will change. Ownership without a correction plan is just an apology.
It's not being tough all the time. The authors themselves wrote a second book, The Dichotomy of Leadership, about the balance the first one leaves implicit: every leadership quality taken to the extreme becomes a flaw. Too much ownership turns into micromanagement; too little turns into outsourcing the blame. Too much discipline turns into rigidity; too little turns into chaos. The leader's job is finding the right point in each situation.
Bringing it into daily work
Reading the book is the easy part. The hard part is turning the ideas into habits that survive a busy week. These are the tools I'm putting together to practice, based on what the book proposes.
Written intent. For every important decision I delegate, I want it to fit in a short block: the goal, the why, what success is, what must not happen and how far the person can decide alone. If I can't write that, I don't yet know what I'm asking for.
Ownership questions in 1:1s. Instead of asking a manager what went wrong, ask what was in their world and what they will change. And ask myself the same questions before the conversation: what was in my world?
A debrief after every delivery. Not only after incidents. Fifteen minutes, three questions: what worked, what didn't, what changes next time.
One standard at a time. Pick one thing the team says it does and doesn't, and stop tolerating it. Just one, until it becomes a habit, before moving to the next.
For Monday
- Change the question. At a team's next problem, before asking what went wrong there, ask what was in your world: the explanation, the training, the context.
- Look at what you tolerate. Pick a rule the team says it follows and check whether it holds in practice. If it doesn't, the next time you let it slide is the one that sets the standard.
- Test the plan. Ask someone on the team to tell you, in their own words, what the quarter's priority is. If the answer doesn't match, simplify.
- Write the intent. For the next decision you delegate, say the why and what success is, not just what to do.
- Own it and bring the plan. When something goes wrong in your world, say it's yours and, in the same conversation, what will change.
Closing
Boat crew VI didn't get better paddlers. It got someone who wouldn't accept losing and who made the crew believe they could win. With one more layer, my boat got bigger and I paddle less. But the reasoning is the same: if the result isn't good, the first question is about me. And the second is what I'm going to change.
Sources
- Extreme Ownership: How U.S. Navy SEALs Lead and Win, Jocko Willink and Leif Babin, St. Martin's Press, 2015
- The Dichotomy of Leadership, Jocko Willink and Leif Babin, St. Martin's Press, 2018
Did you like this article?
Comments
No comments yet. How about being the first?