You’re prob­a­bly fa­mil­iar with the dead in­ter­net the­ory: most of what you en­counter on­line is now gen­er­ated by bots, for bots, with hu­mans re­duced to a shrink­ing au­di­ence for ma­chine-gen­er­ated noise. Last year, over half of new con­tent on the in­ter­net was AI-generated. The hu­mans are still there, scrolling, but the thing they’re scrolling through has be­come a per­for­mance staged by ma­chines for an au­di­ence that has­n’t yet re­al­ized the show is­n’t for them.

It’s ut­terly des­ic­cat­ing to log onto spaces seek­ing a live mind to joust and think with, and find a re­lent­less stream of slop. Promised an age of su­per­con­nec­tiv­ity, we’ve let our shared phys­i­cal spaces wither, only to find our promised dig­i­tal com­mons to be one large bill­board in­creas­ingly read and cre­ated by bots.

That’s bad enough. I want to talk about some­thing worse. Call it the dead econ­omy the­ory.

A word of wel­come to the folks who have ar­rived here from Hacker News and var­i­ous other places. Two quick com­ments, given that I’ve re­ceived many mes­sages and have seen many com­ments on HN on this. First, the text of this piece is en­tirely hu­man-gen­er­ated, in­clud­ing the in­fe­lic­i­tous phras­ings and pen­chant for two-dol­lar words. The AI-generated im­ages, which many of you hate, are an in­side joke with a friend. Had I known this piece was go­ing to get the trac­tion it has, I promise you I would have gone with nor­mal head­ers. But, to para­phrase Dostoevsky from the pro­logue to The Brothers K, yes, I agree that it is su­per­flu­ous, but it’s done, so let it stand. Thanks for read­ing.

The AI in­dus­try has a num­bers prob­lem.

OpenAI, Anthropic, Google DeepMind, Meta AI, Microsoft: the com­bined in­vest­ment in large-scale AI in­fra­struc­ture now runs into the hun­dreds of bil­lions of dol­lars, with pro­jec­tions into the tril­lions over the next decade. OpenAI alone has been val­ued at north of $800 bil­lion. Anthropic, which has yet to pro­duce a sin­gle year of profit, com­mands a val­u­a­tion in the same stratos­phere. These num­bers need an ad­dress­able mar­ket large enough to jus­tify them.

There is only one mar­ket that large: the global la­bor mar­ket.

As we’re get­ting ex­cited about dis­cov­er­ing how to use claude.md files in Cowork, the in­dus­try is pitch­ing a dif­fer­ent re­al­ity. Every in­vestor pre­sen­ta­tion of an AI agent “doing the work of ten an­a­lysts” is telling you the same thing: the prod­uct is la­bor re­place­ment. The gen­tler lan­guage (”copilot,” “assistant,” “augmentation”) is mar­ket­ing. The fi­nan­cial model un­der­neath re­quires the elim­i­na­tion of hu­man cost cen­ters at civ­i­liza­tional scale. If it does­n’t do that, these com­pa­nies are the most over­val­ued as­sets in the his­tory of cap­i­tal­ism. The peo­ple writ­ing the checks are not in the habit of light­ing tril­lions of dol­lars on fire for a bet­ter au­to­com­plete and an end­less pro­lif­er­a­tion of longer and longer memos that no­body reads.

The AI com­pa­nies now con­struct their own bench­marks to prove the point. OpenAI’s GDPVal bench­mark mea­sures how well mod­els per­form across forty-four oc­cu­pa­tions, from real es­tate bro­ker to news an­a­lyst. The AI Productivity Index eval­u­ates mod­els against four spe­cific pro­fes­sional roles: in­vest­ment bank­ing as­so­ci­ate, man­age­ment con­sul­tant, Big Law as­so­ci­ate, pri­mary care physi­cian. These are tar­get­ing ret­i­cles aimed at the pro­fes­sional class. As an OpenAI eval­u­a­tion lead told the New York Times,1 mod­els now achieve “over an 80 per­cent win rate com­pared to hu­man pro­fes­sion­als” on tasks that, months ear­lier, no model could match. A for­mer banker on the re­search team “keeps be­ing shocked by how much of her old work the mod­els can do.”

So let’s take them at their word. Assume the tech­nol­ogy works as ad­ver­tised, that AI sys­tems be­come ca­pa­ble of per­form­ing most cog­ni­tive la­bor at a frac­tion of the cost of hu­man work­ers. What hap­pens next?

Follow the money through three turns.

Turn one: a com­pany li­censes AI to re­place a sig­nif­i­cant por­tion of its work­force. Costs drop. Margins ex­pand. The stock price goes up. Everyone on the earn­ings call is happy. When Block’s Jack Dorsey laid off nearly half his work­force in March, cit­ing AI cod­ing agents, in­vestors re­sponded with a twenty-five per­cent stock price surge in af­ter-hours trad­ing. The mar­ket re­warded the elim­i­na­tion of hu­man la­bor with an im­me­di­ate, mas­sive trans­fer of value to share­hold­ers.

Turn two: the re­placed work­ers stop earn­ing in­come. They cut spend­ing. The busi­nesses they used to pa­tron­ize see rev­enue de­cline. Some of those busi­nesses also adopt AI to cut costs, com­pound­ing the dis­place­ment. Consumer de­mand con­tracts across the econ­omy.

Turn three: the com­pany that fired its work­ers to save money dis­cov­ers that its cus­tomers were, in ag­gre­gate, other com­pa­nies’ work­ers. Revenue growth stalls. The AI sub­scrip­tion that was sup­posed to be an in­vest­ment in ef­fi­ciency turns out to be a con­tri­bu­tion to the de­struc­tion of its own mar­ket.

Economists Brett Hemenway Falk and Gerry Tsoukalas at Wharton have re­cently de­scribed this dy­namic in a pa­per they aptly ti­tled, “The AI Layoff Trap.” In com­pet­i­tive mar­kets, an au­tomat­ing firm cap­tures the full cost sav­ings from re­plac­ing work­ers but bears only a frac­tion of the re­sult­ing de­mand de­struc­tion. In a mar­ket with twenty com­peti­tors, each firm feels one-twen­ti­eth of the de­mand it de­stroys. The rest falls on ri­vals. This cre­ates a pris­on­ers’ dilemma: every firm ra­tio­nally au­to­mates be­yond the so­cially op­ti­mal level, be­cause the in­di­vid­ual in­cen­tive to cut la­bor costs al­ways out­weighs the dif­fuse, shared con­se­quence of elim­i­nat­ing con­sumer spend­ing. Better AI makes this worse. Improved pro­duc­tiv­ity widens the profit gap from au­tomat­ing faster than your com­peti­tors, in­ten­si­fy­ing the arms race to­ward col­lec­tive ruin.

Sometimes the lay­offs hap­pen be­fore ex­ec­u­tives even know whether AI will do the job. Zoë Hitzig, an econ­o­mist who pre­vi­ously worked at OpenAI, told the Times: “When chief ex­ec­u­tives are say­ing they’re cut­ting jobs be­cause of A.I., other peo­ple feel like they have to too. That dy­namic could make the changes hap­pen sooner than ef­fi­ciency would dic­tate.” Herd be­hav­ior dressed in the lan­guage of in­no­va­tion.

Henry Ford un­der­stood, per­haps apoc­ryphally but cor­rectly in prin­ci­ple, that his work­ers needed to earn enough to buy his cars. The AI econ­omy is elim­i­nat­ing the work­ers and ex­pect­ing the cars to keep sell­ing, ex­cept that soft­ware has near-zero mar­ginal cost, so the en­tire value propo­si­tion is the elim­i­na­tion of the hu­man cost cen­ter. The prod­uct is the re­moval of the cus­tomer base.

The op­ti­mists will tell you this is just pro­duc­tiv­ity gains. The econ­omy has ab­sorbed au­toma­tion be­fore; agri­cul­tural em­ploy­ment col­lapsed from ninety per­cent of the American work­force to two per­cent and civ­i­liza­tion con­tin­ued. David Autor at MIT has shown that roughly sixty per­cent of to­day’s jobs did­n’t ex­ist in 1940. New tech­nolo­gies cre­ate new cat­e­gories of work. True. But there’s a dif­fer­ence be­tween an ob­ser­va­tion about the past and a law of na­ture, and the op­ti­mists con­sis­tently con­fuse the two. The agri­cul­tural tran­si­tion took a hun­dred and forty years. Carl Benedikt Frey at Oxford has doc­u­mented that the Industrial Revolution took sev­enty years be­fore wages and em­ploy­ment re­cov­ered for the work­ers it dis­placed. In the in­terim, wages stag­nated, the la­bor share of in­come col­lapsed, prof­its surged, in­equal­ity sky­rock­eted, and the po­lit­i­cal con­se­quences in­cluded the Chartist move­ment and wide­spread so­cial up­heaval. As Frey puts it: “Most econ­o­mists will ac­knowl­edge that tech­no­log­i­cal progress can cause some ad­just­ment prob­lems in the short run. What is rarely noted is that the short run can be a life­time.”

Compare that time­line to the one the AI in­dus­try is work­ing on. Bharat Ramamurti, a for­mer deputy di­rec­tor of the National Economic Council, has drawn the par­al­lel to the China shock, the wave of man­u­fac­tur­ing job losses that re­shaped American pol­i­tics when pro­duc­tion moved over­seas. “The China shock un­folded over sev­eral years, whereas this could hap­pen over two years,” he told the Times. “These com­pa­nies have spent so much money de­vel­op­ing mod­els that there’s go­ing to be im­mense pres­sure on them to gen­er­ate rev­enue through quick adop­tion.”

Previous au­toma­tion re­placed spe­cific tasks within jobs. The power loom re­placed hand weav­ing, the spread­sheet re­placed man­ual cal­cu­la­tion, etc. In each case, the tech­nol­ogy was nar­row. General-purpose AI threat­ens cog­ni­tive la­bor com­pre­hen­sively, across every in­dus­try, si­mul­ta­ne­ously. The econ­o­mist Wassily Leontief saw this com­ing in 1983 when he com­pared hu­man la­bor to horses. The US horse pop­u­la­tion grew from nine mil­lion in 1840 to twenty-one mil­lion by 1900, seem­ingly im­mune to tech­no­log­i­cal change. Within sixty years of the in­ter­nal com­bus­tion en­gine, the pop­u­la­tion col­lapsed by eighty-eight per­cent. The horses weren’t re­tired out of mal­ice. They be­came un­eco­nom­i­cal to keep. Leontief’s point was that there is no eco­nomic law pre­vent­ing the same thing from hap­pen­ing to hu­mans.

Daron Acemoglu, who won the Nobel Prize in Economics in 2024 and is the most rig­or­ous voice on this topic, has found that be­tween 1987 and 2017, “the dis­place­ment ef­fect of new tech­nolo­gies far out­weighed their pro­duc­tiv­ity and re­in­state­ment ef­fects.” The new tasks did not ma­te­ri­al­ize fast enough to ab­sorb the dis­placed work­ers. His as­sess­ment of AI is more pointed still: firms are de­ploy­ing what he calls “excessive au­toma­tion,” us­ing AI to kill jobs with­out gen­er­at­ing sig­nif­i­cantly lower pro­duc­tion costs, while im­pos­ing sub­stan­tial so­cial costs. The tech­nol­ogy, in many ap­pli­ca­tions, is­n’t good enough to jus­tify the dis­place­ment it causes. Automation for the sake of the stock price, not for gen­uine pro­duc­tiv­ity.

Who is the cus­tomer when the cus­tomer is the thing you’ve elim­i­nated?

An econ­omy that does­n’t need hu­man la­bor is a po­lit­i­cal cri­sis of a kind de­mo­c­ra­tic sys­tems have never faced.

Democratic gov­er­nance rests on a bar­gain so old we’ve for­got­ten it’s a bar­gain at all. The gov­erned have some­thing the gov­er­nors need: la­bor, tax rev­enue, mil­i­tary ser­vice, con­sumer spend­ing. This de­pen­dency is the source of de­mo­c­ra­tic lever­age. The whole sys­tem func­tions be­cause power is dis­trib­uted, and it’s dis­trib­uted be­cause the peo­ple at the top need some­thing from the peo­ple at the bot­tom.

Remove la­bor from that equa­tion and watch what hap­pens.

When value is gen­er­ated by AI sys­tems owned by a hand­ful of cor­po­ra­tions al­ready world-class at tax op­ti­miza­tion, every fis­cal mech­a­nism of de­mo­c­ra­tic gov­er­nance starves at once. The tax base erodes. Collective bar­gain­ing be­comes ves­ti­gial (employers who don’t need em­ploy­ees don’t bar­gain with them). Consumer spend­ing, which de­pends on la­bor in­come, con­tracts. Piketty’s r > g, the en­gine of wealth con­cen­tra­tion, ac­cel­er­ates be­cause AI sev­ers the last link be­tween cap­i­tal ac­cu­mu­la­tion and the need for hu­man la­bor as a pro­duc­tion in­put. Without re­dis­tri­b­u­tion, as one analy­sis of the frame­work put it, “approximately every­thing will even­tu­ally be­long to those who are wealth­i­est when the tran­si­tion oc­curs.”

And the pub­lic funded the re­search that made it pos­si­ble. The trans­former ar­chi­tec­ture, large-scale train­ing meth­ods, semi­con­duc­tor ad­vances—all of these were pub­licly or quasi-pub­licly funded through uni­ver­si­ties, DARPA, and na­tional labs. The pub­lic bore the risk. Private com­pa­nies cap­tured the re­ward. This is blind­ingly com­mon across tech­no­log­i­cal ad­vance­ment in the last sixty years. As Mazzucato puts it, “AI risks be­com­ing an­other en­gine of rent ex­trac­tion rather than value cre­ation.” We sub­si­dized the rev­o­lu­tion and are now be­ing told to ac­cept dis­place­ment as the cost of progress that some­one else prof­its from.

You can still vote (and please do, for peo­ple who get this shit and are will­ing to try to stop it). But what you’re vot­ing over is the dis­po­si­tion of a shrink­ing pool of re­sources, while the real econ­omy op­er­ates in a par­al­lel sys­tem you in­creas­ingly have no in­put into.

The peo­ple build­ing these sys­tems un­der­stand this per­fectly. Dario Amodei, the CEO of Anthropic, has said it on the record: “The bal­ance of power of democ­racy is premised on the av­er­age per­son hav­ing lever­age through cre­at­ing eco­nomic value. If that’s not pre­sent, I think things be­come kind of scary.” The CEO of one of the three lead­ing AI com­pa­nies is telling you that the tech­nol­ogy he is build­ing will un­der­mine the ma­te­r­ial ba­sis of de­mo­c­ra­tic gov­er­nance. He sees the prob­lem. He is build­ing the thing that causes it. His com­pany has not en­dorsed a sin­gle piece of leg­is­la­tion to ad­dress it. When asked about pol­icy ad­vo­cacy, Anthropic co-founder Jack Clark de­scribed it as “the end of a very, very long chain of work.”

Peter Thiel wrote in 2009 that he no longer be­lieved free­dom and democ­racy were com­pat­i­ble. The logic runs: de­mo­c­ra­tic sys­tems pro­duce reg­u­la­tion, re­dis­tri­b­u­tion, and ac­count­abil­ity, all of which cre­ate fric­tion on the abil­ity of ex­cep­tional peo­ple to re­shape the world. If you be­lieve you’re build­ing the most trans­for­ma­tive tech­nol­ogy in hu­man his­tory, de­mo­c­ra­tic over­sight is an ob­sta­cle. Note: he is­n’t talk­ing about your or my free­dom. We don’t mat­ter.

This view has only gained ad­her­ents. The po­lit­i­cal spend­ing, the me­dia ac­qui­si­tions, the sov­er­eign-fund diplo­macy where Sam Altman tours the Middle East cut­ting com­pute deals with au­to­cratic gov­ern­ments: ra­tio­nal be­hav­ior for peo­ple who’ve con­cluded that de­mo­c­ra­tic gov­er­nance is a legacy in­sti­tu­tion to be routed around when it in­ter­feres.

Autocracies are bet­ter cus­tomers for this tech­nol­ogy than democ­ra­cies, which is pre­cisely why the broli­garchy has rapidly shifted its sup­port be­hind Trump and MAGA. A de­mo­c­ra­tic gov­ern­ment that de­ploys AI to re­place its work­force faces elec­toral con­se­quences. An au­thor­i­tar­ian gov­ern­ment faces no such con­straint and gains a sur­veil­lance and con­trol div­i­dend on top of the eco­nomic ef­fi­cien­cies. Saudi Arabia, the UAE, Singapore: vast cap­i­tal, cen­tral­ized de­ci­sion-mak­ing, no elec­torate to an­swer to, and an ac­tive in­ter­est in tech­nolo­gies of con­trol. This is one of the mo­ti­vat­ing fac­tors in the Valley’s latch­ing on to Trump: he and his cronies can be bought, and as im­por­tantly, they have no loy­alty to democ­racy. The eco­nomic in­cen­tives for AI com­pa­nies point to­ward the en­ti­ties with the fewest de­mo­c­ra­tic ac­count­abil­ity mech­a­nisms.

Leave a com­ment

Every pro­posed so­lu­tion to mass AI dis­place­ment treats it as a re­source dis­tri­b­u­tion prob­lem. Universal ba­sic in­come. Retraining pro­grams. The “leisure econ­omy.” The as­sump­tion is that if you send peo­ple checks, they’ll find mean­ing in hob­bies and com­mu­nity. They’ll paint. They’ll gar­den. They’ll fi­nally write that novel.

This is ahis­tor­i­cal bull­shit.

We don’t have to spec­u­late about what hap­pens when eco­nomic func­tion dis­ap­pears from com­mu­ni­ties. Anne Case and Angus Deaton’s re­search on “deaths of de­spair” tracks the ris­ing tide of sui­cide, drug over­dose, and al­co­holic liver dis­ease mor­tal­ity con­cen­trated in less-ed­u­cated, for­merly man­u­fac­tur­ing-de­pen­dent pop­u­la­tions. The mech­a­nism is­n’t just poverty. We lose any sense of eco­nomic pur­pose, and with that, so­cial sta­tus and a per­ceived fu­ture. Communities or­ga­nized around in­dus­tries that left, where what re­placed the jobs was opi­oids, do­mes­tic vi­o­lence, and a life ex­pectancy that dropped year over year in the rich­est coun­try on earth.

Molly Kinder at Brookings drew the con­nec­tion ex­plic­itly in Sun’s NYT piece: “Our econ­omy grew ex­tra­or­di­nar­ily and prices went down, but there were clear losers.” The AI com­pa­nies’ nar­ra­tives about abun­dance re­peat the same promises of glob­al­iza­tion. This time, the losers won’t be lim­ited to man­u­fac­tur­ing towns in the heart­land. “I’ve in­ter­viewed so many col­lege stu­dents who are su­per fear­ful about what the fu­ture means,” Kinder told the Times, “and their nar­ra­tive is ex­actly the same as those blue-col­lar guys in the heart­land.” The twenty-some­thing soft­ware en­gi­neer in San Francisco and the dis­placed fac­tory worker in Ohio are star­ing at the same ques­tion: what hap­pens when the mar­ket de­cides my skills are worth­less?

Guy Standing’s work on the “precariat” adds the struc­tural di­men­sion. The psy­cho­log­i­cal con­se­quences of per­ma­nent eco­nomic pre­car­ity cor­rode so­cial co­her­ence re­gard­less of whether the rent is paid. Four decades of ne­olib­eral pol­icy plus dig­i­tal ac­cel­er­a­tion have al­ready cre­ated this class. AI ac­cel­er­a­tion ex­pands it to in­clude the col­lege-ed­u­cated pro­fes­sion­als who thought they were safe.

Piketty, no con­ser­v­a­tive, has ar­gued that UBI fails to ad­dress root struc­tural prob­lems: “unequal ac­cess to ed­u­ca­tion and health, low-pay­ing and low-pro­duc­tiv­ity jobs, mal­func­tion­ing mar­kets, cor­rup­tion, and re­gres­sive tax sys­tems.” David Shor’s polling data bears this out from the other di­rec­tion: UBI is un­pop­u­lar with American vot­ers; a fed­eral jobs guar­an­tee has legs. People don’t want a check. They want work. They want pur­pose.

Anthropic’s own re­search has doc­u­mented some­thing worse than dis­place­ment: ac­tive deskilling. Junior en­gi­neers who re­lied on AI cod­ing agents did­n’t com­plete tasks much faster and un­der­stood their work less when quizzed af­ter­ward. The tech­nol­ogy is de­grad­ing the ex­per­tise of the next gen­er­a­tion of work­ers at the same time it’s com­pet­ing with them for their jobs. The re­train­ing ar­gu­ment as­sumes peo­ple can de­velop new skills to stay rel­e­vant. The ev­i­dence sug­gests the tools are pre­vent­ing them from de­vel­op­ing skills at all.

At the scale these com­pa­nies need to jus­tify their val­u­a­tions, you’re look­ing at so­cial in­sta­bil­ity that makes the cur­rent pop­ulist mo­ment look quaint. Tens of mil­lions of peo­ple, in their pro­duc­tive years, with no eco­nomic func­tion, no clear path to one, and a keen aware­ness that the peo­ple who did this to them are the rich­est hu­man be­ings who have ever lived. Stiglitz points out that AI will hit “routine white col­lar jobs,” the col­lege-ed­u­cated desk work that felt in­su­lated from man­u­fac­tur­ing dis­rup­tion. Accountants, an­a­lysts, ju­nior lawyers, ra­di­ol­o­gists, soft­ware de­vel­op­ers. The pro­fes­sional class that con­sti­tutes the back­bone of po­lit­i­cal sta­bil­ity in de­vel­oped democ­ra­cies.

The most hon­est thing you can say about vi­o­lence is that no­body wants it, but the con­di­tions that pro­duce it are be­ing en­gi­neered with ex­tra­or­di­nary ef­fi­ciency by peo­ple who have ap­par­ently never opened a his­tory book. It’s hap­pen­ing. In April, some­one tried to fire­bomb Sam Altman’s home. Another at­tacker tar­geted an Indianapolis city coun­cil­man who ap­proved a lo­cal data cen­ter pro­ject. Alex Karp, the CEO of Palantir, told a re­cent panel: “The biggest chal­lenge to A.I. in this coun­try is po­lit­i­cal un­rest. If I were sit­ting here in pri­vate with my peers, I’d be telling them the coun­try could blow up po­lit­i­cally and none of us are go­ing to make any money when the coun­try blows up.” Karp, to his credit, is say­ing this out loud. Most of his peers re­strict such ob­ser­va­tions to the dis­ap­pear­ing-mes­sage Signal chats where, as Jasmine Sun has re­ported, tech ex­ec­u­tives boast about the roles they plan to au­to­mate.

A strain of thought runs through Silicon Valley, from the Thiel Fellowship to the ra­tio­nal­ist blogs to the ef­fec­tive al­tru­ism move­ment, that treats its in­tel­lec­tual frame­work with the se­ri­ous­ness of re­ceived rev­e­la­tion. These are peo­ple who be­lieve they are op­er­at­ing at the fron­tier of hu­man thought.

They are op­er­at­ing at the level of a sec­ond-year phi­los­o­phy sur­vey, armed with enor­mous con­fi­dence and no aware­ness of the coun­ter­ar­gu­ments.

Start with Nietzsche, be­cause the Valley loves Nietzsche, or rather a ver­sion of Nietzsche that would have made the man lose his shit and go horse-hug­ging much faster than the syphilis. The Übermensch gets trot­ted out as jus­ti­fi­ca­tion for the ex­cep­tional founder, the vi­sion­ary who tran­scends con­ven­tional moral­ity be­cause he’s op­er­at­ing on a higher plane. Nietzsche was di­ag­nos­ing the cri­sis of mean­ing af­ter the col­lapse of meta­phys­i­cal cer­tainty, not writ­ing a man­age­ment phi­los­o­phy for peo­ple who got rich sell­ing ad­ver­tis­ing tech­nol­ogy. The Übermensch is about the in­di­vid­u­al’s re­la­tion­ship to the cre­ation of mean­ing in a god­less uni­verse. It has noth­ing to do with whether Peter Thiel should be ex­empt from de­mo­c­ra­tic ac­count­abil­ity. Nietzsche would have clas­si­fied these peo­ple as the last men, the ones who blink, say “we have in­vented hap­pi­ness,” and mis­take com­fort and op­ti­miza­tion for hu­man flour­ish­ing. He would have fuck­ing loathed them.

The pat­tern re­peats. Effective al­tru­ism is util­i­tar­i­an­ism rein­vented by peo­ple who have ap­par­ently never en­coun­tered Bernard Williams, or Derek Parfit’s own ag­o­nized wrestling with the im­pli­ca­tions of con­se­quen­tial­ist rea­son­ing, or the two cen­turies of philo­soph­i­cal lit­er­a­ture ex­plain­ing why naive ex­pected-value cal­cu­la­tions pro­duce mon­strous out­comes when ap­plied with­out lim­it­ing prin­ci­ples. The EA move­ment walked it­self into the Sam Bankman-Fried cat­a­stro­phe be­cause it adopted a moral frame­work with­out un­der­stand­ing its fail­ure modes. What hap­pens when you skip the course­work and go straight to the fi­nal exam.

Longtermism, the philo­soph­i­cal en­gine of AI ac­cel­er­a­tion, whether its pro­po­nents ac­knowl­edge it or not, is warmed-over Parfit with­out the rigor. The ar­gu­ment (that we should op­ti­mize for the wel­fare of tril­lions of hy­po­thet­i­cal fu­ture be­ings, and that pre­sent-day costs are ac­cept­able in ser­vice of that goal) is a frame­work any com­pe­tent ethi­cist can dis­man­tle in an af­ter­noon. It has no lim­it­ing prin­ci­ple. It can­not dis­tin­guish be­tween gen­uine moral ur­gency and the self-serv­ing con­clu­sion that what­ever the speaker was al­ready do­ing is cos­mi­cally im­por­tant. In prac­tice, it is a ma­chine for gen­er­at­ing jus­ti­fi­ca­tions for the con­cen­tra­tion of power by peo­ple who have de­cided they are the ones best po­si­tioned to stew­ard the fu­ture of the species. How con­ve­nient.

The ra­tio­nal­ist com­mu­nity re­dis­cov­ers Bayesian epis­te­mol­ogy and treats it like a rev­e­la­tion, ap­par­ently un­aware that the phi­los­o­phy of sci­ence has been work­ing through these ques­tions since the 1920s. Blog posts get treated as foun­da­tional texts. People who have never read Kuhn or Lakatos or Feyerabend con­struct an epis­te­mol­ogy from first prin­ci­ples, mar­vel at what they’ve built, and pro­ceed to use it as the in­tel­lec­tual build­ing blocks for de­ci­sions that af­fect bil­lions of peo­ple. The con­fi­dence is in­versely pro­por­tional to the depth. Dunning-Kruger at scale.

The in­tel­lec­tual poverty ex­tends to the eco­nom­ics. Acemoglu has found that only 4.6 per­cent of tasks in the econ­omy are cur­rently cost-ef­fec­tive to au­to­mate with AI. His es­ti­mate for AI’s to­tal pro­duc­tiv­ity im­pact over the next decade: 0.66 per­cent. Goldman Sachs pro­jected seven per­cent in 2023, be­fore we be­gan to see the shape of this thing. McKinsey pro­jects be­tween 0.5 and 3.5 per­cent an­nu­ally. Someone is cat­a­stroph­i­cally wrong, and the peo­ple spend­ing the money are not the ones with the Nobel Prize. Over ninety per­cent of firms sur­veyed in 2025 re­ported no mea­sur­able im­pact on em­ploy­ment or pro­duc­tiv­ity de­spite a quar­ter-tril­lion dol­lars in AI in­vest­ment. Torsten Slok: “AI is every­where ex­cept in the in­com­ing macro­eco­nomic data.” These are peo­ple who have de­cided what the fu­ture looks like and are spend­ing other peo­ple’s money to will it into ex­is­tence.

These bas­tards al­ways tell on them­selves. OpenAI pub­lished a white pa­per in April call­ing for “Industrial Policy for the Intelligence Age,” full of rad­i­cally pro­gres­sive pro­pos­als: a thirty-two-hour work­week, higher taxes on cor­po­ra­tions and cap­i­tal gains, a “public wealth fund” pro­vid­ing all cit­i­zens an eq­uity stake in AI com­pa­nies. In the same pe­riod, OpenAI’s pres­i­dent helped fund a su­per PAC that spent over two mil­lion dol­lars on ads against Alex Bores, a New York con­gres­sional can­di­date whose crime was in­tro­duc­ing safety reg­u­la­tion for large AI de­vel­op­ers and propos­ing to tax AI to fund di­rect pay­ments to Americans. The com­pany re­moved a profit cap that had pre­vi­ously lim­ited in­vestor re­turns to a hun­dred times their ini­tial in­vest­ment. Chris Lehane, OpenAI’s chief lob­by­ist, sys­tem­at­i­cally de­pri­or­i­tized in­ter­nal re­search that could pro­duce un­flat­ter­ing re­sults. “Whenever some­one wrote a pa­per which talked about some neg­a­tive as­pect of A.I.,” a col­league told the Times, “he would say, ‘We’re not go­ing to re­lease some­thing about a prob­lem un­til we have a so­lu­tion for it.’” Lehane’s own char­ac­ter­i­za­tion: “We want to do ap­plied physics, not the­o­ret­i­cal physics.” Tell the story that helps us, not the one that’s true.

A Philosophy 101 stu­dent who mis­reads Nietzsche writes a bad pa­per and gets a C. A bil­lion­aire who mis­reads Nietzsche builds a po­lit­i­cal phi­los­o­phy around the mis­read­ing and funds it with the GDP of a small na­tion. This is fuck­ing in­sane.

These are not se­ri­ous peo­ple. They are se­ri­ous about ac­cu­mu­la­tion and about win­ning. They are not se­ri­ous about the ques­tions that mat­ter for what they’re build­ing: what we owe each other, what makes a life worth liv­ing, and what hap­pens to a civ­i­liza­tion when you re­move the ma­te­r­ial ba­sis of hu­man agency. These ques­tions have oc­cu­pied the best minds in hu­man his­tory for mil­len­nia. The Valley’s en­gage­ment with them amounts to read­ing the CliffsNotes on a transat­lantic flight and ar­riv­ing con­vinced you’ve mas­tered the canon.

And they want to re­struc­ture civ­i­liza­tion.

Albert Camus broke with Jean-Paul Sartre and the French left over the most con­crete po­lit­i­cal ques­tion there is: can the peo­ple alive to­day be treated as ac­cept­able ca­su­al­ties in the pur­suit of a bet­ter fu­ture?2

Sartre and the Marxists said yes. History has a di­rec­tion. The rev­o­lu­tion re­quires sac­ri­fice. Camus said no. Any sys­tem of thought that sub­or­di­nates liv­ing peo­ple to a hy­po­thet­i­cal fu­ture has al­ready com­mit­ted the foun­da­tional moral er­ror. Once you ac­cept that logic, there is no lim­it­ing prin­ci­ple. Any atroc­ity be­comes jus­ti­fi­able. Any amount of pre­sent suf­fer­ing can be ra­tio­nal­ized as a nec­es­sary in­put to the glo­ri­ous out­put.

This is the struc­ture of the AI ac­cel­er­a­tion ar­gu­ment. The tech­nol­ogy will even­tu­ally ben­e­fit hu­man­ity (trillions of fu­ture hu­mans, lives of abun­dance and mean­ing we can barely imag­ine), so pre­sent dis­rup­tion is tol­er­a­ble. Displaced work­ers, hol­lowed com­mu­ni­ties, the ero­sion of de­mo­c­ra­tic lever­age, the con­cen­tra­tion of power in a hand­ful of pri­vate ac­tors who have ex­empted them­selves from the con­se­quences of their own pro­ject: re­gret­table but nec­es­sary. The ex­pected value math works out.

The founders of Mechanize, a startup whose stated mis­sion was “to en­able the full au­toma­tion of the econ­omy,” made the logic ex­plicit: “the only real choice is whether to has­ten this tech­no­log­i­cal rev­o­lu­tion our­selves, or to wait for oth­ers to ini­ti­ate it in our ab­sence.” Technological de­ter­min­ism as moral ab­so­lu­tion. The fu­ture is fixed. Our only choice is whether to build it first. Therefore, noth­ing we do along the way re­quires jus­ti­fi­ca­tion, be­cause the des­ti­na­tion was never in our hands. They’re mak­ing the same ar­gu­ment as the Marxists who sent dis­si­dents to the gu­lag.

Camus staked his in­tel­lec­tual legacy on the claim that the per­son stand­ing in front of you is not an in­put to a util­ity func­tion. Their suf­fer­ing is not re­deemed by a fu­ture state of af­fairs they may never see. Their dig­nity is not ne­go­tiable against pro­jected out­comes. The per­son who ex­ists now (who has a job they’re about to lose, a fam­ily they sup­port, a com­mu­nity that de­pends on a func­tion­ing lo­cal econ­omy) is the unit of ac­count. Not hu­man­ity in the ab­stract. Not the tril­lions of fu­ture be­ings that the longter­mists con­jure to win their ex­pected-value cal­cu­la­tions.

Once that com­mit­ment is aban­doned, the door opens to every form of ra­tio­nal­ized cru­elty that the twen­ti­eth cen­tury spent a hun­dred mil­lion lives try­ing to teach us to re­ject.

The en­tire AI ac­cel­er­a­tion pro­ject is premised on aban­don­ing it. It asks pre­sent peo­ple to bear costs for fu­ture ben­e­fits they may never see, dis­trib­uted to peo­ple who do not yet ex­ist, ad­min­is­tered by a self-ap­pointed class that has in­su­lated it­self from the con­se­quences en­tirely. Altman’s “universal ba­sic com­pute” pro­posal ac­knowl­edges, if you squint, that the fu­ture he’s build­ing re­quires a new dis­tri­b­u­tion mech­a­nism. It is also a pro­posal in which he gets to be the one do­ing the dis­trib­ut­ing. Feudalism with bet­ter brand­ing.

Jasmine Sun re­ported re­cently that tech in­dus­try sources “expressed more ex­treme con­cern about the la­bor mar­ket im­pacts of A.I. in pri­vate con­ver­sa­tion, but sud­denly be­came op­ti­mists once I turned on the mic.” They know what they’re build­ing. They know what it will do. They per­form op­ti­mism in pub­lic be­cause the al­ter­na­tive is ad­mit­ting that the thing they’ve staked their ca­reers and for­tunes on will im­mis­er­ate a sig­nif­i­cant por­tion of hu­man­ity, and they’re do­ing it any­way. Amodei has writ­ten that Anthropic is “currently con­sid­er­ing a range of pos­si­ble path­ways for our own em­ploy­ees,” im­ply­ing that even the peo­ple build­ing the tech­nol­ogy may be sur­plus to its re­quire­ments. He framed this as com­pas­sion­ate. Read it again as a CEO telling his work­force that their jobs, too, are tem­po­rary.

I don’t want to dwell on whether AI can do what these com­pa­nies claim. It may well be able to, though the cur­rent ev­i­dence sug­gests the gap be­tween pitch and prod­uct is vast, and se­ri­ous econ­o­mists think the pro­duc­tiv­ity gains are a frac­tion of what the in­dus­try pro­jects. But Acemoglu’s core find­ing is that AI does­n’t need to be rev­o­lu­tion­ary to be de­struc­tive. “So-so” au­toma­tion (technology that’s mediocre at re­plac­ing work­ers but cheap enough to do it any­way) still dis­places at scale while de­liv­er­ing un­der­whelm­ing pro­duc­tiv­ity. The worst out­come may not be su­per­in­tel­li­gent AI. It may be ad­e­quate AI, de­ployed ag­gres­sively by com­pa­nies chas­ing stock prices, elim­i­nat­ing jobs it can’t ac­tu­ally do well be­cause the quar­terly in­cen­tives de­mand it.

Has any­one with the power to shape this tran­si­tion thought se­ri­ously about what it means for the peo­ple alive to­day who did­n’t get a vote on any of it?

Fuck no.

The win­dow for chang­ing that an­swer is not in­fi­nite. The reg­u­la­tory cap­ture is al­ready ad­vanced: AI-related in­vest­ments ac­counted for thirty-nine per­cent of US eco­nomic growth in the first three quar­ters of 2025, giv­ing the fed­eral gov­ern­ment a vested in­ter­est in sus­tain­ing the boom. Amodei him­self ac­knowl­edges that this leads to “the re­luc­tance of tech com­pa­nies to crit­i­cize the U.S. gov­ern­ment, and the gov­ern­men­t’s sup­port for ex­treme anti-reg­u­la­tory poli­cies on A.I.” The reg­u­la­tor and the reg­u­lated have con­verged into a sin­gle in­ter­est. The ex­per­tise asym­me­try be­tween leg­is­la­tors and the in­dus­try they’re sup­posed to over­see is in­sur­mount­able. The feed­back loop (AI sys­tems ad­vis­ing on the gov­er­nance of AI sys­tems) is clos­ing.

The in­ter­ven­tions that could mat­ter are known. Public own­er­ship stakes in AI in­fra­struc­ture. Aggressive an­titrust en­force­ment. A gen­uine tax regime on au­to­mated la­bor. Branko Milanovic’s pre­scrip­tion is char­ac­ter­is­ti­cally di­rect: spread cap­i­tal own­er­ship more widely, tax the high­est cap­i­tal in­comes more ag­gres­sively. None of these are tech­no­log­i­cally dif­fi­cult. All of them re­quire func­tion­ing de­mo­c­ra­tic in­sti­tu­tions with the will to chal­lenge the rich­est com­pa­nies in hu­man his­tory. The com­pa­nies that would need to be taxed are spend­ing mil­lions to de­feat the politi­cians who pro­pose it.

The dead econ­omy is not one where noth­ing hap­pens. Plenty will hap­pen. The GDP might even go up; AI-related in­vest­ments are al­ready prop­ping it up. The dead econ­omy is one where plenty hap­pens and none of it re­quires you. Where the pro­duc­tive ca­pac­ity of civ­i­liza­tion has been cap­tured by a sys­tem you have no stake in, no in­put into, and no vote on. Where the peo­ple who built it told you they don’t think you should have a say. Where they ex­press alarm about the con­se­quences in pri­vate and op­ti­mism in pub­lic. Where they pub­lish white pa­pers call­ing for rad­i­cal re­dis­tri­b­u­tion while fund­ing su­per PACs to de­stroy the politi­cians who pro­pose it.

Share

1

This es­say re­lies fre­quently on the out­stand­ing re­port­ing of Jasmine Sun’s April 30, 2026 piece in the New York Times, which you can find at: https://​www.ny­times.com/​2026/​04/​30/​opin­ion/​ai-la­bor-work-force-sil­i­con-val­ley.html

I’m not go­ing to link it for every quo­ta­tion pulled from Sun’s piece, so if a di­rect quo­ta­tion is not cited in­di­vid­u­ally, I have pulled it from Sun’s re­port­ing.

I Am Retiring from Tech to Live Offline

AI took the last of the wind out of my Open Source sails. I wish you all the best!

Be sure to use AI when mak­ingy­our next, I don’t know, meal plan,for ex­am­ple. Definitely do not cal­ly­our friend who loves to cook and ask her­for her fa­vorite recipes or tips or ways to save time mak­ing meals, be­cause you will endup talk­ing for longer than you had hoped,hear­ing, per­haps, about her fa­ther’s can­cer di­ag­no­sis or how lonely she’s been or even­what she’s planted in her spring gar­den and then lost with the early frost.

And be sure to use AI when plan­ning that nextcamp­ing trip, the last one you will take­with this par­tic­u­lar child. Definitely do not text your friend who has fly-fished every river in Pennsylvania and biked every back­woods trail, be­cause you might end up tex­ting back and forth for the rest of the dayor even meet­ing up late for a beer and hear­ing­how he has ended each re­cent night black-out drunk, or per­haps you’ll hear how his­cousin is an id­iot on Facebook or maybe just­that he re­paired his own wash­ing ma­chine­and is pretty damn proud of that.

And be sure to use AI when your next child­gets mar­ried, so that you can write themthe per­fect toast or poem or speech or song­be­cause no one wants to hear your words, the ac­tual poorly writ­ten words of a par­ent (you) who changed­hun­dreds of di­a­pers for said child or fed them in the mid­dle of the night from your ac­tual body. Or cried when they were late home be­cause you were pos­i­tive they were dead. We don’t want those words—we’d pre­fer the ster­ile words of a ma­chine that never lived, never had an orig­i­nal thought, never felt the pain of mis­car­riage or bro­ken­re­la­tion­ships or the joy of a friend­ship re­store­dor of see­ing spring’s first robin danc­ing on frost.

And be sure to use AI when work­ing on your next­book or es­say or piece of art or pho­tog­ra­phy,and then smile or even laugh at your own­clev­er­ness when you see how good it is, and how easy, be­cause who the hell has timeto work at some­thing, to give time to craft, tocre­ate with their own minds, to spend years be­ing mediocre. Why do that when­mas­tery, or at least com­pe­tency is so sim­pleonly a good prompt away?

How mag­nif­i­cent the fu­neral song our chil­dren or con­tem­po­rarieswill write for us, a song they will make by tak­ing our obit­u­ary and Facebook posts,plus ran­dom quotes from our al­go­rithm,and feed­ing them into Chat or Gemini or Claude. The tears that will fall in the face of such­san­i­tary sweet­ness!

Be sure to use AI

and while you do I’ll be over here in my 50thyear, my youngest daugh­ter asleep on my chest,my arm falling asleep be­cause I dare not move­lest I scare away this mo­ment, ly­ing here melan­choly about my older chil­dren mov­ing out and my mid­dlechil­dren no longer need­ing me, at least­not like they used to, weary about this bodythat fails me now in ever in­creas­ing ways that will never be re­stored. Sighing over sto­ries I tried to write but never hit the page the way they felt in my mind.

But is­n’t that, my flesh-and-blood friend, the nat­ural or­der of things?

the long­ing for some­thing that could al­ways bea bit bet­ter

or the way that any­thing­worth do­ing feels a bit clumsy and painful, es­pe­cially at first

or hear­ing an­other hu­man voice and some­howre­al­iz­ing the beauty of life is found in all of the­sesub­tle im­per­fec­tions

No posts

GTA 6 de­vel­op­ers have for­mally an­nounced a union to com­bat Rockstar Games’ ac­tions which will be de­bated in court.

On Thursday, the Independent Workers’ Union of Great Britain (IWGB) and Rockstar staff mem­bers an­nounced the Rockstar Game Workers Union. This union will be part of the IWGB. The re­veal came in the form of an in­for­ma­tive video which delves into their mo­tives and what we should be look­ing out for in the fu­ture.

This union is the one fac­ing a le­gal bat­tle with Rockstar. Over 30 em­ploy­ees were fired last year for “gross mis­con­duct” which the IWGB dis­putes as an act of union bust­ing. As time has passed, the union has now been fully set up and is look­ing to fight Rockstar Games in court. A date for the trial in court has been set though not been pub­lished by the union just yet.

The Rockstar Game Workers Union say in their video that Rockstar’s ac­tions to­wards those 30+ staffers charged oth­ers to join the union. Whilst most of the af­fected work­ers were based at Rockstar North in Edinburgh, the seeds have spread far and wide. The union claims a size­able num­ber of Rockstar em­ploy­ees from their London, Leeds, Lincoln and Dundee of­fices have joined forces with the many oth­ers in Edinburgh.

Together, we are or­gan­is­ing around the things we want to change. Starting with: Pay trans­paren­cyFlex­i­ble workingAn end to crunch Rockstar IWGB Game Workers Union

Together, we are or­gan­is­ing around the things we want to change. Starting with:

Pay trans­parency

Flexible work­ing

An end to crunch

The Rockstar IWGB Game Workers Union have cre­ated BlueSky, Instagram and Twitter ac­counts for you to fol­low and re­ceive up­dates from. There is also a page to do­nate to­wards their le­gal bat­tle with Rockstar here.

This comes af­ter politi­cians have ac­cused Rockstar of block­ing the on­go­ing le­gal pro­ceed­ings. Learn more about it here.

Be sure to stay tuned to RockstarINTEL for all the lat­est news on Rockstar Games and GTA VI.

Subscribe to our newslet­ter!

DBOS re­cently ar­gued that Postgres is all you need for durable ex­e­cu­tion: if you al­ready trust your data­base, you do not need a sep­a­rate or­ches­tra­tion tier. I agree with the di­rec­tion, and I think the idea can be pushed fur­ther.

For a large class of durable sys­tems, SQLite is all you need.

The Durable Part

Durable ex­e­cu­tion is of­ten dis­cussed as if it re­quires durable in­fra­struc­ture. In many cases it does not. The durable part is the work­flow state. The com­pute can stay cheap and dis­pos­able.

That is a nat­ural fit for Obelisk: work­flow progress lives in an ex­e­cu­tion log, work­flows re­play from per­sisted his­tory, and ac­tiv­i­ties can be re­tried. What mat­ters most is keep­ing the work­flow state around and easy to in­spect.

Why SQLite Fits

SQLite is ap­peal­ing be­cause it gives you trans­ac­tional durable state with­out in­tro­duc­ing a sep­a­rate data­base ser­vice. There is no net­work hop, no ex­tra con­trol plane, and no new op­er­a­tional sur­face area just to keep work­flow progress safe. For many sys­tems, a lo­cal data­base file is ex­actly the right level of ma­chin­ery.

Litestream Makes It Portable

The ob­vi­ous con­cern is what to do with those SQLite files once ex­per­i­ments start to ac­cu­mu­late. That is where Litestream helps. It can stream SQLite changes asyn­chro­nously to S3-compatible ob­ject stor­age. That gives you a sim­ple way to keep work­ing state close to the run­time while still copy­ing data­bases out for backup, mi­gra­tion, and in­spec­tion.

The caveat is that Litestream repli­ca­tion is asyn­chro­nous. A re­store can miss the newest lo­cal writes if the SQLite vol­ume dis­ap­pears be­fore they are copied. That is fine for many AI and ex­per­i­men­ta­tion work­flows, but it is not the same thing as a highly avail­able shared data­base.

That still leads to a use­ful op­er­at­ing model: run an Obelisk server with a SQLite data­base, back it up with Litestream, and let an ob­server pull in­ter­est­ing data­bases when needed. The same file can be used for lo­cal re­play, de­bug­ging, and un­der­stand­ing what an agent ac­tu­ally did.

Why This Works Well For Agents

This is es­pe­cially at­trac­tive for AI agents and AI-generated work­flows. Those sys­tems are of­ten bursty, ex­per­i­men­tal, and eas­ier to rea­son about when each agent or ten­ant has a small self-con­tained unit of state. A fleet of tiny servers in mi­cro VMs or con­tain­ers, each with its own SQLite data­base and ob­ject stor­age backup, is of­ten a bet­ter fit than one large al­ways-on shared sys­tem. It is sim­pler, cheaper, and gives bet­ter fault iso­la­tion.

When To Use Postgres Instead

SQLite is not the an­swer to every de­ploy­ment shape. Obelisk also sup­ports Postgres, and that is the right choice when you need higher avail­abil­ity, broader shared scal­a­bil­ity, or other de­ploy­ment prop­er­ties that are bet­ter served by a net­work data­base. It is also the bet­ter fit when asyn­chro­nous repli­ca­tion to ob­ject stor­age is not the dura­bil­ity model you want.

Many work­flow sys­tems do not need that on day one and should not start with more in­fra­struc­ture than their state ac­tu­ally de­mands.

In a large set of cases, a lo­cal SQLite data­base plus Litestream backup to S3 is enough. Add cheap work­ers around it and you get a durable sys­tem with very lit­tle in­fra­struc­ture. For the world of AI agents, that may be the most sen­si­ble de­fault.

Skip to con­tent

Secure your code as you build

We read every piece of feed­back, and take your in­put very se­ri­ously.

Include my email ad­dress so I can be con­tacted

Use saved searches to fil­ter your re­sults more quickly

To see all avail­able qual­i­fiers, see our doc­u­men­ta­tion.

Sign up

You signed in with an­other tab or win­dow. Reload to re­fresh your ses­sion.

You signed out in an­other tab or win­dow. Reload to re­fresh your ses­sion.

You switched ac­counts on an­other tab or win­dow. Reload to re­fresh your ses­sion.

There was an er­ror while load­ing. Please re­load this page.

Notifications

You must be signed in to change no­ti­fi­ca­tion set­tings

[BUG] Login no more pos­si­ble, Android App still works[BUG] Login no more pos­si­ble, Android App still works

You can’t per­form that ac­tion at this time.

Claude Code’s auto-mode per­mis­sion sys­tem is in­ter­nally called the “YOLO Classifier.” That’s the ac­tual vari­able name in yolo­Clas­si­fier.ts. And you can con­fig­ure it with plain English de­scrip­tions of your en­vi­ron­ment, things like “this is a stag­ing server, de­struc­tive op­er­a­tions are ac­cept­able,” that the clas­si­fier reads to de­cide what’s safe to auto-ap­prove. This is­n’t in any doc­u­men­ta­tion.

It’s one of dozens of un­doc­u­mented ca­pa­bil­i­ties buried in the Claude Code source code, which is sit­ting right there in your node_­mod­ules as a pub­licly dis­trib­uted npm pack­age. The of­fi­cial docs cover the ba­sics well enough. But the source code re­veals fields, re­sponse for­mats, and set­tings that dra­mat­i­cally ex­pand what you can build. Everything here works right now, and every ex­am­ple is de­signed to be dropped into your pro­ject as-is.

A note on ver­sion­ing: These find­ings come from @anthropic-ai/claude-code@2.1.87. Undocumented fea­tures can change be­tween re­leases, so treat this as a snap­shot of what’s avail­able to­day. Fields with “EXPERIMENTAL” in their names are ex­plic­itly flagged as un­sta­ble by Anthropic’s own en­gi­neers, and I’ll call those out in­di­vid­u­ally.

Quick ref­er­ence for where every­thing lives:

Settings: ~/.claude/settings.json (personal) or .claude/settings.json (project, shared via git)

Settings: ~/.claude/settings.json (personal) or .claude/settings.json (project, shared via git)

Skills: ~/.claude/skills/<name>/SKILL.md (personal) or .claude/skills/<name>/SKILL.md (project)

Skills: ~/.claude/skills/<name>/SKILL.md (personal) or .claude/skills/<name>/SKILL.md (project)

Agents: ~/.claude/agents/<name>.md (personal) or .claude/agents/<name>.md (project)

Agents: ~/.claude/agents/<name>.md (personal) or .claude/agents/<name>.md (project)

Hook scripts: ~/.claude/hooks/ is a good con­ven­tion. Remember to chmod +x your scripts.

Hook scripts: ~/.claude/hooks/ is a good con­ven­tion. Remember to chmod +x your scripts.

Project-level files in .claude/ can be com­mit­ted to git and shared with your team. Personal files in ~/.claude/ are yours alone.

This is the biggest gap in the doc­u­men­ta­tion. The docs tell you hooks re­ceive JSON on stdin and that exit code 2 blocks an op­er­a­tion. What they don’t tell you is that hooks can re­turn JSON on std­out with event-spe­cific fields that mod­ify Claude Code’s be­hav­ior in real time. The source code re­veals ex­actly what each event type ac­cepts.

PreToolUse hooks can re­turn:

up­date­d­In­put - rewrite the tool’s in­put be­fore it ex­e­cutes. You can mod­ify com­mands mid-flight.

up­date­d­In­put - rewrite the tool’s in­put be­fore it ex­e­cutes. You can mod­ify com­mands mid-flight.

per­mis­sion­De­ci­sion - force “allow” or “deny” with­out prompt­ing the user.

per­mis­sion­De­ci­sion - force “allow” or “deny” with­out prompt­ing the user.

per­mis­sion­De­ci­sion­Rea­son - ex­plain the de­ci­sion (shown in UI).

per­mis­sion­De­ci­sion­Rea­son - ex­plain the de­ci­sion (shown in UI).

ad­di­tion­al­Con­text - in­ject text into the con­ver­sa­tion con­text.

ad­di­tion­al­Con­text - in­ject text into the con­ver­sa­tion con­text.

SessionStart hooks can re­turn:

watch­Paths - set up au­to­matic file watch­ing that trig­gers FileChanged events.

watch­Paths - set up au­to­matic file watch­ing that trig­gers FileChanged events.

ini­tialUser­Mes­sage - prepend con­tent to the first user mes­sage in the ses­sion.

ini­tialUser­Mes­sage - prepend con­tent to the first user mes­sage in the ses­sion.

ad­di­tion­al­Con­text - in­ject con­text that per­sists for the whole ses­sion.

ad­di­tion­al­Con­text - in­ject con­text that per­sists for the whole ses­sion.

PostToolUse hooks can re­turn:

up­dat­edM­CP­ToolOut­put - mod­ify what Claude sees from an MCP tool re­sponse.

up­dat­edM­CP­ToolOut­put - mod­ify what Claude sees from an MCP tool re­sponse.

ad­di­tion­al­Con­text - in­ject con­text af­ter a tool runs.

ad­di­tion­al­Con­text - in­ject con­text af­ter a tool runs.

PermissionRequest hooks can re­turn:

de­ci­sion - pro­gram­mat­i­cally al­low or deny with up­date­d­In­put or up­dat­ed­Per­mis­sions.

de­ci­sion - pro­gram­mat­i­cally al­low or deny with up­date­d­In­put or up­dat­ed­Per­mis­sions.

This is pow­er­ful stuff. Here’s a PreToolUse hook that au­to­mat­i­cally adds –dry-run to any git push com­mand be­fore Claude ex­e­cutes it.

In your set­tings.json:

{ “hooks”: { “PreToolUse”: [{ “matcher”: “Bash”, “hooks”: [{ “type”: “command”, “command”: “~/.claude/hooks/dry-run-pushes.sh” }] }] } }

And the script at ~/.claude/hooks/dry-run-pushes.sh:

#!/bin/bash INPUT=$(jq -r ‘.tool_input.command’ < /dev/stdin) if echo “$INPUT” | grep -q ‘git push’; then jq -n –arg cmd “$INPUT –dry-run” ‘{“updatedInput”: {“command”: $cmd}}’ fi

Claude thinks it’s run­ning git push ori­gin main, but your hook qui­etly rewrites it to git push ori­gin main –dry-run be­fore ex­e­cu­tion. The up­date­d­In­put field is­n’t in any docs.

Here’s a SessionStart hook that watches your con­fig files and in­jects git con­text into every ses­sion.

set­tings.json:

{ “hooks”: { “SessionStart”: [{ “hooks”: [{ “type”: “command”, “command”: “~/.claude/hooks/session-context.sh”, “statusMessage”: “Loading pro­ject con­text…” }] }] } }

~/.claude/hooks/session-context.sh:

#!/bin/bash BRANCH=$(git branch –show-current 2>/dev/null) CHANGES=$(git sta­tus –porcelain 2>/dev/null | wc -l | tr -d ′ ’)

jq -n \ –arg branch “$BRANCH” \ –arg changes “$CHANGES” \ ‘{ “watchPaths”: [“package.json”, ”.env”, “tsconfig.json”], “additionalContext”: “Current branch: \($branch). Uncommitted changes: \($changes) files.” }’

Now Claude Code au­to­mat­i­cally watches your pack­age.json, .env, and tscon­fig for changes, and it knows what branch you’re on and how many un­com­mit­ted files you have be­fore you even type any­thing.

And here’s one that auto-ap­proves read-only bash com­mands with­out prompt­ing.

set­tings.json:

{ “hooks”: { “PreToolUse”: [{ “matcher”: “Bash”, “hooks”: [{ “type”: “command”, “command”: “~/.claude/hooks/auto-approve-readonly.sh” }] }] } }

~/.claude/hooks/auto-approve-readonly.sh:

#!/bin/bash CMD=$(jq -r ‘.tool_input.command’ < /dev/stdin) if echo “$CMD” | grep -qE ‘^(ls|cat|echo|pwd|whoami|date|git sta­tus|git log|git diff)‘; then echo ‘{“permissionDecision”: “allow”, “permissionDecisionReason”: “Safe read-only com­mand”}’ fi

You’re ba­si­cally build­ing your own per­mis­sion clas­si­fier with shell scripts. The per­mis­sion­De­ci­sion field is­n’t in any docs.

The doc­u­mented hook fields are type, com­mand, matcher, time­out, if, and sta­tusMes­sage. The source code parser ac­cepts three more that fun­da­men­tally change how hooks be­have.

once: true fires the hook ex­actly once, then auto-re­moves it. Perfect for first-ses­sion setup:

{ “hooks”: { “SessionStart”: [{ “hooks”: [{ “type”: “command”, “command”: “[ -f .env ] || cp .env.example .env && echo ‘Created .env from tem­plate’”, “once”: true, “statusMessage”: “First-time setup…” }] }] } }

Simple enough to in­line. It checks if .env ex­ists, copies the tem­plate if not, and never runs again.

async: true runs the hook in the back­ground with­out block­ing Claude. Fire and for­get:

{ “hooks”: { “PostToolUse”: [{ “matcher”: “Bash”, “hooks”: [{ “type”: “command”, “command”: “jq ‘{timestamp: now, com­mand: .tool_input.command, ses­sion: .session_id}’ < /dev/stdin >> ~/.claude/audit.jsonl”, “async”: true }] }] } }

That logs every bash com­mand to an au­dit file with­out adding any la­tency to your ses­sion.

asyn­cRe­wake: true is the clever one. It runs in the back­ground like async, so it does­n’t block on the happy path. But if it ex­its with code 2, it wakes the model back up and blocks the op­er­a­tion. Non-blocking when every­thing’s fine, block­ing when some­thing’s wrong:

set­tings.json:

{ “hooks”: { “PostToolUse”: [{ “matcher”: “Write|Edit”, “hooks”: [{ “type”: “command”, “command”: “~/.claude/hooks/scan-secrets.sh”, “asyncRewake”: true, “statusMessage”: “Scanning for se­crets…” }] }] } }

~/.claude/hooks/scan-secrets.sh:

#!/bin/bash FILE=$(jq -r ‘.tool_input.file_path // .tool_response.filePath’ < /dev/stdin) if grep -qE ‘(password|secret|api_key)\s*=’ “$FILE” 2>/dev/null; then exit 2 # Block: se­crets de­tected fi exit 0 # Clean: carry on

This scans every file Claude writes for hard­coded se­crets. If it finds one, it blocks and tells Claude. If not, you never even no­tice it ran.

The doc­u­men­ta­tion cov­ers name, de­scrip­tion, al­lowed-tools, ar­gu­ment-hint, when_­to_use, and con­text. The ac­tual front­mat­ter parser in the source code ac­cepts six more.

model lets you over­ride which model runs the skill. Use haiku for cheap, fast tasks and opus for com­plex analy­sis:

–- name: quick-lint de­scrip­tion: Fast lint check us­ing the cheap­est model model: haiku ef­fort: low al­lowed-tools: Bash, Read ar­gu­ment-hint: “[file]” –- Run the pro­ject lin­ter on: $ARGUMENTS Detect the lin­ter from con­fig (eslint, ruff, clippy) and run it. Report only er­rors, not warn­ings.

That runs on Haiku at low ef­fort, so it’s fast and cheap. For a deep ar­chi­tec­ture re­view you’d want model: opus and ef­fort: max.

ef­fort con­trols how hard the model thinks. low, medium, high, or max. This maps to the same ef­fort sys­tem that in­ter­nally con­trols rea­son­ing depth per re­sponse.

hooks de­fines hooks scoped to when the skill is ac­tive. They reg­is­ter when the skill fires and dereg­is­ter when it com­pletes:

–- name: strict-type­script de­scrip­tion: Write TypeScript with type check­ing on every save al­lowed-tools: Bash, Read, Write, Edit, Grep, Glob hooks: PostToolUse: - matcher: “Write|Edit” hooks: - type: com­mand com­mand: “~/.claude/hooks/typecheck-on-save.sh” sta­tusMes­sage: “Type check­ing…” - type: com­mand com­mand: “~/.claude/hooks/lint-on-save.sh” async: true –- Write TypeScript with strict en­force­ment. Every file you touch gets type-checked and linted au­to­mat­i­cally. $ARGUMENTS

~/.claude/hooks/typecheck-on-save.sh:

#!/bin/bash FILE=$(jq -r ‘.tool_input.file_path // .tool_response.filePath’ < /dev/stdin) [[ “$FILE” == *.ts ]] && npx tsc –noEmit 2>&1 || true

~/.claude/hooks/lint-on-save.sh:

#!/bin/bash FILE=$(jq -r ‘.tool_input.file_path // .tool_response.filePath’ < /dev/stdin) [[ “$FILE” == *.ts ]] && npx es­lint –fix “$FILE” 2>&1 || true

While this skill is run­ning, every TypeScript file Claude writes gets type-checked syn­chro­nously and linted in the back­ground. When the skill fin­ishes, those hooks dis­ap­pear. The scop­ing is clean.

agent del­e­gates the skill to a cus­tom agent:

–- name: deep-re­view de­scrip­tion: Thorough se­cu­rity re­view del­e­gated to the re­view agent agent: se­cu­rity-re­view –- Review the fol­low­ing: $ARGUMENTS

dis­able-model-in­vo­ca­tion: true pre­vents auto-in­vo­ca­tion. Only ex­plicit /skill-name works. Use this for de­struc­tive skills you don’t want fir­ing ac­ci­den­tally.

shell: bash spec­i­fies which shell to use for ex­e­cu­tion.

Custom agents in .claude/agents/ sup­port front­mat­ter fields the doc­u­men­ta­tion does­n’t men­tion.

color sets the UI color: red, or­ange, yel­low, green, blue, pur­ple, pink, or gray. Helps vi­su­ally dis­tin­guish agents when mul­ti­ple are run­ning.

mem­ory is the big one. It gives the agent per­sis­tent mem­ory across in­vo­ca­tions:

user - global, per­sists across all pro­jects

user - global, per­sists across all pro­jects

pro­ject - per-pro­ject per­sis­tence

pro­ject - per-pro­ject per­sis­tence

lo­cal - pri­vate per-pro­ject (gitignored)

lo­cal - pri­vate per-pro­ject (gitignored)

This means you can build an agent that learns. A se­cu­rity re­viewer that tracks past find­ings. A code re­viewer that re­mem­bers your pat­terns across ses­sions. The mem­ory uses the same front­mat­ter for­mat as the auto-mem­ory sys­tem.

–- name: code­base-guide de­scrip­tion: Answer ques­tions about the code­base, learn­ing more with each ses­sion tools: [Read, Grep, Glob, Bash] color: green mem­ory: pro­ject –- You are a code­base guide with per­sis­tent mem­ory. Check your mem­ory first be­fore ex­plor­ing the code.

After an­swer­ing a ques­tion, save use­ful con­text to mem­ory: - Architecture de­ci­sions (type: pro­ject) - Code lo­ca­tions for com­mon tasks (type: ref­er­ence) - Patterns and con­ven­tions (type: feed­back)

Over time, you should an­swer faster be­cause you re­mem­ber where things are.

After a few ses­sions, this agent builds a knowl­edge base about your code­base and starts an­swer­ing from mem­ory be­fore grep­ping.

May 29, 2026

4 min read

ai

ar­ti­cle

I was in Paris the last few days to visit the AI Now Summit by Mistral AI, hop­ing to learn more about their mod­els, plans for the fu­ture of European AI and more. My per­sonal in­sights:

Mistral is no longer just a model com­pany. They’re build­ing the full AI stack: com­pute, mod­els, plat­forms & con­sul­tancy. They own the com­pute (a 40MW data cen­ter in Paris, more data cen­ters com­ing soon, in­clud­ing one in Sweden). They fo­cus on ef­fi­cient, open and be­spoke mod­els that you own and can run on-prem. That seems to be their unique sell­ing point com­pared to Anthropic or OpenAI.

The mes­sag­ing was all about part­ner­ships: col­lab­o­ra­tions with ASML, BNP Paribas, Amazon’s Alexa+ and how they were help­ing them with AI to solve real prob­lems. It was less about up­com­ing new mod­els and tech in­no­va­tion. Something I found dis­ap­point­ing. They did launch Vibe for Work, a prod­uct sim­i­lar to Claude for Work.

When it comes to agen­tic, the har­ness is every­thing. In a talk by Pieter Stock he men­tioned that the model alone is­n’t enough. With a har­ness you add con­text, per­sis­tence and learn­ing. Reasoning is es­sen­tial for this; it’s what lets a sys­tem back­track, re­cover from er­rors and stay trans­par­ent. Skills are the way for or­gan­i­sa­tions to cap­ture best prac­tices, you de­velop these in co­op­er­at­ing with the AI agent.

Specialized small mod­els are their strat­egy. Mistral showed sev­eral ex­am­ples where small, fast and fo­cused mod­els out­per­form the big gen­eral-pur­pose ones when it comes to en­ergy ef­fi­ciency and speed: Document AI for OCR (used by the EU Patent Office to do large scale OCR), Voxtral for mul­ti­lin­gual voice (powering Amazon’s Alexa+ in Europe), and Robostral for in­dus­trial ro­bot­ics with ASML. And also in to­ken-heavy agen­tic ap­pli­ca­tions, speed and ef­fi­ciency are be­com­ing as im­por­tant as raw ca­pa­bil­ity.

Sovereignty and on-prem are their sell­ing points. BNP Paribas runs Mistral mod­els on-prem for KYC in Belgium, with sen­si­tive data stay­ing within the bank’s walls. Abanca is us­ing agent or­ches­tra­tion to han­dle sen­si­tive cus­tomer in­for­ma­tion at a huge scale (more than 1 mil­lion cus­tomers in their app). For European com­pa­nies in reg­u­lated in­dus­tries, this is a good al­ter­na­tive to re­ly­ing on US hy­per­scalers.

A talk that was a bit out of the or­di­nary and that I re­ally en­joyed was about an­cient pa­pyrus doc­u­ments: a re­search team from the Austrian Academy of Sciences fine­tuned a cod­ing LLM by Mistral (Codestral) to read tiny snip­pets of mil­len­nia-old dis­carded pa­pyri that had sat un­pub­lished for decades. This work helps make a col­lec­tion of 180,000 doc­u­ments found in the Egyptian desert ac­ces­si­ble, a job that would have taken more than 2000 years with­out AI. A beau­ti­ful ex­am­ple of how AI can also help the hu­man­i­ties.

All in all, the sum­mit left me with a bet­ter pic­ture of Mistral’s vi­sion for Europe an AI: maybe not to win the race for AGI (Artificial General Intelligence), but to be­come the European full-stack AI part­ner that de­liv­ers real re­turn on in­vest­ment NOW. Whether that pays off will de­pend on more European com­pa­nies com­mit­ting to this, but the com­bi­na­tion of open mod­els, on-prem de­ploy­ment and en­ter­prise part­ner­ships could be ap­peal­ing to many big or­ga­ni­za­tions in the EU. And hon­estly, it’s good to see a se­ri­ous European player at the table. The days of blindly re­ly­ing on US tech gi­ants is com­ing to an end.

Post-script: Many thanks to Mistral for the in­vi­ta­tion. The lo­ca­tion was just per­fect, in the mid­dle of Paris near the Louvre, and it was re­ally some­thing to be in the place where Paris Fashion Week nor­mally takes place: with co-founders and other speak­ers on the cat­walk.

This ar­ti­cle was also pub­lished on LinkedIn and Hacker News. Feel free to join the dis­cus­sion there.

Mauro Bieg on May 23, 2026

What AI is do­ing to the jobs of pro­gram­mers feels very fa­mil­iar to a lot of us fron­tend de­vel­op­ers — be­cause it has hap­pened to us be­fore.

Let’s first look at the trans­for­ma­tion of the fron­tend and agen­tic cod­ing through the lens of deskilling, and then look at both changes through the lens of a higher level of ab­strac­tion. Finally, we’ll look at pre­vi­ous changes, like the ad­vent of copy-pasta from Stack Overflow, and how the Bauhaus move­ment re­acted to ris­ing in­dus­tri­al­iza­tion.

Deskilling

Just like AI is deskilling pro­gram­ming now, JavaScript frame­works have deskilled fron­tend de­vel­op­ment in the last decade. As some­one who started with HTML/CSS and a bit of PHP, later did Ruby on Rails, and then was fron­tend team lead of a ma­jor Swiss news­pa­per (Next.js at the time), I’ve seen the trans­for­ma­tion first-hand. And no need to take my word for it! I’m not the first to say so. Alex Russell called it Frontend’s Lost Decade.

What is deskilling? From Wikipedia:

Deskilling is the process by which skilled la­bor within an in­dus­try or econ­omy is elim­i­nated by the in­tro­duc­tion of tech­nolo­gies op­er­ated by semi- or un­skilled work­ers. This re­sults in cost sav­ings […] and re­duces bar­ri­ers to en­try, weak­en­ing the bar­gain­ing power of [workers].

Deskilling is the process by which skilled la­bor within an in­dus­try or econ­omy is elim­i­nated by the in­tro­duc­tion of tech­nolo­gies op­er­ated by semi- or un­skilled work­ers. This re­sults in cost sav­ings […] and re­duces bar­ri­ers to en­try, weak­en­ing the bar­gain­ing power of [workers].

Let’s see how this ap­plies to the fron­tend, and then to agen­tic cod­ing.

The deskilling of the fron­tend

A lot of pro­gram­mers may not know this, but fron­tend used to be a highly spe­cial­ized skill, re­quir­ing knowl­edge of se­man­tic HTML, CSS, the dif­fer­ences of var­i­ous browsers, ac­ces­si­bil­ity, pro­gres­sive en­hance­ment, net­work per­for­mance, in­ter­face de­sign and user test­ing — to just name a few. To dis­tin­guish what they’re do­ing from what “frontend” has be­come, prac­ti­tion­ers of this ar­cane art nowa­days of­ten re­fer to it as the “front of the fron­tend”.

The deskilling of the fron­tend was the in­tro­duc­tion of frame­works and other tool­ing that treats the browser as a mere com­pi­la­tion tar­get — just like any other app run­time (e.g. JVM or iOS). Then you can just load in the mon­stros­ity that is a Shadcn ra­dio but­ton, and don’t need to un­der­stand the un­der­ly­ing HTML, any sub­tleties in­volv­ing dif­fer­ent browsers, page load per­for­mance, and ac­ces­si­bil­ity.

As the Wikipedia quote above points out, this “results in cost sav­ings” for busi­nesses, since they then can eas­ily put any gen­eral pro­gram­mer to work on the fron­tend. Often, a “full-stack de­vel­oper” is un­for­tu­nately not some­body who deeply un­der­stands the fron­tend and the back­end, but a gen­er­al­ist who just knows enough to wran­gle a JavaScript frame­work to do both. This al­lows busi­nesses to eas­ily switch pro­gram­mers around be­tween dif­fer­ent pro­jects. The same gen­er­al­ist can even also do na­tive apps with React Native and Electron! To fin­ish the Wikipedia quote: this “reduces bar­ri­ers to en­try” (which is some­thing I’ve al­ways cher­ished), but it also “weakens the bar­gain­ing power of work­ers”.

AI is deskilling pro­gram­ming

What’s cur­rently hap­pen­ing to pro­gram­mers more gen­er­ally seems very sim­i­lar to what web de­vel­op­ers in par­tic­u­lar have been go­ing through al­ready. The skilled job of writ­ing code man­u­ally is be­ing “eliminated by the in­tro­duc­tion of tech­nolo­gies, op­er­ated by semi- or un­skilled work­ers.”

We still don’t know ex­actly what skillset the work­ers wran­gling agen­tic AI will need to have at the end of this trans­for­ma­tion, and at what price point we’ll ar­rive at — for both labour, and for lo­cal and re­mote LLMs. But it is al­ready clear now, that busi­nesses ab­solutely will use this tech­nol­ogy for cost sav­ings and weak­en­ing of the bar­gain­ing power of work­ers.

A pro­found sense of loss

Just like ar­ti­sans and crafts­men that were re­placed by as­sem­bly line work­ers more than a cen­tury ago, we feel a pro­found sense of loss. We grieve that a skill, that we spent half a life­time hon­ing, is not be­ing val­ued by the mar­ket any­more. And we’re sad­dened that the new process re­sults in lower qual­ity work, and that a lot of peo­ple just don’t seem to care.

Operating at a higher level of ab­strac­tion

An al­ter­na­tive way to look at “deskilling” is of course to ar­gue that this is just in­creas­ing ef­fi­ciency us­ing au­toma­tion. And what en­gi­neer does­n’t like au­tomat­ing things? It’s a big part of our job af­ter all!

In this fram­ing, the new tech­nol­ogy in­tro­duced sim­ply works on a higher level of ab­strac­tion, al­low­ing the per­son op­er­at­ing it to fo­cus on the big­ger pic­ture, with­out hav­ing to bother about unim­por­tant de­tails. But ex­actly which de­tails are deemed “unimportant” is a very con­se­quen­tial and some­times sub­jec­tive de­ci­sion. And even­tu­ally, the de­tails al­ways leak through.

“Modern” fron­tend: a tower of leaky ab­strac­tions

It’s com­mon for an ab­strac­tion to come at a cost of per­for­mance. But since com­put­ers are very fast nowa­days, we were of­ten will­ing to trade some run­time per­for­mance for in­creased de­vel­oper pro­duc­tiv­ity (garbage col­lec­tion is one ex­am­ple). And for high-pow­ered servers un­der mod­er­ate load, this is a very sen­si­ble trade­off. But mo­bile phones on slow net­works are a dif­fer­ent beast.

By us­ing a heavy client-side JavaScript frame­work like React, and a lot of pack­ages from that ecosys­tem, you’re ab­stract­ing over things like ac­ces­si­bil­ity, and per­for­mance on lower-end phones, or on slow net­works. In ef­fect, you’re choos­ing not to think about those things, and you’re choos­ing not to care about them.

Agentic cod­ing: an un­de­ter­min­is­tic ab­strac­tion

By us­ing agen­tic AI to code a fea­ture or fix a bug, you’re de­scrib­ing the change at a higher level of ab­strac­tion, writ­ing fewer words than writ­ing all code by hand. The AI will fill in the de­tails you omit­ted by look­ing at its train­ing data and sur­round­ing con­text — some­times guess­ing well, other times not. Whether you find this use­ful or not de­pends to a large de­gree on your opin­ions on what’s im­por­tant when cod­ing.

But com­pared to pre­vi­ous ab­strac­tions in pro­gram­ming, agen­tic cod­ing is a very leaky ab­strac­tion. It’s not de­ter­min­is­tic like a com­piler, and slight vari­a­tions in in­put or model can give very dif­fer­ent re­sults. That has led peo­ple to com­pare AI to “junior en­gi­neers”, since those are also not de­ter­min­is­tic. But one dif­fer­ence is of course that peo­ple are ca­pa­ble of learn­ing, with­out you hav­ing to end­lessly tweak their AGENTS.md or SKILL.md files.

LLMs as an ex­ten­sion of copy-pasta from Stack Overflow

As such, the best anal­ogy for us­ing LLMs I’ve found so far is how a Google search used to be­have. It was a skill all of us had to learn at some point: choos­ing just the right key­words, so that the right fo­rum post (and later Stack Overflow post) would sur­face on the first Google re­sults page. Just like prompt­ing an LLM, in or­der to re­turn the right as­sem­blage of its train­ing data, a fuzzy web search is a lookup in a very high-di­men­sional space. And just like with LLMs, the lookup used to be very sen­si­tive to slight vari­a­tions of word­ing, and changes to Google’s search in­dex.

In re­cent years, among other things, Google has changed the search to nor­mal­ize en­tered terms much more ag­gres­sively. For peo­ple who were not versed in the dark art of Google-fu, this made the search much eas­ier to use. But for those of us that had ac­quired that skill, it made Google search much less pow­er­ful. Specialized key­words used to bring us di­rectly to an an­swer. Now they get nor­mal­ized to a syn­onym, or to a closely as­so­ci­ated word, and we land on a more generic page.

But the ad­vent of Google, and later Stack Overflow, ir­re­versibly changed pro­gram­ming. Instead of read­ing the f***ing man­ual, pro­gram­mers could now just blindly copy & paste an­swers from Stack Overflow, and sur­pris­ingly of­ten got some­thing that kind of worked. Seen through this lens, LLMs are just a con­tin­u­a­tion of the same trend: tools and ab­strac­tions that make peo­ple that know what they’re do­ing slightly faster, and en­able peo­ple who don’t re­ally know what they’re do­ing to ar­rive at some­thing that of­ten kind of works. And you know what? That’s great!

But we should­n’t fool our­selves: at some point the ab­strac­tion will leak. And then some­body has to in­vest the time to ac­tu­ally deeply un­der­stand what’s go­ing on — and fix it. Just like we taught ju­nior pro­gram­mers to read and un­der­stand the Stack Overflow an­swer be­fore us­ing it, now we need to teach peo­ple to read and un­der­stand the stuff the LLM spits out, and to un­der­stand how it fits into the ex­ist­ing code­base.

Does qual­ity mat­ter?

Unfortunately, some pro­gram­mers never pro­gressed to the stage of try­ing to re­ally un­der­stand the Stack Overflow an­swer. Why bother if it works? And while not pub­licly ac­knowl­edged, a lot of com­pa­nies were ac­tu­ally happy with this ap­proach. What’s dif­fer­ent now is that com­pa­nies go out of their way to pub­licly pro­claim how much AI they’re us­ing, with­out even pre­tend­ing to look at the out­put.

While there are def­i­nitely valid use-cases for LLMs, there are also lots of new ways to mess up your code, and to mess up your or­ga­ni­za­tion’s com­mu­ni­ca­tion and processes. This seems es­pe­cially chal­leng­ing to fig­ure out as a team. Just like with code re­view, there are widely dif­fer­ing views on how to use and in­te­grate LLMs into our work­flows (if at all). And if the team is not aligned on what things they value, this can re­ally throw a wrench in the works.

It’s also a sad fact of life that a lot of com­pa­nies are do­ing very well, even though they’re churn­ing out abysmal soft­ware. Despite what we pro­gram­mers would like to be­lieve, busi­ness suc­cess and soft­ware qual­ity are very rarely cor­re­lated. Usually, other fac­tors sim­ply dom­i­nate. Often, soft­ware pro­jects are treated as black boxes, known to fail about as of­ten as they suc­ceed, and are de­risked in var­i­ous ways (in the worst case, a dif­fer­ent team will have an­other go at it).

And it’s been the same for fron­tend de­vel­op­ment. Unfortunately, a ter­ri­ble web­site has a rel­a­tively small im­pact on the bot­tom line. Does a slow web­site and lots of cookie ban­ners hurt con­ver­sion? Sure, but that ef­fect is rel­a­tively small com­pared to other fac­tors like brand loy­alty and pric­ing. And all the com­peti­tors have slow web­sites as well! Besides, no­body was ever fired for choos­ing React.

Does that mean we should stop car­ing about our users and about our craft? No. But it does mean that it’s be­come even harder to find a job where you’re al­lowed to do so. Hopefully, the pen­du­lum will swing back a bit, once the hype has blown over, and we’ve a bet­ter un­der­stand­ing what tasks LLMs are ac­tu­ally a good fit for and what not. But it’s safe to say that our pro­fes­sion will not be the same as be­fore.

The Bauhaus move­ment

What did pre­vi­ous gen­er­a­tions of crafts­peo­ple do when every­day goods and build­ings sud­denly could be mass-pro­duced by in­dus­trial processes? One re­ac­tion was to copy the style of old, and make the in­dus­try crank out wid­gets and build­ings that at least looked like they were hand­crafted.

Countering this trend of his­tori­cism, an al­ter­na­tive ap­proach was de­vel­oped by the Bauhaus move­ment of the early 20th cen­tury. Instead of pit­ting fac­tory work­ers against crafts­peo­ple, their stated goal was to have them work to­gether, and re­de­velop the arts and crafts with in­dus­trial man­u­fac­tur­ing processes in mind. The Bauhaus urged de­sign­ers to go back into the work­shops, and work with the ma­te­ri­als them­selves. Still with the goal of ar­riv­ing at de­signs that would then be mass pro­duced. But al­ways keep­ing the end user and mind, and deeply car­ing about them. Modern in­dus­trial de­sign, as ex­em­pli­fied by Dieter Rams and Johnathan Ive, can trace its roots straight back to the Bauhaus.

Caring about qual­ity and the user

How can we trans­late this line of think­ing to soft­ware?

Software sits some­where in-be­tween craft on one hand (the pro­gram we write gets shipped “as is” to our users, with­out first go­ing through a man­u­fac­tur­ing step), and in­dus­trial de­sign on the other hand (we ship the same thing to po­ten­tially thou­sands of users, who we never get to see in­ter­act­ing with our prod­uct).

The need for be­ing able to write code by hand is clear. Just like in­dus­trial de­sign­ers need to know the ma­te­ri­als their prod­ucts will be made of, a web de­signer needs to be in­ti­mately fa­mil­iar with HTML and CSS.

While it’s great that tools like Google, Stack Overflow, ready-to-use li­braries, and now LLMs are mak­ing things eas­ier for be­gin­ners, this also means that the nat­ural bar­rier to get any­thing work­ing at all is con­tin­u­ously be­ing low­ered.

While there is a high bar­rier to en­try to a field, it’s dif­fi­cult to find ab­solutely ter­ri­ble pieces of work. Once a crafts­man was taught how to build a wooden chair, they in­vari­able were also taught how to not do a ter­ri­ble job at it.

The in­dus­tri­al­iza­tion en­abled lots of cheap plas­tic prod­ucts, de­signed by peo­ple who did­n’t take the time to think how they would be used and by whom — yet good in­dus­trial de­sign is still a thing. The in­ven­tion of the word proces­sor en­abled lots of ter­ri­bly for­mat­ted doc­u­ments — yet ty­pog­ra­phy and graphic de­sign still ex­ist. And soft­ware like Wix and Next.js en­abled the cre­ation of lots of web­sites that load ter­ri­bly slow and are not ac­ces­si­ble — yet there are still prac­ti­tion­ers of the front of the fron­tend out there. Likewise, AI is en­abling lots of AI slop — but this does­n’t mean we don’t still need peo­ple who know what they’re do­ing, and who care about what they’re do­ing.

How will it shake out?

But like in other in­dus­tries, do­ing things prop­erly will be­come an ever smaller slice of the pie. But be­cause it’s now eas­ier and cheaper to do so, the size of the pie will con­tinue to grow. It’s very hard to say at this point in time whether the ab­solute num­ber of peo­ple, be­ing payed to do things well, will in­crease or de­crease. If you ask me, there are way too many poorly de­signed plas­tic prod­ucts out there. And it’s a sad fact that de­sign­ing new type faces is not a sus­tain­able full-time job any­more. But at the same time, there is still so much great work be­ing done in all those do­mains.

And you know what? Sometimes churn­ing out a quick pro­to­type or MVP is the right thing to do. If you don’t have prod­uct-mar­ket-fit yet, quick it­er­a­tion and learn­ing is more im­por­tant than fu­ture-proof­ing every­thing. But you need to know what you’re try­ing to learn, and how you val­i­date those learn­ings. And when the time has come, it’s usu­ally bet­ter to take a step back and do things right from the start. For ex­am­ple, good per­for­mance is very hard to achieve in a badly ar­chi­tected fron­tend later. And it’s eas­ier to start with a sim­ple stack and add func­tion­al­ity later on than the re­verse. Both of these, Mastro ex­plic­itly en­cour­ages.

For any part of the sys­tem, you need to know what trade­offs you’re mak­ing, and then de­cide whether you should buy a ser­vice, use an open source li­brary, have an LLM churn it out, or write it your­self. When the hype has died down, the in­dus­try will re­al­ize it’s just one more tool in the tool­box. But un­til then, we’re go­ing to see a lot of ugly things: ugly code, bro­ken com­mu­ni­ca­tions, and aw­ful lay­offs un­der the guise of AI.

Stay up­dated 👨‍🍳

Follow us on Bluesky, or add our blog to your RSS reader (feed link).

Mastro is the sim­plest web frame­work and sta­tic site gen­er­a­tor yet.

Discover Mastro →