Eating the Loss
The fifth untaught skill, and the first one that isn’t about your own judgment at all. It’s about what you’ll absorb on behalf of someone else. In a workplace where software has made blame precise, instant, and free, the rarest thing a human can do is stand between that precision and the people it would otherwise grind down. This is the long-form companion to the fifth piece in the series.
The earlier four: getting fired three times before I learned to think like a leader; almost getting fired again over the second skill; the $1.4M decision I got wrong in front of the board; and the fourth, on keeping custody of the calls a machine can’t be trusted to own. You can read this one cold. It lands harder with the others behind it.
9:06 on a Thursday. The quarterly review. Coffee going cold in identical white cups, because someone in facilities had decided personality was a fire risk.
On the screen: a supplier transition that had slipped its window. The slip had cost us seven hundred and forty thousand dollars in committed spend we couldn’t claw back. And next to the red number, in the new analytics suite the company had spent a fortune on that year, sat a contribution breakdown. The system had done its job beautifully. It had traced the slip to a missed dependency, and the missed dependency to an owner, and the owner had a name.
The name was Maya’s. She was twenty-six. She was sitting three feet to my left, and I watched her go very still in the particular way people go still when they’re trying very hard not to be seen.
A board member I’ll call Marcus — some of you met him in the second piece in this series, the one whose single question took me six months to recover from — looked at the slide, then looked along the table, and asked the question those rooms always ask now that the software can answer it. “Whose was this?”
The honest answer was complicated. Yes, Maya had owned the transition. Yes, she’d missed the dependency. But I had set the timeline, and the timeline was impossible, and I had told her to trust the vendor’s delivery date against my own gut, and she had flagged the risk in week two and I had overruled her because I wanted the quarter to look a certain way. The software couldn’t see any of that. The software saw an owner and a number. Precise. Clean. Wrong in the exact way that only technically-correct things can be wrong.
I had about ninety seconds. What I did with them is the skill no one ever taught me, and it turned out to matter more than the four that came before it.
The fog is gone
Something has changed in the last few years, and we are mostly pretending it hasn’t.
It used to be genuinely hard to assign blame precisely. A miss was a fog. By the time anyone had untangled who-decided-what-and-when, the moment had passed, the team had moved on, and the fog was, in its quiet way, merciful. It protected people from the full, itemised, time-stamped consequences of being human at work. You could fail and recover inside the same week, before the failure had hardened into a record.
The fog has lifted, and it isn’t coming back. Every decision now leaves a fingerprint. The dashboard knows whose forecast slipped, whose ticket aged, whose call moved the number the wrong way. Attribution, the thing that used to take a forensic week and a reluctant analyst, is now a hover-state. It costs nothing. And because it costs nothing, it’s everywhere, and because it’s everywhere, the reflex in every review room has quietly hardened into the same shape: find the name.
AI didn’t invent blame. It made it precise — and precise blame is the cheapest, most corrosive thing in any company.
This is the new failure mode of management, and almost nobody is naming it, because it doesn’t look like a failure. It looks like accountability. It looks responsible and modern and data-driven. A number went wrong, the system found whose it was, justice is served, next slide. Everyone in the room keeps their hands clean except the one person whose name was in the cell.
And the manager who lets that happen — who looks down the table, follows the software’s pointing finger, and says “well, that was Maya’s area” — that manager believes he has just demonstrated rigour. What he has actually demonstrated, to every person in that room and every person they will later tell, is precisely how much cover they can expect from him on the day it is their name on the slide. None. The answer is none, and they will file that away, and they will be right to.
A manager who only manages up is just a blame router with a nicer office.
Eating the loss
Here’s the phrase I use for the alternative. Eating the loss.
It means standing up, in the room, while the stakes are live and the number is red and your own standing is on the line, and taking the hit the software wants to hand to someone smaller than you. Not deflecting it. Not “adding context” until it dissolves. Eating it. Putting your name where the system put theirs, out loud, before the room has finished forming its opinion.
What I said to Marcus was close to this. “That’s my number. I set the timeline, I told the team to trust the vendor’s date over our own read, and Maya raised the dependency risk in week two and I overruled her. The software’s got the wrong owner. If you want a name on this, it’s mine.”
It cost me, and I want to be precise about that, because the version of this story where eating the loss is free and noble and instantly rewarded is a fairy tale, and you have read enough of those. It cost me a chunk of board confidence I had spent two years assembling. It cost me most of a bonus. Marcus did not say “how admirable.” Marcus made a note, and the note was not flattering, and I felt the weight of it for the rest of that year.
What it bought, I couldn’t see for months. That is the trouble with this skill and the reason it is so rare. The cost is immediate and itemised and lands on you alone. The return is delayed, diffuse, and unmeasurable, which is exactly why the software will never recommend it and the spreadsheet will never reward it. You are choosing a certain present cost against an uncertain future return that no model in your company is built to price. Of course it’s rare. The surprising thing is that anyone does it at all.
The org chart says who reports to whom. Who eats the loss says who actually leads.
Why blame cultures quietly lose
I used to think eating the loss was simply the decent thing, a question of character, the sort of trait you either had or didn’t. I now think that’s only half of it, and the softer half. The harder half is that blame, as an operating system, makes organisations measurably worse, and there is a whole body of work showing how.
Start with the oldest piece of it. Social psychologists have a name for the thing that boardroom was doing to Maya: the fundamental attribution error. When something goes wrong, human beings reliably over-attribute the cause to the character of the nearest individual and under-attribute it to the situation that individual was standing in. We see a missed dependency and think careless person. We almost never see the impossible timeline, the overruled warning, the structural pressure that made the error close to inevitable for whoever happened to be holding it. The new analytics suites don’t correct this bias. They industrialise it. They put a name in a cell and call the situation noise.
W. Edwards Deming, who arguably understood organisations better than anyone of his century, used to argue that the overwhelming majority of what goes wrong in a company belongs to the system, not the worker — he put the figure somewhere around ninety-four percent to the system and the remainder to the individual. You can quibble with the exact number. The instinct behind it is the one that matters: when you punish the person for what was really a property of the system, you don’t fix the system, you just teach everyone to hide the next error until it’s too big to hide. Blame doesn’t reduce mistakes. It reduces the reporting of mistakes, which is a far more dangerous thing, because now they grow in the dark.
The safety world learned this the hard way and built a discipline around it. Sidney Dekker’s work on what’s called just culture in aviation and medicine makes the case plainly: when an industry responds to error by hunting culprits, people stop disclosing, near-misses go unreported, and the organisation goes blind to its own risks right up until one of them kills someone. The industries that got safer did it by deliberately separating the question “what is broken” from the question “who do we punish,” and refusing to let the second contaminate the first.
And on the upside, Amy Edmondson’s research out of Harvard on psychological safety spent decades establishing what good managers feel in their bones: the teams that perform best are not the ones that make the fewest mistakes, but the ones where people feel safe enough to surface mistakes early, while they’re still small and cheap. You cannot have that safety under a manager who feeds his people to the software the moment the number turns red. The two things cannot coexist in the same room.
Blame is a confession that you’d rather find a culprit than fix a cause.
So eating the loss is not only decent. It is the price of admission to having a team that tells you the truth. The manager who eats losses gets early warnings. The manager who assigns them gets silence, then surprises. One of those is a much worse way to run anything.
You are the umbrella
Most people think a manager’s job, when things go wrong, is to assign blame accurately. To be a fair and impartial judge of whose fault it was.
That is a referee’s job. It is not a leader’s job, and the confusion between the two is why so many genuinely competent people spend whole careers being respected and never once being followed.
The leader’s job, when the storm comes, is to be the umbrella.
The rain still falls. The loss is still real, the money is still gone, the lesson still has to be learned by someone. Being the umbrella does not mean pretending the weather is fine, and it does not mean the person under it never gets wet. It means standing so the people you’re responsible for don’t take the full force of a storm they couldn’t have stopped, when you — with your title, your standing, your seat at the table — can take it and stay upright.
Here is the part the cynics miss, the part that makes this hard-nosed rather than sentimental. The umbrella isn’t charity. It is the only mechanism anyone has ever found for building the kind of team that runs through walls for them. You cannot earn that in the good quarters. Loyalty does not mint in good weather, because good weather costs the manager nothing to stand in, and everybody knows it. It is only in the bad quarter, the red number, the named slide, that anyone learns what you’re actually made of.
You can’t build loyalty in the good quarters. It’s only ever minted in the bad ones.
The day you eat a loss the software had pinned on someone else, you don’t only protect one person. You broadcast, to the whole room, what kind of weather they can expect to work in for as long as they work for you. People will turn down a twenty-percent raise to stay under that umbrella. I have watched them do exactly that. I have been the reason they stayed, once or twice. I have also been the reason they left, which is the next part, and the part I would rather skip.
The three managers in every bad meeting
There aren’t two kinds of manager in a room when the number goes red. There are three, and the failure modes sit on either side of the thing you actually want.
The blame router points. He follows the software’s finger, names the owner, keeps his own hands clean, and mistakes this for accountability. He is the most common and the most quietly destructive, because his behaviour is indistinguishable from “rigour” on any given day. You only see what he is over time, in the slow exodus of everyone good enough to have options.
The martyr eats everything. Every loss, every miss, every error, regardless of whose it really was or whether the person needed to feel its weight to grow. This looks like the opposite of the router, but it’s a failure too, and a sneaky one, because it wears the costume of nobility. The martyr trains his people to stop owning anything, robs them of the consequences they need, and reads, to the board, as a manager who simply cannot run a tight shop. He is avoiding the harder thing, which is letting someone he cares about feel the appropriate weight of a real mistake.
The umbrella is selective, and the selectivity is the entire skill. He signs off fast and without drama on the losses that belong to the system or to him. He hands back, with support, the ones a person genuinely needs to own. And he spends his scarce, expensive standing eating the specific losses where the public cost to a good person wildly outruns the lesson. Most days he looks exactly like everyone else. The difference only shows on the Thursday.
If you take one thing from this piece, take the shape of that middle path, because both ditches are deep and both are easy to fall into while feeling virtuous.
The one I didn’t eat
I have not always been the umbrella. I want to tell you about the time I was the router, because the version of me that wrote the first four pieces in this series would have left this out, and that version of me is exactly who this skill is meant to correct.
Years before Maya, a different company, a project I was nominally senior on went sideways in a way that became visible in a single bad meeting. A quieter colleague had made the decision that was, narrowly, the proximate cause of the mess. When the room turned to find the reason, I let his decision carry the weight. I didn’t lie. Every word I said in that meeting was true. I simply declined to add the one true thing that mattered, which was that I had seen the risk weeks earlier and said nothing, because saying nothing had been more convenient and the deadline had been loud. I let “accurate” do the work that “honest” should have been doing, and I told myself there was a difference.
He left within the quarter. He was good — better than I understood at the time. He went somewhere that deserved him less than we had. And the thing I remember, the thing that still lands when I’m not careful, is not that he was angry. He wasn’t. It’s that he wasn’t surprised. He had already worked out what kind of manager I was, some meeting or other I don’t even remember, and the day I confirmed it was, for him, just the day the data came in. I was the last person in the building to learn what I was. He’d known for months.
That is the cost of the skill you don’t have. It never appears as a red number in any review. It shows up as the slow, silent, entirely deniable departure of every person who was quietly watching to see whether you would cover them, and concluded, correctly, that you would not. You will never be able to attribute those exits to their real cause, because the real cause doesn’t leave a fingerprint. The software that found Maya in nine seconds will never find this. It is the most expensive thing you will ever do to a team and the one thing no dashboard will ever bill you for.
When to eat it, and when to hand it back
“Be the umbrella” is useless without a way to tell, at 9:06 on a Thursday with the room waiting, which losses are yours to eat and which belong to the person who made them. Eating all of them makes you the martyr. Eating none makes you the router. So here is the actual filter, the one I can run under pressure.
Eat it when you shaped the conditions. If you set the timeline, approved the plan, rushed the hire, or overruled the warning, then the proximate error was downstream of a decision that was yours. The software’s attribution is technically right and substantively wrong, and correcting that record is not generosity. It is accuracy. It is usually, if you’re honest, the truer account.
Eat it when the person couldn’t reasonably have prevented it. Genuine bad luck, a hidden dependency no diligence would have surfaced, a system that was an accident waiting for an owner. Punishing someone for standing in the wrong place when the structure failed is the fundamental attribution error wearing a manager’s badge.
Eat it when the public cost dwarfs the lesson. Sometimes the mistake is theirs, but the value of them feeling it in front of the board is near zero, and the damage of being named there is enormous. Take it in the room. Teach it in private. The lesson does not require an audience. The humiliation is pure deadweight loss.
And the inverse, said plainly so you don’t drift into martyrdom: hand it back, with support, when the mistake is genuinely theirs, the stakes are survivable, and the weight is the thing that will make them better. Protect people from storms they didn’t make. Do not protect them from the weather they need to learn to read. An umbrella held over someone every single day doesn’t keep them dry. It keeps them from ever learning that it rains.
The umbrella is for the storms they didn’t make. It is not for teaching them to check the forecast.
Why this is the skill that pays now
Run the series forward in your head. Clarity in chaos. Conviction. Recovering from being wrong. Keeping custody of the call. Every one of those is something you do with your own judgment, for your own outcomes. This skill is the first that is entirely about what you will absorb on behalf of someone else, and that difference is the whole reason it’s about to outrank the rest.
Because a machine can now do an astonishing amount. It forecasts, decides, drafts, analyses, attributes, and it improves at all of it monthly. There is one thing it structurally cannot do, and the gap is not closing, and it never will. It cannot take a hit. It has no reputation to spend, no standing to risk, no skin to put between a junior and a board. When the number turns red, the model cannot rise in the room and say “that one’s on me.” It can only point. Pointing is the one move it’s getting better at every quarter.
A model can take the credit. It can’t take the hit. That’s the whole difference, and it’s becoming your whole job.
Now picture the workplace we are actually walking into. Total attribution. Every error instantly, precisely, permanently owned. A culture where the software points and the cowards follow its finger because following the finger is free and standing in front of it is not. In that world, the scarcest and most valuable thing a human being can be is the one who stands between the precision of the machine and the people it would otherwise reduce to a red cell. The safe harbour. The umbrella. That person cannot be automated, not because the task is hard, but because the entire value of what they do lives in the fact that they personally chose to absorb a cost they were under no obligation to absorb. Strip out the choice and the cost and there is nothing left to automate.
That is why they keep you. Not for the calls you get right — the machine will match you on those and then beat you. They keep you for the losses you were willing to eat, because that is the one column on the ledger the machine can never fill in.
The reps
None of this transfers by agreeing with it. Here is how you build it before the Thursday that tests it.
Rep one — eat it in public, fix it in private. Take the hit in the room, where the audience is, where the protection is visible and therefore worth something. Then hold the real, hard, developmental conversation behind a closed door, where it can land without shame and without spectators. Never the reverse. The manager who is warm in private and throws you to the wolves in public has taught you that his kindness is worthless precisely when it would have cost him something, which is the only time kindness counts.
Rep two — locate the failure at your own altitude, and mean it. Don’t perform martyrdom; find the part that was genuinely yours, because there nearly always is one and it is usually the real cause. The timeline you set. The risk you waved through. The hire you rushed. “I greenlit this” is almost always a truer sentence than the software’s clean attribution, because the software cannot see the decision two levels up that made the error close to inevitable for whoever inherited it.
Rep three — never eat a loss you can’t convert. Absorbing blame with nothing attached is theatre, and people can smell theatre across a room. Eating the loss has to arrive with the next sentence already loaded: here is the specific thing we change so this can’t recur. Take the hit, then immediately spend the standing it cost you on a visible repair. That is the alchemy that turns a loss into authority instead of into a stain you carry.
Rep four — say it before you’ve finished calculating whether it helps you. This is the one that cannot be faked, and the room reads it instantly. If you pause to compute the political return on eating a loss, everyone feels the pause, and the gesture curdles into strategy in real time. The credibility is in the speed. You stand up fast, before the part of your brain that runs cost-benefit has finished its sum, because the entire meaning of the act is that you’d do it even if the sum came out against you.
Rep five — protect the person, interrogate the system. When you eat the loss, point the room’s attention not at “who” but at “what.” “The process let this through, and the process was mine to design.” This is just culture in a single move: you have separated the human from the failure, taken ownership of the structure, and turned a blame hunt into a system fix without anyone quite noticing you did it.
Rep six — keep a private ledger of the losses you ate. Not to collect credit. To check which manager you’re becoming. If the ledger is empty, you’re a router and you’ve been calling it discipline. If it’s overflowing and indiscriminate, you’re a martyr and you’ve been calling it care. The umbrella’s ledger is short, deliberate, and made of the few specific storms where standing in the rain was the right and costly call. If you can’t remember the last loss you ate, that’s not a clean record. That’s drift.
Don’t build a culture that manufactures crumple zones
There’s a way to get this exactly wrong at the level of a whole organisation, and well-meaning leaders walk straight into it, so it’s worth naming.
The researcher Madeleine Clare Elish described something she called the moral crumple zone: when an automated system fails, blame tends to collapse onto whatever human happened to be nearest the controls, even when that human had no real power to change the outcome. They become the soft body that absorbs the impact so the system’s reputation survives.
Companies do a version of this on purpose without realising it. They want to “keep a human accountable,” so they put a junior on the approve button, give them no authority to actually say no, no time to interrogate the output, and no cover when the confident answer turns out to be the catastrophic six percent. Then they call that arrangement governance, and when it breaks, the junior is the name in the post-mortem. That is not eating the loss. That is institutionalising a scapegoat and budgeting for it.
Eating the loss as a culture means the opposite. It means accountability flows up to where the real authority sat, not down to where the last click happened. It means the person with the power to say no is the person whose name is on it when no should have been said. A team only learns to surface errors early, the way Edmondson’s safest teams do, when they have watched, more than once, the loss roll uphill to someone who could actually have prevented it. You teach that by doing it in front of them. There is no other curriculum.
What I actually did, and what it cost
Back to that Thursday. 9:06. The cold coffee, the red number, Maya going still, Marcus and the question the software had finally made cheap to ask.
I told him it was mine. I gave him the timeline I’d set and the warning I’d overruled, and I put my name where the system had put hers, and I did it fast, before I’d worked out whether it would help me, because I’d learned by then that the working-out is the thing that ruins it.
It cost what I said it cost. The bonus. A measurable cooling in how Marcus looked at me for a year. A note in a file somewhere that I have never seen and have thought about more than I’d like to admit. I am not going to pretend the market rewarded the virtue on the spot. It didn’t. The market mostly doesn’t.
But Maya stayed. That part I can tell you for certain. She got better fast, the way people do when they’re handed the room to instead of the blame for, and the dependency she missed at twenty-six is the first thing she now checks on every project she runs. She’s senior now, somewhere good. And about a year ago she mentioned, almost in passing, that she’d recently stood up in a review of her own and taken a hit the software had handed to one of her people. She didn’t say she’d learned it from that Thursday. She didn’t have to. Some lessons you only ever teach by standing in the rain where someone can see you.
Anyone can find the name on the slide. They keep you for being the one who covers it.
The room, again
The machines will get better at finding the name. That’s certain. The rooms will get faster at following the finger, because the finger is free and getting freer. Every quarter, somewhere, there will be a red number and a still, young person three feet away, hoping that someone bigger will stand up first.
Be the one who stands up.
That’s the skill. No college teaches it. No model will ever have it, because the thing that gives it value is the one thing a model can’t possess: a reputation it chose to risk for someone who couldn’t have asked. In a workplace where blame has become precise, instant, and free, it might be the last thing that makes a human genuinely, unautomatable worth keeping.
This is part five of a series on the skills no one teaches you and AI can’t replace. If it was useful, the two I’d send you to next are the third — how being wrong in front of the board became a promotion — and the fourth, on keeping custody of the calls a machine can’t be trusted to own. There’s a sharper, shorter version of this on Medium, more on the blog, and if the writing earns it, you can keep me doing it at ko-fi.com/AFulcrum.