When a team discovers that their carefully engineered AI product performs worse than the plain model underneath it, the instinct is to upgrade to a more expensive model.

Yet the product probably isn’t underperforming because the model is bad. It’s underperforming because someone stuffed the desk or shouted too many instructions. Those are two different problems — and I know because I caused both.

My first encounter started when I built an agent to scan the news. Setting it up meant briefing the agent the way you’d brief a sharp new hire who happens to know nothing about you. I gave it my preferences, the angles I care about, the stories to skip. By the time I finished I’d handed it about nine pages of instructions.

As the pages stacked up, I hit a wall: the information was all there, but when I asked the agent to do something with it — pull a particular subset of articles, say — it would quietly skip or omit results.

My AI was overwhelmed and confused, and I had caused both.

Piling the information on

A widely known principle of working with AI over the past few years is that AIs have a fixed attention budget — a context window — and every token draws it down. While this originally applied in the sense of ‘reduce long chat windows’, a whole discipline of curating what a model sees in a multi-threaded agentic interaction has arisen: context engineering.

When an AI’s attention budget runs out, there’s a name for the particular way it loses the plot, “lost in the middle.” The model prioritizes what sits at the beginning and end of the window, the way your eye slides down a contract to find the signature line. What sits in the center gets skimmed or skipped entirely.

Picture a mid-career white-collar worker in grey slacks and suspenders and horn-rimmed glasses, sitting behind a desk. The worker is the AI, and they look up as you walk in with a stack of books. You are working on an important project, you tell him, and you stack ream after ream on the desk until it’s holding the weight of a small library.

Now you ask the worker to keep all of that in mind while helping you on your project.

What struck me about this is that the AI suffers a very human-like response. It starts forgetting. Intuitively, this shouldn’t happen: an AI has theoretically unlimited potential to store and recall data. Practically, it’s a function of space and reasoning constraints that limit the model. The desk has edges.

That describes the attention budget, but the interesting thing is expanding the desk (upgrading to a bigger model) doesn’t resolve the issue. More desk space without curation is like a teenager’s room — it doesn’t matter how big the room is; the mess fills to the size of the room.

There’s a bill attached to the mess, and it’s easy to miss. In a single chat, you pay for that context once. In an agentic loop, you pay for it on every turn — the model re-reads your instructions from scratch. My nine pages, on a twenty-step run, were a hundred and eighty pages — re-read and re-billed, in service of results the agent was quietly dropping anyway. And the upgrade path makes that worse before it makes it better: a more expensive model raises the per-token price of exactly the material you should have deleted.

Shouting at the help

Context overload is relatively well understood by now, at least among builders. The second failure I encountered receives less attention, and it may be more costly. This was a failure of rules.

In my nine pages of information, I had structured, with good intention, a number of guidelines for the model to follow. Prioritize your search by XYZ sources. Search only for articles in the trailing 90 days. Do this instead if you encounter topics that aren’t bounded by the core search areas. And so on.

Go back to the worker behind the desk, and take off the stack of books. Instead, you tell the assistant you have 20 instructions you need him to follow: run every search two times for accuracy, double check references, filter out references if they return certain parameters, draft an original memo, be brief, be formal, adapt it to the standard company format, and do all of it while dancing on one foot.

Now the person hasn’t lost a document — the desk has no books in this example — only a set of rules. But as the rules become more complex, the person begins to lose their judgment. They quietly work towards what they perceive as the loudest rules — always do this, never do that — at the expense of overlooking softer ones. Or they create eloquent output that satisfies all conditions while failing to land the objective: a nice-looking memo that does nothing to advance the project.

When Arize AI benchmarked instruction-following across frontier models this year, they found that even the best systems held steady and then fell off a cliff. Past a few hundred simultaneous constraints, models start dropping instructions they were meant to follow. (Interestingly, they don’t ease into it. They hold, then turn erratic, quietly favoring whichever instructions came first.) MindStudio documented a related failure they call “instruction interference”: tell a model to “be concise” in one section and “always explain your reasoning fully” in another, and it resolves the ambiguity differently every time. The behavior looks inconsistent, but the inconsistency is coming from the instructions themselves.

Here, as with desk stuffing, a bigger model doesn’t solve the underlying problem. When there are too many rules being shouted at the AI, an upgraded model with stronger reasoning is a magnet for more of the same mis-use, if un-curated. Even a more capable worker can’t take direction from fifteen managers at once.

The takeaway for your team

A system can drown in context or drown in rules, and what moves the needle on production AI is knowing what to leave out. Georgia O’Keeffe, talking about paint, put it plainly: we reach the meaning of a thing “by selection, by elimination, by emphasis.”

That’s the true meaning behind context engineering, and it’s fundamentally an architecture problem. With the spread of AI beyond engineering teams, understanding the solution is more important than ever.

When context is the overload, you cut it back and reorder it, with the load-bearing facts at the front and end where the model genuinely reads them. When it’s the rules, you thin them, settle the contradictions, and be ruthless about which behaviors matter versus which ones you bolted on because something embarrassing happened once.

A bigger, more expensive model gives you two things: a larger context window and stronger reasoning. But neither solves the problem of unstructured, unruly context and a spaghetti of competing rules.

For someone running a product or a business, curating context and pruning rules requires similar judgment to prioritizing a roadmap: deciding what’s essential and dropping the rest. And the teams that come out ahead won’t be the ones spending the most on the latest models. They’ll be the ones willing to leave things out.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

Traditionally, the ability to discern and evaluate another person’s judgment was the hallmark of a good leader. Yet the twin obsessions of the last decade — the builder mindset and organizational flattening — have made the skill rare. I’ve argued before that executives get the middle management they deserve: companies flattened their management layers because so much of that management was low-value work that deserved to go.

This is the other side of that coin. Management that was worth keeping was worth keeping because they were good at understanding people.

I made the point last week that AI is turning product managers from builders into operators. Managing a team of builders in the past gave rise to a specific category of ineffective management: the artifact-inspector. The PM builder produced an artifact — a spec, a launch, a feature — and managers could look at it and judge it. The manager read that and believed he had thereby read you. Reviews and checklists existed to make that job possible; the work arrived as objects, and objects can be examined. Once the objects could be examined without him, the layer collapsed, correctly.

Managing an operator offers no such object to assess. The work is never finished, so there’s nothing to inspect. What you’re assessing instead is a person’s attention over time, because the real failure of someone operating an agent isn’t a bad deliverable. It’s observation fatigue: not noticing that the waves have changed direction and the storm clouds are gathering.

That puts the pressure back on the oldest leadership skill there is. “Is this a good PRD” gives way to “is this person calibrating the system well” — reading the right signals, tuning the right things, catching drift early. It’s judgment about someone else’s judgment, and you have to get close to the work to see it.

Here is the new danger — people use tools they are familiar with, and this can give rise to the same inefficient manager, wearing a new costume. Leaders who came up in the flat-org years, and who now spend their days operating agents, reach for the techniques that work on agents and aim them at people.

Picture the manager this produces. Their days are spent operating: the model misbehaves, they re-prompt it; the output drifts, they retune it; the pipeline stalls, they rewire it. Fast, iterative, effective — the correct relationship to a machine.

But then a strong performer on their team goes quiet. The manager does what the tools trained them to do: treat the silence like a line stoppage and get things moving again. More structure, a tighter check-in, a pointed note about the missed signal, a re-prompt aimed at a person. Six weeks later the person on their team is interviewing elsewhere, and the manager is genuinely puzzled. Their attempted fix was only correct for an agent, not for the human on their team.

Here’s the core reason. A lot is being said about product teams managing autonomous agents, and thus acting like managers. But a lot is riding on the term ‘autonomy’ in this sense. An agent has autonomy of execution: it plans its own steps, picks its tools, retries when it fails. What it doesn’t have is autonomy of will — a preference of its own about where it should go. A person has autonomy of will. If you hand a person a goal, they can disagree, disengage, or leave. Agents can’t. That’s exactly why while you can operate the agent, you must lead the person.

To expand the ship building analogy of the product operator: the people on your team should be experts at operating the ship. But you cannot operate the crew.

Look closely and the two bad managers are the same type. The builder-turned-manager judged you by your artifact and thought the deliverable was you. The operator-turned-manager debugs you like a system and thinks the correction is leadership. Different tools, one mistake: taking the person for the instrument you already know how to handle. But a person is neither an artifact nor an agent. What makes them their own category is the will, the very thing that neither the PRD nor the AI agent has. That’s why flattening was right to cut the artifact-inspector, and why it would be a mistake to rebuild her in a new costume. Same hollow management, new tool.

The leader worth retaining is the one who anchors on a skill that hasn’t changed: reading the person. AI raises the value of that skill precisely by automating everything around it. You can walk away from something you built. You cannot walk away from something you operate. And you cannot walk away from the people doing the operating — which is why the scarcest role left is the one who keeps a room of operators sharp, motivated, and unwilling to leave, and who knows the difference between the machine and the person running it.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

Product management has long relied on running loops: build, ship, measure, iterate. PMs scoped a feature, shipped it, watched the numbers, evaluated what to build next. The key assumption in that loop was that the feature largely sat still: if you built an onboarding page, that page was the same two weeks later. If something upstream broke, it broke loudly — an error, a crash, a support queue lighting up. You went and fixed it. The work was a sequence of finished things, each handed off before the next began.

An agent doesn’t sit still.

If your product team was in the business of building metaphorical wooden toy ships, the AI agent is the equivalent of taking those ships out of the dry dock and launching them in the water, headed toward an open sea with constantly surging waves and uncertain weather. A ship cruising on a calm day might encounter a raging storm the next.

The core mission of the product team for the past several decades was to build. Build and ship. Ship, then build the next feature, and so it went. Yet building and operating are different relationships to the work. Operating means keeping a hand on the wheel: the ship is structurally complete, but without someone at the helm you can’t be sure it will survive.

And so AI is dragging the product manager’s job from the builder’s relationship toward the operator’s, because what you ship keeps running and keeps drifting.

The moment your team ships an AI agent, everything around it keeps moving. Customers ask it things no test anticipated: new intents, new edge cases, questions about a product line that became outdated last month and that nobody recalibrated it for. The model underneath it changes without asking you; the provider updates it quietly, and a thing that behaved one way on launch day behaves another way a month later, untouched by your hand. And every new capability you add doesn’t sit politely beside the old ones. It changes how the whole system behaves, because the parts interact.

What’s worse, agents fail quietly.

Deterministic software fails loudly. It throws an error, falls over in a way that trips an alarm and points at the line that broke. An agent degrades quietly. It keeps returning fluent, confident, plausible answers that are slowly getting worse, and every infrastructure light stays green while it does: latency fine, uptime fine, cost fine.

Instead of ship-and-measure and the occasional point-in-time feedback loop, the job becomes continuous evaluation. You don’t evaluate the agent once and move on. You watch it, because it will drift, and it will not tell you.

A team ships an external customer-support agent, the thing that reads an incoming ticket and answers it without a human. Launch day, it resolves sixty percent of tickets on its own. The demo is clean, the metrics are green, the deck goes up. The PM who built it proudly declares it done and moves to the next feature.

Six weeks later the dashboard still says sixty percent resolved. But the rate at which a human has to reopen a ticket the agent “resolved” and quietly redo it has doubled. Customers are getting confident, wrong answers about the product line that shipped last month, which no one had recontextualized the agent for.

You could object that none of this is new. Support teams have watched these systems for years, and the old rule-based bots failed too. True — but they failed the way machines fail. Something broke, in a specific place, for a traceable reason, and the same input failed the same way every time until you fixed it. An AI agent doesn’t fail the same way every time. There is no obvious break; the quality just thins, unevenly and quietly, for reasons that don’t resolve to a line someone can go find. The old systems failed like a snapped cable. These drift like a current.

For most of software’s history, the riskier the system, the harder you froze it: you don’t push weekly updates to an x-ray machine or a rocket; you certify a finished artifact and ship it, precisely because lives ride on it not changing. Agents break that bargain. Companies might license and freeze a fixed version of the model, but they can’t freeze the world the model runs against. The inputs are effectively infinite, and certification can only test the slice you thought to write down. This means the highest-stakes deployments are the ones where the vigil stops being good practice and becomes the only safety you have.

Build is an event. Operate is a vigil.

The PM who operates agents has stopped waiting for an alarm and started reading an instrument — and when a system can’t break loudly, the instrument is the only thing standing between you and a slow, invisible decline. It’s the whole reason drift gauges stop being a nice-to-have.

The daily focus changes as well. A builder opens the laptop and asks what they’re making today. When a builder gets faster, they ship more features — and applying a builder’s mindset to AI is exactly what produced the term “AI slop.” An operator opens the laptop and asks what their system is doing today, and where it’s starting to drift. When an operator gets faster, a living system holds together under more load.

The ship your team launched is already past the breakwater. It is well-built; that was the outcome of your skilled team of builders. But the sea it’s in changes by the hour, and the only thing between a good crossing and a wreck is whether someone is at the helm — reading the water, correcting for a drift no instrument will announce on its own. Sailing the ship is the objective of the decade ahead, and the product managers who understand the difference will keep their ships off the rocks. The ones still admiring the hull they built won’t notice the water until it’s over the deck.

Next in this series: You can hand off a finished artifact and walk away, but you can’t walk away from a system that’s still alive. Managing the operators — why leading the people who run these systems is a different job than running the systems, and the one the last decade of org design left us worst prepared for.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

Air Canada’s support bot invented a bereavement-fare policy that did not exist. A customer relied on it, booked his flight, applied for the refund the bot had promised him, and was turned down because the policy was never real. He took the airline to tribunal, and the airline lost.

The headline cases are the loud ones, but the quieter write-ups from this year are the ones worth reading. They describe agents that follow their instructions cleanly in week one and, by week six, have renegotiated those instructions with themselves. The thread running through all of it is unglamorous: almost none of these failures register as errors to the systems watching them. They return a valid response. They throw no exception. Monitoring built to catch the absence of an answer has nothing to say about an answer that is fluent, well-formed, and wrong.

I ran into the same wall on a far smaller stage, building an advisor agent, and the first real test I wrote for it worked perfectly. It had one rule it could never break: research a figure before stating it, and never assert a number it hadn’t looked up. That either happened or it didn’t. Clean pass, clean fail, nothing to argue about.

Then I encountered a bigger problem.

As the agent got more capable, its memory and its skills got spread across more systems, and the first thing that broke was the voice. What had sounded like a person started sounding like a manual. That failure was relatively easy to repair — but then generated another, harder problem. With the voice restored, it drifted: plain on the first exchange, faintly professorial by the third, talking like a philosophy seminar by the sixth. No single response was obviously wrong, but the trajectory meant that someone having a conversation over time with the agent would feel the slope.

The cause wasn’t the model changing under me — though that’s also a real failure for production agents (say, a provider ships an update under a stable model and behavior shifts overnight). Mine was the opposite kind: the model still held but the context moved. My own prior turns were the strongest examples in front of it, so a slightly ornate answer on turn one became the example that turn two imitated.

A slope isn’t something you catch immediately by reading transcripts. So I seeded the agent’s instructions with a handful of examples of the voice I wanted, then scored each run on how far it wandered from them, grading the spread of outputs rather than any one of them. And somewhere in building it, I realized the research test and the voice score were not two versions of the same job — they were different jobs.

Three different jobs, three different evaluations.

For most of its history, a piece of software took a defined input and produced a defined output, and testing meant checking the second against the first. Put a language model inside that software and the output stops being a single value and becomes a spread of values: same input, a distribution of possible responses, no single correct one to check against. A pass/fail gate has nothing fixed to measure a distribution against.

So the one job becomes three, and only one of them is still a gate.

Some things stay binary: the research must always happen first, the output must be valid. Those are gates, and they still block the build exactly as before. Some things are invariants that have to hold across the whole spread, whatever words come out: the agent concedes uncertainty when it has no grounds to be sure; the answer stays the same when only an irrelevant detail of the question changes. Those are property tests. And some things are matters of judgment: is the voice right, did the joke land, would this put a customer off. No assertion settles those, because those are gauges on a scale. A gauge gets read, and watched over time.

It’s worth stating that software has not been uniformly blind to this. Machine learning has graded output with no single right answer for decades — translations scored against references, models tuned on precision and recall, human labels reconciled for agreement. Property-based testing has asserted invariants across a range of inputs for years. Performance engineers have always shipped against a distribution of latencies, not a single number. The pieces existed. Yet they lived in the ML lab and a few specialized corners, and the great deterministic middle of software (the CRUD apps, the business logic, the SaaS that runs on defined input and defined output) built its entire quality model on the assumption it would never need them. That middle is the latecomer.

It built its quality model around a specific bet: that testing is mechanical enough for the person who wrote the code to also write the test. Over the last decade the bet won. Separate QA got folded into engineering, “throw it over the wall” became an embarrassment, and the coder owning the test became the default. That arrangement holds for gates because a gate is mechanical, and catches the fault no matter who wrote it. But a gauge needs a reader whose judgment is independent of the making: a second party, or a rubric fixed in advance so the score isn’t just the maker’s gut.

The strain of managing AI quality is already in the numbers.

Developers working with AI assistants merge far more code, carrying something like 1.7 times the defects of code written by hand. QA headcount, widely written off a few years ago, has grown faster than developer headcount over the same stretch. And the field is openly split on where the judgment work should go: back to a revived quality function, or out to the robots, with LLMs grading other LLMs.

The real answer is both, but applied in an order. The robots scale the gauge: an LLM can score a thousand voice samples against a rubric overnight in a way no human panel can. But it cannot own the verdict, because you have no reason to trust its scores until you’ve checked them against a human whose judgment you already trust. That requires organizations to calibrate the judge first, against a person, the way clinical raters are checked against each other before their scores are allowed to count. The teams doing this well are the ones who decided on purpose where a human stays in the loop, instead of discovering the answer after a tribunal.

When you evaluate voice drift, the judgment takes two forms. First is calibrating the scale itself: what makes an output a 4 and not a 5, a 3 and not a 4. Second is whether to put a gate on the gauge at all, and where. The mistake is to gate on the average, because the average lies. A voice whose mean score looks fine but whose worst five percent collapses into generic-assistant filler is exactly the one a user stops trusting. So you gate on the tail, the fraction of outputs that breach the bar, not on the score of a typical one.

Which raises a question the industry is asking backward. It isn’t whether we need testers again. It’s who in the building already knows how to read a gauge — and some of them have been doing it in plain sight. NPS was never a number you passed or failed; it was a user-generated gauge, on which teams read and argued about where to draw the line. Whether your organization strove for an NPS of 7 or 8 was a matter of judgment. Likewise, “good enough to ship” was always a gauge reading disguised as a decision. Product is one function that’s lived with this; so has anyone who's owned an SLA or a support-CSAT target. The capability the org suddenly needs — owning a threshold on a distribution and defending it — is one that teams have practiced for years under a different name.

I spent years running quality as a function before I ever built an agent: the launch frameworks, the named go/no-go conditions, the framework for deciding when a thing met the bar that customers expected. That apparatus for judgment already existed, and I’d built versions of it. It had simply never been pointed at a language model.

Other industries built this apparatus long ago.

A pharmaceutical release lab is an evaluation harness built in stainless steel. Standardized sample pulls, calibrated instruments, spec limits applied automatically, and a literal gate at the end: the batch does not ship unless its measured distribution sits inside spec. That is the same move: a gate riding on the tail of a gauge, not on any single reading.

A factory floor runs the other half — automated measurement on the line, the output distribution charted in real time, an alarm when it drifts past its limits. That is drift monitoring, built decades before anyone needed it for a chatbot.

And standardized essay grading, the machinery behind every large-scale exam, long ago built distributed rater pools, calibration sets fed to graders before live scoring, double-scoring with adjudication when two raters disagree, and lately an automated scorer running alongside the humans with its agreement to them monitored. That last one is LLM-as-judge, with the operational scaffolding already bolted on and fifty years of practice behind it.

When you catch yourself asking “is this good?” about an output that varies and has no single right answer, the field that has answered that question for fifty years is medicine, or sensory science, or competitive judging. Wine has calibration standards. Gymnastics drops the high and low score and decomposes the rest. Clinical trials have independent panels and analysis plans written before the data arrives. Ask who has graded your kind of problem for half a century, then go read what they built.

Two things borrow cleanly. The first is calibrating the judge against a human: you validate your scorer against a person you trust before you let the scorer’s numbers mean anything, the same inter-rater check a clinical study runs on its raters.

The second aspect to borrow is recognizing the difference between a gate that blocks and a gauge that gets read. A gate asks whether a thing is present or absent, and a script can run it. A gauge asks how good, across a spread, and it needs a calibrated reader. Confuse the two and you get the worst of both: force voice into a pass/fail check and you’ll set it so loose it never catches anything, or so tight nothing ever ships and your own builders start routing around their own test.

Which brings me back to the voice score that reads 4.1/5 on the first turn and verges on the esoteric by the fifth. The binary check was never going to tell me whether the voice was good — no more than a check would help customer service agents who silently renegotiate their instructions after weeks of use. In judgment, the deciding factor is whether the person on the other end can trust what they’re reading. Trust is no longer a layer on top of the product; it is the product. And judging trust — reading the gauge — is no longer a layer on top of the work; it is the work.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

Last quarter a product manager I know spent ninety minutes at her desk rereading a three-paragraph memo from her CEO. She wasn’t slow. She was trying to work out which of three things was happening: a reorg, a project cancellation, or a layoff.

The memo used the words “sharpening focus,” “doubling down on our most defensible investments,” and “a disciplined posture for the quarters ahead.” It named no team, no project, no date. It was, by any reading, an announcement of something — but the something sat just out of view.

The reason she couldn’t interpret the memo isn’t that she’s bad at her job. It’s that the memo was built to be legible to some readers and opaque to others, and she was on the wrong side of the line.

We treat corporate language as a character defect. The people who write in coded terms get called dishonest, cowardly, political. The assumption underneath is that if everyone were braver and clearer, the language would dissolve. That assumption is wrong, and it’s a disservice to the people who haven’t learned to read it.

Corporate language is an equilibrium. And like every equilibrium, it persists because the people inside it are rewarded for staying there.

Corporate language maintains an equilibrium

Consider what a memo from a department head has to accomplish. It has to inform without committing to outcomes that can’t be guaranteed. It has to align with next quarter’s narrative without contradicting the last three months. It has to satisfy a half dozen stakeholders who want different things, while preserving the writer’s room to renegotiate in six weeks when the landscape shifts. And it has to survive the worst-faith reader in the room: the executive looking for someone to blame when a number misses, the board member who skims the first paragraph and asks the question that decides headcount.

A clear statement fails most of those tests. Clarity commits. It names an owner, a number, a date. Being wrong in writing is survivable for a junior employee but expensive for a director or VP — whose pattern of being wrong becomes the case against them at the next reorg.

So the language adapts. “We will ship X by date Y” becomes “we’re doubling down on X to drive durable value over the coming quarters.” The substitution is intentional: the first sentence is a commitment, the second is a posture. The corporate system rewards postures because postures can be revised quietly and commitments cannot.

This dictionary gets used across functions, up and down the org. A finance lead writing “we’re taking a prudent approach to discretionary spend” is doing the same work as a marketing head “reallocating toward higher-conviction channels” or a general counsel describing a settlement as “a pragmatic resolution.” Each phrase is a costume worn over a more direct sentence that someone decided was too costly to say plainly.

People don’t write this way because they’re bad at their jobs. They write this way because the systems they work inside grade them on it.

Who pays the cost in translation

The corporate dictionary isn’t evenly distributed. It’s acquired by proximity to decision-makers, which is a function of who hired you, whether your manager invested in you, whether you got pulled into the room or left outside it.

There's no dictionary to pass down, because the knowledge isn't a list of definitions. It's pattern recognition built from time and proximity, and both are rationed by the org chart. For example, the tenured employees in the room know what “exploring opportunities in the adjacent space” means. They know it means there’s no owner, no scope, no timeline, and a few quarters of churn before anyone agrees what the work even is. They know because they’ve lived through six versions of the same memo and watched what followed each one.

This raises an important point: the dictionary works as a sorting mechanism; a signal sent at one frequency to people already tuned to receive it, and at another to everyone else. The memo that reads as a warning to a VP reads as a strategic update to a mid-level PM. That’s not a flaw in the communication; that is the intent of the communication.

Newer employees take the memo at face value: they write plans against it, set goals to it, and get blindsided when the initiative dies two quarters later. The signals were always there, and the people meant to read the signals did so, while everyone else waited.

The result is that we’ve built a private language inside professional work. The price of admission to senior roles is fluency in a dialect taught nowhere, acknowledged by no one, and acquired only by recognizing the same pattern again and again. This isn’t exclusion of the obvious kind — nobody is denied a job over their reading comprehension. The exclusion is quieter: it happens at the level of which projects feel real, which executive sponsorship is durable, which “strategic priority” survives the quarter and which is already a dead man walking.

The cost isn’t paid in salaries or titles. It’s paid in which careers compound and which stall: who develops senior judgment and who spends a decade confused about why their good work kept landing on the wrong initiatives.

Acting on the hidden dictionary

An equilibrium can’t be moralized out of existence. The genre of critics telling leaders to “just say what they mean” has run for fifteen years without moving a single quarterly memo. The system is stable because it’s doing exactly what the incentives ask of it.

The inescapable truth is that the language is load-bearing, and the scarcity of understanding is the point. A system in which everyone could read the memo accurately is a system in which the memo can no longer sort who belongs in the room and who doesn’t. That’s not a problem anyone is trying to solve.

The PM who spent the time on the memo was trying to solve a puzzle that was not designed to be solved from her seat. The senior people in the room had already moved on: they’d gotten the message (sent at the frequency she couldn’t receive) and were already acting on it. That’s not a communication failure — that’s the system working exactly as intended.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

Sunday morning I opened my laptop expecting a victory lap.

I’d spent a few weeks building an AI app — the rolodex reimagined for people who want help maintaining relationships, not another social network to feed. By the second week I had auth working, password resets wired, and a rudimentary AI agent producing qualified output against a contact database. Work that would have taken weeks a few years ago, and required multiple specialists, had taken a few days.

I made coffee, sat down, and found a longer to-do list than I’d started with.

The V1 worked, and that was the problem. With the core shipped, the next layer of questions moved to the front of the line: prompt injection, jailbreak hardening, token gating so a single curious user couldn’t run up a four-figure bill against my account in an afternoon. None of these had been on the list a week earlier. All of them needed a decision.

Having a backlog wasn’t new. Any seasoned engineer will tell you the work is never done — there’s always a queue of new requirements stacked on a standing backlog of bugs, and shipping one thing only surfaces the next three. What had changed by using AI was the speed: the backlog emptied and refilled before I could catch up with it. The hours AI saved on coding hadn’t returned to my calendar. They’d gone somewhere else: into deciding what to build next, what to harden, what to defer, and whether the thing I’d just shipped was actually safe to put in front of a stranger.

This is the part the trending takes on AI and product management are missing. Doomsayers claim AI is coming for product management — that as engineering velocity rises, fewer product decisions are needed, and by extension, fewer PMs.

I don’t see it. The decisions didn’t shrink. They first reshuffled, and then they multiplied.

And it isn’t just one person’s Sunday. The broader 2026 data points the same direction: PM openings are at the highest level in three years, the demand for builders is rising, and the work is multiplying with it. What I ran into that morning — the work expanding to fill the time the tooling saved — is showing up across the discipline.

There’s an obvious objection: PMs are getting laid off right now, in large numbers. But those cuts are a balance-sheet story, not a verdict on the work — and as I’ve argued elsewhere, the roles cut by mistake tend to come back. The signal is in fact running the other way: the work that survives demands more judgment per hour, not less.

There’s a 19th-century version of this phenomenon.

In the late 1800s, William Stanley Jevons studied steam engines and expected efficient ones to reduce England’s coal consumption. What he found was that the technology did the opposite. Cheaper steam meant more factories, more rail, more uses that hadn’t been economical before. Efficiency expanded the market rather than shrinking it.

Cheaper engineering is doing the same thing to product work right now. Categories that barely existed as line items two years ago — prompt regression testing, agent reliability, token budgeting, abuse detection — have moved from “out of scope” to “ship-blocking.” Making one bottleneck cheaper shifted the bottleneck to whatever it was complementing. In software, the thing engineering was always complementing was judgment.

Walk through any tech company’s PM staffing strategy from the last decade and you’ll see the same pattern. Growth PM. Payments PM. Onboarding PM. Each specialization made sense when the unit of work was large enough to sustain a focused career — when “Growth” meant a quarter of experiments and “Payments” meant an eighteen-month migration.

In the generalist era, the speed of backlog throughput is skyrocketing. As a result, there is more work — yet work no longer arrives in chunks big enough to occupy a single-domain career. Previously, an onboarding specialist might have had months of work queued up; OAuth alone might run six weeks, and the PM thought about onboarding strategy while engineering built. When OAuth takes a day, that window collapses. Now they have a day, then they’re idle in their domain while five other domains pile up. The volume went up; the contiguity went away.

The market is already picking this up, though it files it under a different name. The pattern getting reported across 2026 is a K-shape: hiring demand surging at two poles while the mid-level middle hollows out. Read quickly, that looks like a story about specialists winning. But look at what both surviving poles have in common. They’re organized around judgment: deciding what to build at one end, deciding where to route at the other. The role hollowing out in the middle is the single-domain PM whose work used to arrive in contiguous blocks. The bifurcation is the symptom. The collapse of the contiguous block of work is the cause.

The specialist model didn’t arise in a void. Anyone who’s spent real time in software knows the pattern: management likes to move people between products like interchangeable checker pieces, and the experienced ones know it doesn’t work that way. Specialized knowledge is earned. The case for deep expertise is real — complex domains require it, and a generalist who knows a little about everything can ship something dangerous in a domain they don’t fully understand. Payments compliance isn’t something you skim a doc and decide on. Neither is agent safety. The risk of the generalist era isn’t that work slows down. It’s that work speeds up past the point where anyone notices what’s been waved through.

The new generalist can’t be a dilettante.

In the generalist era, the specialist doesn’t vanish. They stop being the default way you staff a team and become the depth a generalist knows when to reach for. The generalist who emerges from this era has to be someone who knows what they don’t know, fast enough to call in the right specialist or AI agent before shipping something they shouldn’t. The skill isn’t breadth over depth. It’s the judgment layer sitting above both: knowing when the work needs breadth or depth, and switching cleanly.

Delegate, decide, dig in. That triage is the job. The functions are interchangeable; the call about which one to make is not.

The closest analogue isn’t another kind of PM. It’s a small-org CEO — not in span of control, which is a separate conversation, but in the fluidity of knowledge required to operate. A CEO pulls from multiple disciplines at once. They don’t need to know engineering as deeply as a CTO or finance as deeply as a CFO, but they need enough fluency across functions to recognize, in real time, when to delegate, when to decide, and when to go deeper.

The measure of a good generalist PM in 2026 isn’t how much they already know. It’s how fast they can come up to speed on an unfamiliar domain, how well they can work with the AI agents now doing first-pass work, and how reliably they can decide whether to ship, push back, or escalate.

If the decisions multiply and judgment is the binding constraint, the headcount math runs opposite to the doomsayer’s prediction. The work calls for more people who can make the call, not fewer. The doomsayers counted the decisions that got cheaper and missed the ones that got created.

This rewrites the hiring question. “Give me examples of your last projects and how you succeeded” is a specialist question, built for an era when projects ran long enough to be told as stories. The question now is closer to: “Walk me through the last unfamiliar domain you came up to speed on, and how you decided what to ship.” It’s the instinct behind the case-study interview — drop someone in front of unfamiliar territory and watch them navigate. But the case study as most teams run it has drifted into pattern-matching against consulting frameworks, and the candidates who do well are the ones who’ve memorized the moves. A question that actually tested the new cadence would throw an unfamiliar domain at the candidate halfway through, and grade the switch.

The PMs worth hiring in this market are the ones who can walk through that without flinching.

The backlog isn’t dead. The specialist might be.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

There are two kinds of changes AI can make to a job.

The first is replacement. Tier-1 customer support triage (think: password resets, billing questions, account lookups) can now be handled end-to-end by software. Junior legal document review, once billed at associate rates by the hour, is now a prompt and a parser. Whereas the human once handled the process, AI can automate the core tasks entirely. From an operating expense standpoint, cutting headcount translates to durable savings.

The second kind of change is augmentation. An augmented role still requires a human — but the human moves faster with AI alongside them. An augmented employee, to borrow from science fiction, wears the proverbial mecha suit that soldiers wear to enhance their abilities.

An augmented PM uses AI to streamline evaluating data to weigh roadmap tradeoffs. An engineering lead uses AI to preflight architecture decisions. In both these instances, the role still exists — and becomes more valuable as productivity increases and employees move faster.

Crucially, the financial impact of AI on this role is different from the replacement scenario. Cut an augmented role, and the human portion of the work still remains. Moreover, that work lands on whoever is left — the person who now carries their original job plus the remainder of their former coworker’s.

Companies running layoffs in 2026 have not separated these two categories. They are budgeting financial outcomes as if all roles are replacement types. The math works on paper. It stops working three quarters later.

One summer morning in July 2024, Intuit cut approximately 1,800 employees — 10% of its workforce. The CEO memo filed with the SEC was explicit on the reason: the AI era required accelerating investment in key growth areas, and that required reallocating resources. It contained one sentence that has not aged well: “We do not do layoffs to cut costs, and that remains true in this case.”

That statement wasn’t a lie. It was a categorization error.

The 2024 memo sorted the cuts into three buckets: employees not meeting expectations, role eliminations to streamline work, and site consolidations. Three distinct rationales, unified under a single AI-investment narrative. The three buckets were the rationale. The 10% was the decision.

Simultaneously, the company announced plans to hire the same number of new people in engineering, product, and customer-facing roles. From the outside, the logic held. Investment redeployed. Underperformers out. New capabilities arriving.

From the inside, the experience was different.

Leaders didn’t decide whether to cut — that had been decided several floors up. Their purview was where: which roles fell below the line, and what that meant for the roadmap.

What followed that July was not an efficiency gain. Main workstreams continued at the same velocity — not improved, because hiring needs had grown so quickly that the recruiting teams now experienced a backlog.

Secondary workstreams lost coverage and quietly slipped. Teams absorbed what they could and deferred what they couldn’t. From above, the metrics looked stable: headcount down, priority output continuing as before. Yet what the metrics missed was the load the remaining team was now carrying — work that hadn’t gone away, just gone quiet. That work surfaced later along with a grinding sense among those who remained that they were doing more, with less room to do it well.

This is not a complaint about the decision itself, but about how these decisions get packaged and impact teams when the work on the table is not quickly replaceable. The category error isn’t unique to Intuit. It’s the error most companies are making right now: assuming that because AI has made some work replaceable, a proportional share of every team’s work has therefore been replaced. That assumption doesn’t survive contact with how product organizations actually work.

In the early 2000s, companies moved call centers offshore. The savings were immediate. The problems came later — customer complaints, then churn, then the quiet and expensive decision to bring the work back. Nobody saw it coming because they were watching the wrong numbers.

The same pattern is showing up now. A February 2026 study of 600 HR professionals found that roughly a third of companies making AI-driven cuts had already rehired a quarter to half of the eliminated roles. Another third had rehired more than half — most within six months.

Forrester forecast that half of AI-attributed layoffs will be quietly reversed once the gap between what companies expected AI to do and what it actually does becomes impossible to ignore. That gap is not a failure of technology. It is a failure by companies to classify the work before they cut.

Smart cuts focus on the tasks to be replaced, not the job title.

The companies that navigate the AI era well are those that do the hard part up front: mapping which roles are end-to-end replaceable and which are augmented, then cutting accordingly.

That mapping requires looking at the work being done, not the job title. Tier-1 support is replaceable because the core work within the role — pattern matching, script-following, routing — are automatable. Senior product managers are less replaceable because many core tasks within the role — navigating ambiguity, making tradeoffs with incomplete information, holding relationships across functions — are not things AI can complete end-to-end. The difference lives in the task, not the title.

Most layoff decisions are made at the title level, by people several floors above the work, on assumptions about AI capability that the people doing the work could correct in twenty minutes.

The survivors are left carrying the bag. The org chart says the work is gone, but the calendar says otherwise. The attrition numbers will look different in two quarters, and the rehire requisitions will follow — quieter than the original announcement, not filed with the SEC, not framed as an AI investment. Just a backfill. Just catching up. Just the deferred cost of a classification error, arriving on schedule.

Piece #1 of this series argued that the 2026 layoffs are not an AI story, but a balance sheet story. Piece #2 argued that AI spend has moved from a fixed cost to a variable one, and handed the productivity lever to the CFO in the process. The first two pieces followed the money. This one follows the work. The balance sheet gets managed, but the work doesn’t go away. Someone carries it.

The full series is at close-tack.com.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

In May, the president and COO of Uber sat down for a podcast and said the thing most executives spend energy not saying.

Andrew Macdonald was asked whether Uber’s surging use of AI coding tools was translating into anything customers could feel. Uber had pushed adoption hard — an internal leaderboard ranked teams by how much AI they used — and the engineers responded. Roughly 70% of committed code was now AI-generated. By every internal dashboard, the program was a triumph. Macdonald’s answer: “That link is not there yet.” He added that the company would now have to weigh token consumption against headcount. The CTO, separately, described the team as back to the drawing board.

This is a company that told its engineers to use AI, watched them do exactly that, and discovered four months into the year that it had spent its entire 2026 budget for AI coding tools.

The easy read is that AI was overhyped and the productivity never showed up. The more interesting part is the nature of the AI bill, and how that bill affects the org chart.

The cheaper it gets, the more it costs

The per-unit price of AI is falling, fast. Gartner projects that running a sophisticated model will cost roughly 90% less in 2030 than it does today. Every reassurance you’ve heard that AI is getting cheaper is true.

And it is entirely consistent with your bill tripling. Agentic workflows — the kind where a tool reads an entire codebase to plan a multi-step change — consume tokens at a scale that swamps any per-unit discount. The cost didn’t rise despite the tool getting better. It rose because the tool got better. Good enough that everyone used it, constantly, for everything. Uber’s engineers weren’t misusing the tool when they vaporized the budget. They were using it exactly as intended.

This is what the productivity pitch never priced in. The whole case for AI adoption was that it makes everyone more productive. Under metered pricing, the most productive employee is now the most expensive one. The better the tool works for them, the more they reach for it, the larger their line on the invoice. Productivity and cost, which a salaried headcount model holds apart, are now on the same curve.

Who owns a cost that behaves like this

For two decades, enterprise software ran on a premise so stable nobody examined it: pay per seat. A license cost the same whether the employee used it one hour or eight. The cost was a flat line you could draw a year in advance, and finance signed off as a formality.

Metering breaks the flat cost predictability. It also does something subtler in the process: it makes consumption visible.

A flat-rate license hid usage inside a fixed number. Nobody in finance knew or cared whether a team ran a Jira instance or Adobe Analytics tool hard or let it sit. Token billing turns that invisible usage into a reported figure — a line item on the income statement, a number that shows up in the quarterly review, something someone has to explain and defend.

Visibility changes the game. Companies won’t cap productivity — no executive issues a productivity halt — yet because spend now correlates directly with how much the tool gets used, capping the spend means rationing the productivity. Determining the output the company is willing to pay for, task by task, in a way it never had to when the cost was flat.

For thirty years, the person who chose the engineering team’s tools was the engineering leader. The CTO evaluated the tool and the cost — a predictable per-seat line — was finance’s rubber stamp. The decision lived with technology.

When the cost of a tool grows faster than the value it creates, the binding question shifts from “is this good” to “what will this cost, and can we model it.” That question belongs to the person who answers for the number on the statement. The clearest signal came in April, when Deloitte published a guide to AI token economics written for chief financial officers — a category of document that didn’t exist eighteen months ago. Advisory firms don’t build CFO playbooks for problems that belong to someone else. The playbook appeared because the decision moved.

You can watch the move happen even at companies that own the alternative. Microsoft wound down its internal Claude Code pilot this spring, redirecting engineers to Copilot. Microsoft escaped variable billing by using its homebuilt solution. Most enterprises can’t.

We have run this play before

The pitch — convert a fixed cost into a variable one, scale it with demand, shed the burden of carrying it — is the exact pitch of offshoring. Replace the salaried call center with a contract that flexes: pay for what you use, nothing when you don’t. For a decade that was the most fashionable line on the income statement.

The savings were real, specifically, where the work was genuinely commoditized. Where the task carried invisible value — institutional memory, judgment, the quality that doesn’t show up until it’s gone — the savings curdled, and the work came back, reshored at a premium once the true cost surfaced. The pattern wasn’t that offshoring failed. It worked exactly to the degree the work was a commodity. The failure was that companies were bad at telling the two apart until the quality dropped or the bill arrived.

AI-on-a-meter operates in a similar way. Token-priced automation will permanently take over the cognitive work that was truly a commodity. It will fail — expensively — on the work that only looked that way. The CFO now holds the lever on that bet, and the offshoring record is not encouraging about how well that bet gets made.

So the layoffs continue, for now. Cut headcount, add an AI line, present a leaner company to shareholders this quarter. But the swap trades a fixed cost for a variable one, and calls the difference savings. The last time the org chart believed that trade was permanent, it spent the following decade quietly hiring back the parts it had misjudged. This time, the bill arrives faster — and itemized by the token.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

The clearest analysis of why the Meta and Intuit layoffs feel different in 2026 didn’t come from a newsletter, a Forbes column, or a podcast. It came from a comment.

Last week, Elena Verna retitled a post. The original headline was “You’ll lose your job in 2027.” After painful reader feedback in the context of the recent cuts, she changed it to “Your Job Is Changing Faster Than You Think” and posted an apology. The substance stayed the same: become AI-native, build optionality, start a Mom & Pop SaaS, ship to prod with Lovable, where Verna happens to be Head of Growth.

Verna isn’t a marginal voice in this conversation. Her Substack has over 90,000 subscribers, most of them senior PMs, growth leaders, and operators at the companies doing the layoffs. The piece did what well-meaning thought leadership has done for two years now. It collapsed three different stories — AI capability improving, layoffs accelerating, and a forecast about superintelligence — into a single inevitability, then told the reader they needed to adapt.

The comments pushed back. One in particular, from Fiodar Sazanavets, did the work the piece didn’t.

He named it AI washing. Companies cutting headcount for balance sheet reasons and labeling the cuts AI efficiency to make the story palatable on the analyst call. He pointed at Coinbase, which announced its own 14% workforce reduction the same week, framed as an “AI efficiency” move during a crypto downturn. He noted Verna’s employer. Two sentences, posted under a piece that will be read by a hundred thousand people. The comment did more analytical work than the article it sat under.

Verna did eventually qualify her position. By then the original provocation had already done its work — the snowball was rolling, and the corrections never catch up.

Here’s the real framework by which to assess the recent AI layoffs.

Three layoffs, three pressures, one costume

AI washing is a costume. Underneath it sits a collection of real business pressures. None of them are primarily about AI replacing the worker.

Meta is cutting employees because of capex pressure. Intuit is cutting because of price-to-earnings multiple compression. Coinbase cut because of a crypto market downturn. All three layoffs got dressed up the same way: we’re becoming more AI-efficient, we’re moving people into AI initiatives, we’re getting faster. Three completely different financial mechanics under one disguise.

Let me dive into each one.

Meta: when the cost of a data center eats the company

The bet underneath the entire AI economy is straightforward. Whoever owns the compute owns the layer every future AI product runs on, the way owning the cell towers meant owning a piece of every phone call in the 2000s. Microsoft, Google, Amazon, Meta, and Oracle are racing to build the cell-tower equivalent for AI: data centers, GPUs, networking, power. The winner gets to charge rent on the next decade of software. Losing means becoming a tenant in someone else’s economy.

So they’re spending. The five have committed between $660 and $720 billion in capital expenditure in 2026, nearly all of it for AI infrastructure. Roughly double 2025. Almost triple 2024.

Here’s the part the layoff coverage skips. Capital expenditure — buildings, chips, ten-year power contracts — comes out of the same pot of money that funds payroll, marketing, R&D, and shareholder returns. For most of the last decade, the hyperscalers’ capex used about 40% of the cash their businesses generated. The rest was spare. Some bought back stock, some paid dividends. Most of it sat on the balance sheet as a buffer.

In 2026, capex is consuming close to 100% of operating cash flow. The buffer is gone. Microsoft’s free cash flow is projected to drop 28% this year. Barclays now models the cohort going cash-negative in 2027 and 2028, spending more than they generate, for two years running.

To bridge the gap, the hyperscalers are doing something they’ve never done at scale: borrowing. The five issued $121 billion in bonds last year against a five-year average of $28 billion, and Morgan Stanley projects $400 billion of AI-related debt issuance in 2026 — roughly ten times what they raised in 2024. Oracle is already cash-flow negative, and on one Barclays scenario runs out of cash by November.

Not all of the debt is in the headline numbers. Meta’s $27 billion deal with Blue Owl Capital to finance the Hyperion data center in Louisiana sits in an off-balance-sheet vehicle. Microsoft, BlackRock, and partners did the same thing at $40 billion scale with the Aligned Data Centers acquisition — the largest data center deal in history, structured specifically to keep the leverage off the parent’s books. The pressure is real even when the disclosure isn’t.

When capex is locked in for years, when debt service is climbing — visible and otherwise — and when free cash flow has collapsed, the income statement has to give somewhere. You can’t unbuild a half-finished data center. Headcount is the line you can cut in a quarter and announce on an earnings call.

So Meta cuts 10% of its workforce — 8,000 people — in May, and the memo talks about flattening management and moving people into AI. The same quarter, the company guides to $115–$135 billion of capex for the year.

The narrative is “we’re moving people into AI.” The accounting is “we are financing a $130 billion infrastructure year, and the cash has to come from somewhere.”

Intuit: when the market downgrades your future

Intuit is a different story, and it took me a minute to figure it out.

By every operating measure that matters, Intuit is fine. Revenue grew 10% last quarter. Operating income climbed to $4 billion from $3.7 billion year over year. The company raised its full-year revenue guidance, bought back $1.6 billion of its own stock, raised the dividend 15%. The CFO went on record saying the underlying business isn’t showing the AI disruption the market is pricing in. None of that looks like a company that needs to cut 3,000 people — nearly 20% of its workforce — to make ends meet.

But the stock is down roughly 40% on the year. The reason is one sentence: in April, Anthropic launched managed agents that handle financial and tax workflows, the exact workflows TurboTax and QuickBooks have charged for since the nineties.

Investors looked at Anthropic’s launches, looked at Intuit’s $200-billion-plus market cap, and asked: how much of this is still worth paying for in 2028?

Whether the question is right doesn’t matter. The fact that investors are asking it changes the price. Spooked by the emerging competition, they quietly downgraded the multiple they’d pay for every dollar of Intuit’s earnings. Earnings are unchanged. The stock — a bet on the future — falls.

When that happens, the only way to defend the share price is to grow earnings faster than investors expect. And the fastest lever a profitable software company has for growing near-term earnings is to cut opex. So you cut 17% of the workforce, take a $300–$340 million restructuring charge, and tell Wall Street the savings flow to margin expansion and EPS growth. Goodarzi said exactly this on the call.

Intuit’s 17% cut isn’t a productivity announcement. It’s an EPS announcement, made because a software company with stock down 40% needs to give Wall Street a number to believe in.

Coinbase: when the actual business is down and “AI” sounds better

Coinbase laid off about 14% of its workforce on May 5 — 700 employees — and attributed the cuts to AI-driven efficiency and a flatter org structure. Two days later, the company reported a $394 million quarterly loss and a 31% year-over-year revenue decline. Crypto is in a bear market. Trading volume is down. The actual reason for the cuts was that the underlying business was contracting. The AI framing was the press release.

What’s actually going on

Three layoffs. Three different financial mechanics. Same costume.

Meta needed cash to fund a capex year that’s eating its operating cash flow. Intuit needed an EPS story to defend a compressing multiple. Coinbase needed a reason for cuts in a down market that didn’t say “we’re a crypto company in a crypto winter.” All three reached for the same word, because in 2026 AI is the word that gets analysts to nod along.

Verna’s piece — and the broader genre it represents — reads all three as evidence that AI is finally coming for knowledge work. The actual evidence supports a more banal claim: AI is the most flexible justification language a CFO has had since “offshore efficiencies.” Like offshoring, the language of layoffs is being deployed in front of decisions that would have been made anyway. The actual driver is margin defense.

That’s not the same as saying AI doesn’t matter in the workforce. It matters. The role change is real, and the employees who refuse to engage with the tools will face an uphill battle delivering in their jobs. Verna isn’t wrong about that.

She’s wrong about the causal connection. “Your job is changing because AI is becoming powerful” and “you were laid off in May 2026 because AI is becoming powerful” are two different claims.

The first is mostly true. The second is a financing story dressed up as a productivity story. Treating them as the same thing leads thoughtful people to make hurried decisions. Quit and start a service business. Take a pay cut to chase an “AI-native” role. Pivot into solopreneurship in a recessionary economy. All based on a misread of what’s actually happening at the cap table.

There’s a version of the advice that I would advocate for. Stay technically sharp. Get genuinely good at the AI tools that affect your function, not as performance but as fluency. Keep your human relationships warm. What's not on that list: rushing to go back to school, becoming a solopreneur, or taking a 30% pay cut because someone told you AI is eliminating your old work.

The quiet good news

If the layoffs were driven by productivity gains alone, the roles would be gone. They aren’t. They’re being deferred because the capex year is brutal, the multiple is compressed, or the underlying business is having a bad quarter. The work didn’t go away.

The research community has been clear on this. As of early 2026, multiple studies using payroll, CPS, and labor-market data through 2025 find no aggregate employment decline traceable to AI exposure. The Federal Reserve Bank of Dallas finds that in jobs with heavy AI exposure, wages aren’t declining either — which is the signature you’d see if labor were being displaced at scale. Even Intuit’s own CFO told analysts the underlying business isn’t showing the AI disruption the market is pricing in. The aggregate productivity gain that would justify aggregate layoffs hasn’t shown up.

Tech has done this before. Meta laid off 21,000 people between November 2022 and March 2023, then hired tens of thousands back through 2024 and 2025. Google cut 12,000 in January 2023 and ended 2024 with more employees than before the cuts. The pattern is consistent across 2001, 2009, and 2022. Each time, the people who stayed sharp and didn’t panic-pivot out of their domain came out of the cycle stronger than the ones who reinvented themselves in a hurry.

The 2026 cycle will run the same way. The capex curve digests its investment-heavy meal. The multiple stabilizes. The bad quarter ends. The same companies that cut in May discover, around the same time next year, that they need to hire back into the function they cut from. The flavor of the work will change — product teams leveraging agents, finance teams automating their daily reporting — but the work remains.

In the meantime, keep an eye on the comments. Sometimes that’s where the real story lies.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

Your newest customer isn’t human.

They never see your hero image. They don’t read your reviews. They show up at your site, scan your structured data, compare you to four competitors in 200 milliseconds, and decide — or skip you entirely.

As I argued in the last piece, the next product strategy shift isn’t web vs mobile. It’s human vs agent.

The question now is what businesses do about it.

The temptation is to treat the agentic customer as an extension of the team that handles humans — same funnel, same metrics, maybe a structured data feed bolted on. That’s the mistake the mobile laggards made in 2012, and it cost them a decade.

The winning approach is to design your org for both customers. First, though, you have to understand what an agentic customer actually is.

What is an agentic customer?

It’s worth pausing on what we really mean by agentic customer.

The human customer is what we’ve always known. A real person opens an app, navigates a menu, fills out a form, reads a confirmation screen. The product, therefore, is designed around what a person can see, tap, remember, and tolerate.

The agentic customer – or agentic shopper - is new. Upstream, a human may tell the agent “I want to buy a pair of dark-wash, slim-fit jeans,” then Gemini takes over and acts on the human’s behalf — searching your site, comparing to Levi’s, Madewell, and Everlane, and deciding. The human never visits. (In the future, agents may even decide on their own when you may need a pair of jeans – without anyone telling them.)

The defining trait of an agent is latitude. Unlike the backend systems your customers never see, an agent doesn't just execute instructions — it interprets them, and decides how to act. The Amazon-Perplexity lawsuit is exactly this question. Perplexity’s agent showed up at Amazon to shop on behalf of humans, and Amazon objected to the latitude it took. The courts now have to draw a line that didn’t exist a year ago.

The agentic funnel breaks at every stage

When an agent is the customer, bolting on additional metrics and adding to your existing team’s charter fails as a strategy because your existing funnel - optimized around a human customer - breaks at every stage.

Consider what changes:

Discovery. SEO was already weakening by the early 2020s. When you ask ChatGPT to find a pair of jeans, it doesn’t care which brands paid Google to rank at the top. It searches for patterns of reliability and fit. New funnels, new placements, and a new acronym — generative engine optimization — are coming, but the larger point is that the discovery funnel you built for humans is no longer the discovery funnel that matters.

Comparison. If an agent does the comparison shopping, your conversion-rate optimization is competing inside a model’s reasoning. The agent never sees your hero image, your social proof banner, or your urgency timer. It sees a structured product feed and decides on attributes that have nothing to do with the persuasion architecture you built for the human eye.

Brand. Your brand has historically lived in the experience — the colors, the voice, the moments of delight. When an agent strips your site to structured data and reads the answer back in its own voice, brand has to live somewhere more durable: in data, trust, and authority.

Each stage of the funnel — discovery, comparison, brand — needs to be redesigned for a customer who doesn’t see screens, doesn’t read copy, and doesn’t make decisions the way humans do.

Three questions for your leadership team

The companies that win this transition will need two parallel funnels — a human funnel and an agentic funnel — with the discipline to recognize they’re different products serving different customers, requiring different metrics, design principles, and probably team structures.

That’s an organizational question. Here’s what to ask your leadership team:

1. Who owns the agentic customer experience? If the answer is “the existing product team will handle it as part of their roadmap,” you’ve already lost. The agentic surface needs dedicated ownership the same way mobile needed dedicated ownership in 2012 — not because it’s separate from the company’s mission, but because the design and metrics are different enough that part-time attention produces mediocre work on both sides.

2. What does “good” look like in the agentic funnel, separately from the human funnel? Conversion, retention, NPS — most of these don’t translate cleanly. Agent-mediated acquisition has different unit economics, different attribution, different competitive dynamics. If your dashboards don’t separate them, you’ll optimize the average of two different things and win at neither.

3. Where does the moat live when one of the two funnels strips the interface away entirely? If the honest answer is “in our UX,” you have a real problem on the agentic side. If the answer is “in our data, our network, our trust, our judgment,” you have something to build on for both.

The framework to carry into the 2030s

Peter Senge’s observation that “the ability to learn faster than your competitors may be the only sustainable competitive advantage” is as true as ever. The product leaders who leaned into mobile early in 2010 didn’t win by abandoning their web product. They won by building two surfaces deliberately, with the org structure to support both, while their competitors were still treating mobile as a side project.

We’re at the same kind of inflection point now. The discipline of product management — the way we draw org charts, write specs, run experiments, define a “good” experience — was built for a world revolving around one customer. Now, a second customer is opening alongside it, and the companies that recognize the agent as a parallel customer will look, in five years, the way the truly mobile-savvy companies look now.

Where does the agentic funnel show up in your org chart? And if the answer is “it doesn’t yet” — what would it take to get it there before your competitors do?

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

For most of the 2010s, every product conversation eventually included the same prioritization question: Web or mobile? Is our core customer sitting at a desk in an office or staring at their phone while shopping? At Intuit, I saw teams debate which experiences earned a dedicated mobile flow and which could get away with a responsive web page. Design systems, engineering org charts, and product requirement documents all made homage to that core tension.

The new product strategy question isn’t web vs mobile. It’s human vs agent.

Agentic AI is still in its infancy. But even now, the signs are here that this will be another revolution, perhaps bigger than the launch of the mobile era — and maybe even rival the arrival of the world wide web in the 1990s.

Three signals tell me we’ve crossed the threshold.

Voice interaction has finally arrived.

Mobile assistants — Siri, Cortana, Alexa — came a decade before their time. I had high hopes when Siri launched in 2014, only to be dismayed after suffering repeated instances of “set a timer” be translated to “set a tiger.” Siri promised a golden era of voice interaction, yet the years that followed reduced Siri’s launch to a collective shrug. Thankfully, that era is almost gone.

Leading voice systems in 2026 make mistakes on fewer than 5 of every 100 words, across accents, background noise, and the full mess of real environments. Once voice accuracy crosses 95%, talking no longer feels like a party trick, and starts feeling like the obvious way to interact. Watch closely next time you’re in a big city: the people talking on their phones aren’t just talking to other humans. They’re just as likely to be transcribing text messages, shopping, or giving instructions to an agent.

Agents went from toys to coworkers in under 24 months.

In late 2024, the best AI on the market could complete about 15 out of every 100 real-world computer tasks, such as logging into a site, filling out a form, comparing prices across tabs. Now, that number is close to 70 - about the same as an average person.

The ‘toy phase’ was the chatbot answering questions. The ‘coworker assistant’ phase is the agent doing work. The AI coworker logs into your portal, reconciles the numbers, drafts the email, books the flight. Amazon sued Perplexity in January over its AI agent casually shopping on Amazon. That lawsuit should be the proverbial canary in the coalmine — a clear signal that we’ve left the “interesting toy” era and entered the mainstream.

The language of search is changing.

Last week I found myself replying to a friend’s question with “Just ask Claude.” For decades (and for Gen Z, their entire lives), “Just Google it” has been the universal equivalent of finding things out. Yet I now notice an ever-increasing number of people around me say “Just ask Claude.” “Search Gemini.” “GPT it.”

Sixty percent of Google searches now end without a click. Google has become the place you go to verify: to find the source, to check if a thing is real. The AI LLMs become the place you go to draft, to explore, and do the actual work.

What this means — and what the mobile-vs-web debate taught us

These three signals point to one underlying story: humans are no longer the only customer navigating your product. Increasingly, an agent acting on the human’s behalf is doing the navigating, the comparing, the buying.

For businesses, the temptation is to treat this shift as a chance to bolt on “agentic AI” to the existing product. The mobile era should tell us that’s the wrong instinct. Instacart still has a web app; even Uber eventually built a serious web product for corporate accounts. They ran two surfaces in parallel, deliberately. The companies who lost were those that treated mobile as an afterthought — those who ported the desktop site to a smaller screen and moved on.

The agentic shift is taking the same shape. The winners will treat agents as a first-class business customer alongside humans.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

A lot of the AI conversation right now is about which jobs get automated. I feel that misses something more interesting. The AI shift isn’t going to eliminate roles neatly: it’s going to expose which roles have been allowed to hollow out. And the layer most exposed, in my view, is middle management.

Not because middle managers are obsolete. Because most organizations stopped asking what middle management was actually for somewhere around the last decade. AI is about to make that neglect impossible to ignore.

Earlier in my management career, an executive told me something that I remember despite the stark connotations: “The hardest role for me to staff is someone who can keep the front lines happy while taking a shellacking from senior leadership.”

Few roles are as clearly defined as those at the top and bottom. Executives set the vision. Individual contributors execute. It’s the layer in between — directors and managers — that decides how efficiently and effectively the vision is implemented.

That layer has always had a thankless job. Middle managers are sandwiched, by design, between managing a team below them and managing executives above them. Every meeting is a translation exercise. Every decision lands them in the awkward position of carrying someone else’s water — either delivering news from above to a team that didn’t ask for it, or surfacing pushback from below to executives who don’t want to hear it.

Done well, the work is largely invisible. Done poorly, the work of middle management adds bureaucracy (more meetings), redundancy (relaying information without adding value), and slows velocity.

The Myth of Boundaryless Leadership

Which is partly why, in the last decade, we saw an enthusiastic corporate experiment to do away with the layer entirely.

The pitch was seductive. Eliminate middle management, the thinking went, and you’d get faster decisions, leaner orgs, and — the cherry on top — executives who were “boundaryless.” A boundaryless executive would be close to the ground, in touch with the work, free of the bureaucratic intermediaries who slowed things down. Companies announced flatter structures with the kind of fanfare usually reserved for product launches.

In practice, the experiment produced a different result. Executives who had built their careers in a structured org didn’t suddenly become great hands-on coaches. Instead, two patterns emerged. Some executives became micro-managers — pulled into the weeds of decisions they had no business making, slowing the very velocity they were trying to unlock. Others were reduced to the equivalent of bird poopers: dropping in unannounced on a team’s work, leaving a strong opinion behind, and flying off to the next thing without context, follow-through, or accountability for the wreckage.

A handful of middle managers survived this era by adapting in a different (albeit also suboptimal) way. They stepped back and let their reports interact directly with executives. They positioned themselves as facilitators rather than gatekeepers. This worked, sort of. It preserved velocity and made the executives feel close to the work.

But it also reduced the manager’s role to information pusher and feedback enforcer: relaying messages, chasing action items, making sure the executive’s latest input got incorporated. Useful in the short term. But parroting executive talking points and relaying already-made decisions is not what strengthens organizations over time. It’s what hollows them out.

And this is where AI re-enters the story. Because if you’ve defined middle management as the layer that produces the artifacts of coordination (the status decks, the synthesis docs, the action-item trackers) then yes, agents are coming for that work, and they should. An individual contributor with the right tooling can generate most of what used to require a manager’s calendar. The artifacts were never really the job, though. They were scaffolding around the job.

The mistake, I think, was treating middle management as a layer to be optimized rather than a role to be defined. A layer can be thinned or flattened. A role has to be done by someone, and if you don’t define it, the work it was supposed to cover doesn’t disappear — it just gets done poorly, by the wrong people, at the wrong altitude.

Middle Managers as Accountability Agents

So what is the role, when it’s done well?

The version I’ve come to believe in — and advocated for at Intuit — is the manager as accountability agent. Worth being precise here: individual contributors are already expected to own their decisions. That’s table stakes. The accountability I’m describing operates one level up. It’s the manager’s accountability for the guidance, scope, and risk tolerance they set for the team — and it’s the part most organizations under-define.

So the accountable manager’s version isn’t “Fred shipped it because the CEO said so.” It’s “the team shipped it because I backed the call based on our roadmap and customer needs — and if the customers hate it, that’s on me as much as on Fred.”

That shift — from relay station to accountable owner — changes everything downstream. The accountable manager by definition must engage with the executive direction rather than just transmit it. She has to push back when strategy doesn’t fit the team’s context, or adapt it when it almost does. She has to absorb pressure from above so the team can focus, and provide cover when the team takes a risk. And she has to design the operating mechanisms that let the work actually flow rather than just appear to.

But herein lies the catch that most experiments in the “flat org” movement missed: this version of middle management only works if executives above let it work. An accountability agent who pushes back has to be allowed to push back. A manager who provides cover for their team needs to have standing in the executive’s eyes to absorb the heat. A director who adapts strategy needs an executive who treats the adaptation as judgment, not insubordination.

Which is to say: executives get the middle management they deserve (in other words, are willing to tolerate). Is the executive cohort willing to be managed by accountable agents, in the specific sense of being challenged, slowed down, and occasionally told no?

That’s the part of the deal that the boundaryless-executive era forgot. You can’t have managers who exercise judgment if the people above them have made it clear that judgment isn’t welcome.

If you’re an executive, the question isn’t how flat you can make your company to take advantage of AI. That’s the version that has already been answered by experiments in the 2020s. The real question is two-part. First: which middle managers act as accountability agents in my organization? Second, and harder: have I been creating the conditions where accountability-agent work is actually possible, or have I been rewarding the information-pushers because they’re easier to manage?

If you can answer both, you have a real advantage. If you can’t, your competitors will answer it for you.

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind

I’ve seen so much of the conversation around AI agents focus on their failures - the hallucinations, the forgetting, the limits of context.

These limits are real (yet the gap is shrinking every month that goes by). What doesn’t get enough attention is how well AI agents DO remember - and what this means for organizations.

I set up an AI agent this week to parse news events for me. (When I speak of agents, I use Gemini, Notebook, Perplexity, Claude and their derivatives for various tasks). Setting it up (perhaps you could call this “introducing myself” to my agent) took some time. Out of the box, of course, it didn’t know anything about me - my preferences, styles, or existing background.

By the time I finished briefing it, the agent had absorbed roughly nine pages of instructions: my personal preferences, sample articles to scan for, examples of angles it should find interesting, and how often to search.

(A quick refinement on this: handing an AI a list of rules degrades its performance, whereas a list of data/text will enhance its grounding. The reason: while AI is exceptional at digesting data, it has a limit on how many rules it can follow at once. To build a truly effective agent, you must separate the two: give it vast amounts of data to read, but keep the directives on how to behave extremely lean so you don't paralyze its ability to reason.)

The magic here is that my agent will pull all of that context, intact, every time I ask it to. At the present moment, the models may lead it to be right roughly 90% of the time - but in my experience that is a far higher percentage of success than would be attainable with a human assistant.

Even the most assiduous human assistant would not be able to reliably reference such in-depth background content every time, nor so quickly.

That’s not a failure of humans - that is how human memory works. We retain what knowledge we attend to often, and let the rest drift. That is to say, selective attention is our human superpower. Memory, and recall, is AI’s superpower.

When assessing a team structure, leaders are accustomed to assessing (whether by force of habit or intent) their individual employee’s superpowers. Likewise, we need to recognize where our digital agents shine to unlock the greatest improvements in velocity and innovation.

Memory is the treasury and guardian of all things

Cicero - Roman orator, philosopher, and statesman - lived by his training to deliver hours-long speeches without notes. For Cicero, memory wasn’t a parlor trick. It was the operating system of his profession and, by extension, of Roman governance itself.

An AI agent is, in the most literal sense, a treasury and a guardian. It holds what you give it, and it returns it intact, safeguarding it against the selective drift of human attention.

Which brings us back to team structure.

When I managed product teams, I spent a lot of time thinking about which humans to put in which roles: who was best at managing relationships with difficult stakeholders, who was best at driving execution in a critical domain, who had the passion and drive to innovate in a greenfield area.

The addition of AI agents to this equation does not simply give every team member a productivity boost. It adds a new kind of team member - one whose superpower is to use memory and near-perfect recall, and whose weakness is the judgment and selective attention that your human teammates bring. The two are not redundant. They are complements.

The leaders who will get the most out of the AI shift are the ones who stop treating agents as faster versions of their existing tools, and start treating them as a different role on the team. That positioning changes what you hand to the agent, what you keep with the humans, and how you structure the handoffs between them.

The failures of AI agents are real. But fixating on their shortcomings is a bit like dismissing a new hire because they cannot do what your most experienced person does.

The more useful question, for a leader, is the one you would ask about a new team member: what is this person uniquely good at, and what should I have them do?

Where are you finding digital agents genuinely complement the humans on your team?

I write Close Tack to give voice to the patterns leaders miss — the ones they're moving too fast to notice.

Click below to get the next one in your inbox.

Lean Into The Wind