The printing press didn't make you an author

In 2010 a Spanish civil servant named Joaquín García was called up on stage to receive an award for two decades of loyal service at the water board in Cádiz. There was one problem. When his boss went into the crowd to hand over the plaque, nobody could find him. As it turned out, García hadn't shown up for work in six years. Two departments each assumed the other was supervising him. He collected his full salary, roughly €37,000 a year, to do precisely nothing, and for six years not one person noticed (Euronews, The Local ES).

It's a funny story. It's also a diagnosis. For twenty years, companies quietly paid for roles that produced nothing, fixed nothing, and built nothing, all dressed up behind an important-sounding title. Then, somewhere around 2023, the bill came due. Meta cut about 11,000 jobs, roughly 13% of its workforce (Euronews). Google cut 12,000, Amazon 18,000, part of a wave that ran through the whole sector (Euronews). Elon Musk took Twitter from around 7,500 people to roughly 2,000, and the site everyone swore would collapse in a week is still running years later (Euronews). Headcount fell. In plenty of cases, profit rose. Which leaves one uncomfortable question hanging in the air: what were all those people actually doing?

There's a tidy story going around that answers it. The internet made a whole layer of coordination jobs redundant thirty years ago; cheap money kept them on life support anyway; and now that money is expensive again and AI can do the paperwork, the layer is finally being cleared out. The anthropologist David Graeber gave the layer its name in Bullshit Jobs: the flunkies, the box tickers, the taskmasters. AI, the story concludes, is the reaper come to collect.

It's a good story. It gets the disease right and the cure wrong. To see why, you have to go back further than 2023, to a time when you could still tell at a glance whether a job was worth paying for.

When you could still score the work

For most of the industrial age, work made things you could count. A factory shift produced so many units, at so many defects, in so many hours. Hire someone who added nothing and the numbers said so inside a week. Waste had nowhere to hide, because output was physical and productivity was arithmetic.

Then the economy tipped. Over the last century the balance of work slid from making things to providing services, until services were most of what people did all day. And a service does not come off a line. What is the unit of output for a coordinator, a liaison, an analyst? How many defects in a status report? From the outside, useful service work and useless service work look identical. That is the soil bullshit jobs grow in. Not malice, not stupidity, just work that nobody can score.

Two kinds of company, and what automation quietly does

Automation then split the business world in two, and it is worth being precise about the split, because these roles live cleanly on one side of it.

One kind of company builds the software. IBM, SAP, the vendors whose actual product is the system itself. The other kind buys that software to run a business that is not software at all: a bank, an insurer, a grocer, a logistics firm, where IT is indispensable but serves a product that lies outside it. The joke writes itself, since it tends to be the same logos on both sides of the deal. One world sells you SAP; the other world runs on it.

The translator roles live almost entirely in that second world, the one where software serves a process, because that is where someone has to carry business intent across the seam and turn it into something engineers can build. Strip the titles and the business analyst, the information analyst, and the proxy Product Owner are the same person on that seam, between a business that knows what it wants, sort of, and engineers who will build exactly what they are told. The business analyst works the problem space: IIBA's BABOK, the governing standard, defines the craft as enabling change by defining needs and recommending solutions that deliver value, need and value before solution (IIBA BABOK). The information analyst, a role Northern Europe splits out where the Anglo world folds it into "business analyst," works closer to the solution, turning that need into a precise information and function model: entity models, a data dictionary, functional design. It is the direct descendant of the 1970s structured-analysis systems analyst, Yourdon and DeMarco's data-flow diagrams and data dictionaries, and it still carries the same toolkit. The proxy Product Owner tried to be both, full-time, standing in for a business too busy to show up.

Put those roles back in the world they were built for and they were not overhead. They were the brake. Software used to be slow and expensive to make: a specification was a promise you would be paying off for months, a wrong one a promise you would be paying off for years. Spending a week to discover that "balance" meant two different things, before a team of ten started building, was the cheapest week in the whole project. When construction is the expensive part, translating carefully before you construct is simply good economics. These were real jobs, and for decades they earned their salary.

Now watch what automation does to that world over time. Every process it swallows is a batch of coordination work it quietly removes. The clerks who moved information up and down the hierarchy, the people who reconciled one department's numbers against another's: automation eats their reason to exist. So the more automated an organisation becomes, the less of that middle layer it should need. By rights, the translator layer should have thinned decade by decade as the tools got better.

But cheap money refilled what automation drained

It didn't thin. And this is the connection the tidy story rushes past. At the very moment automation was draining the need for the coordination layer, cheap money was refilling it.

For most of the last decade money was nearly free. The European Central Bank held its rates at or below zero and did not raise them once between 2011 and the summer of 2022 (Euronews). When capital costs nothing, the discipline that keeps an organisation lean quietly switches off. There is no market inside the firm to switch it back on, no price on a desk telling you a role has stopped earning its keep. In a service business you cannot even see the waste in the numbers, because service output cannot be counted. So the old reflex takes over: more people looks like more capability, a bigger team looks like a more important manager, and nobody asks the awkward question because the extra salary barely shows up. Automation pulled the need down, cheap money pushed the headcount back up, the two cancelled, and the swollen seam stayed swollen.

Everyone could feel it anyway. The developers complained, loudly, for years: vague specs, a game of telephone through someone who could relay a question but never answer it, decisions that never came. The business complained just as loudly from the other side: why does a small change take six months, why does IT never build what we actually meant. Both sides were right, and both were describing the same swollen seam. The proxy Product Owner is exactly what grew into that gap, a full-time stand-in translating all day with no authority to decide. Scrum.org has flagged it as an anti-pattern for years, a bottleneck with no decision-making authority (Scrum.org). Everyone knew. Nobody had to fix it, because cheap money was quietly paying for the friction.

Then two things happened at once

In 2022 the subsidy was withdrawn. The ECB raised rates faster than at any point since the euro was launched, from minus 0.5 percent to around 4 percent inside a year (Euronews). Every salary on the books had a real cost again.

At almost the same moment, AI arrived as a kind of super-automation. Earlier automation swallowed a process here and a process there. AI collapses the build itself: the agent types the code, drafts the tests, sketches the first version in an afternoon. And that does something the slow years never did. It makes the friction impossible to miss. When a feature took two quarters to ship, a six-week wait on a spec or a decision was lost in the noise. When the agent builds it before lunch, that same six-week wait stands out like a stopped escalator in a moving crowd.

Put the two together and you get the cull. Expensive money removed the cover, super-automation made the delay glaring, and organisations at last began to notice their Garcías. The numbers at the top of this piece are what that noticing looked like. The roles did not suddenly turn useless in 2023. They had been draining value for a decade. Two forces simply arrived on the same morning, one making the waste expensive again and the other making it visible.

AI is the printing press, not the author

So AI does deserve some credit here, just not the credit it is claiming. It did not make these roles pointless. It made the pointlessness visible. "AI killed the translator" is like saying the printing press made you a famous author. The press made publishing cheap. It did not write your manuscript, and it did not make it worth reading. It lowered the cost of one step and raised the value of every step it could not touch.

That is exactly what AI does to building software. It makes execution cheap. What it does not do, cannot do, is decide what is worth building and say precisely enough what it is. Expensive money is what cut these roles. AI only stripped away the last place the work could hide.

And here is the twist that should stop you before you cheer. Super-automation makes the low-value relay vanish, the moving of information, the mandate-less proxy passing along a message it has no authority to rule on. But it makes the real translation harder, not easier. When building was slow, IT was the brake, and a sloppy translation could shelter behind the cost of construction. Now that building is cheap, the brake moves to the business, which cannot decide and describe what it wants nearly as fast as an agent can build it.

Let me make it concrete, because I lived this one. I built an accounting package with AI recently. It took weeks, and not because the coding was hard; that part was over almost before it started. The weeks went into genuinely understanding the domain. Ask an AI for "a balance sheet" and you get a balance sheet. But the difference between a saldibalans (a trial balance) and a fiscale balans (a balance sheet drawn up under tax rules)? If you don't say which, the agent builds the wrong one. Confidently, tidily, and wrong. The code was never the bottleneck. My domain knowledge was.

That's the trap. The agent doesn't pick the right concept, it picks the most common one. AI hasn't made the translator obsolete. It has retired the relay and turned a spotlight on the craft.

Where the cut actually falls

So if AI isn't the thing that kills these roles, what is? A distinction, applied without mercy. Split the translator's work down one line: technique versus mandate.

The information-analysis half is technique. Modelling a concept precisely, forcing the right follow-up question, holding a data dictionary, standing up a rough demo to surface what people actually meant. None of that requires authority. It requires rigour. And rigour is exactly what you can put into a tool. Say "balance" and a good specify-layer shouldn't guess. It should see two candidate concepts in the model, each with its own definition and rules, and refuse to build until you pick one. The precision isn't cleverness, it's the discipline of the model. That is automatable.

The business-analysis half is mandate. Is this worth doing? What's it worth relative to everything else? In a bank or an insurer, that call was never the translator's to make anyway; it sits with risk, with compliance, with the business. So you don't automate it and you don't fake it. You route it to whoever actually holds the authority, and you record who decided. Then you train the judgment, because someone still has to know what to ask.

That's the fatal flaw of the proxy Product Owner, named exactly: they delivered the breadth of the business analyst without the mandate, and papered over the gap by pretending to own decisions they didn't. Automate the technique, route and train the mandate, and the toxic middle simply has nowhere left to stand. Notice what did not die here: Product Management. The Product Manager stays, on the seam, weighing and prioritising with real mandate. What leaves is the mandate-less relay.

The control layer, or you've built a nicer black box

One warning, because this is where it goes wrong. If you replace three careful humans with an AI that swallows intent and emits code, you haven't removed the risk, you've hidden it. A control layer you can't inspect isn't control. It's a fresh black box, which is the one thing you least want when the thing inside is a language model.

So the specify-layer has to be open. A readable, versioned, inspectable artefact: the concept model, the acceptance criteria, the demo, with a visible trail of who decided what. The delivery pipeline is the guardrail, not a PDF of good intentions filed after the fact. Speed without that isn't speed, it's risk.

Don't rebuild what you just tore down

The cynical ending to the layoff story is that these jobs never really die, they migrate. The culture coordinator becomes the AI transformation officer. The box ticker becomes the AI ethics reviewer. Same instinct to look busy, new lanyard.

The translator roles will try the same trick. The business analyst who never learned to route a real decision will re-emerge as the "AI requirements engineer," faking breadth in front of an agent instead of a Jira board, stacking debt that feels like productivity. If you let that happen, you've spent your restructuring budget buying a more expensive proxy Product Owner.

The way you stop it is the distinction. Technique into the tool, in the open. Mandate back to the business, and trained, not mimed.

Put it in front of your team on Monday

• Name the seam. For each team, who translates intent into spec today, and are they doing it with a mandate or faking one?
• Cut along technique versus mandate. Which half is rigour a tool can hold (concepts, models, criteria, demos), and which half is a value call that belongs to the business?
• Route the decisions. Send every value and priority call to whoever actually holds the authority, and record who decided. Stop asking a translator to pretend.
• Keep it in the open. If your new specify-layer can't be read, versioned, and inspected, you've built a black box, not a control layer.
• Train the judgment. Someone still has to know what to ask. Tooling scales that person; it doesn't replace them.

Cheap money hid these roles. Cheap building exposed them. But it was never AI that made the translator obsolete, any more than the printing press made anyone an author. AI just took away the last place the work could hide. The craft that's left, knowing what to ask and who gets to decide, didn't get cheaper. It got scarce. That's not a role you're cutting. It's the one you should be building.
‍

---
‍

This is a position piece, meant to be pressure-tested. The Joaquín García case, the 2022–2023 layoff figures, and the ECB rate history are sourced above. The framing draws on Baseflow's essay From Handwork to Agents and A plea for forward-deployed engineering; the limited mandate of the Product Owner is documented by Scrum.org and SAFe, with survey data from Wolpers (2026). "Bullshit jobs" is David Graeber's term (Bullshit Jobs: A Theory, 2018).

Sources

• Joaquín García: Euronews · The Local ES
• Meta layoffs (~11,000, ~13%): Euronews
• The wider tech layoff wave (Google ~12,000, Amazon ~18,000): Euronews
• Twitter headcount (~7,500 to ~2,000): Euronews
• ECB rates (first hike in 11 years, July 2022): Euronews · (fastest tightening since the euro, to ~4%): Euronews
• Proxy Product Owner as anti-pattern: Scrum.org
• Business analysis definition and BACCM: IIBA / BABOK
• David Graeber, Bullshit Jobs: A Theory (2018)
• Banner image: Printing press at Wilco printing the first edition of "The Product Samurai"

‍