Today, I’m proud to an­nounce Homebrew 6.0.0. The most sig­nif­i­cant changes since 5.1.0 are a new tap trust se­cu­rity mech­a­nism, the new faster, smaller, de­fault in­ter­nal Homebrew JSON API, sand­box­ing on Linux, bet­ter de­faults in­formed by our user sur­vey, many brew bun­dle im­prove­ments, im­proved per­for­mance and ini­tial sup­port for ma­cOS 27 (Golden Gate).

✨ Highlights since 5.1.0

🔐 Tap trust

Homebrew 6.0.0 in­tro­duces tap trust. A third-party tap can con­tain ar­bi­trary, un­sand­boxed Ruby that runs on your ma­chine, so Homebrew now re­quires taps (and tap-qual­i­fied for­mu­lae and casks) to be ex­plic­itly trusted be­fore their code is eval­u­ated or run. This re­duces the risk from ma­li­cious or com­pro­mised taps while leav­ing the of­fi­cial Homebrew taps trusted by de­fault. See the new Tap-Trust doc­u­men­ta­tion for de­tails.

Homebrew en­forces ini­tial tap trust so un­trusted taps are flagged be­fore their code runs, trusts qual­i­fied tap items be­fore in­stall, stops auto-tap­ping un­trusted taps, pins tap al­low, for­bid and trust lists to re­motes and uses tap trust when eval­u­at­ing all for­mu­lae and casks.

brew tap gains com­mands for man­ag­ing tap trust, can trust a tap by its re­mote URL, brew trust adds a –json=v1 flag and brew tap-info adds a trusted field.

brew bun­dle ho­n­ours the trusted: op­tion and brew bun­dle dump records trusted bun­dle en­tries, mark­ing cus­tom-re­mote taps as trusted.

docs.brew.sh has new pages, in­clud­ing Tap-Trust, ex­plain­ing Homebrew’s new tap trust model, and Homebrew trusts taps in test-bot.

⚡ Default in­ter­nal JSON API

The in­ter­nal JSON API is now the de­fault, ad­vanc­ing the smaller API that Homebrew re-en­abled and turned on for de­vel­op­ers re­cently. It com­bines all Homebrew’s meta­data into a sin­gle down­load, so brew up­dates faster and talks to the net­work less. It was opt-in via HOMEBREW_USE_INTERNAL_API since 5.0.0; that vari­able is now dep­re­cated (see be­low).

🐧 Linux sand­box

The Linux Bubblewrap sand­box aligns Linux with ma­cOS, where build, test and postin­stall phases al­ready run sand­boxed. It is on by de­fault for de­vel­op­ers, Homebrew moved its ma­cOS sand­box logic to share code, im­proved Linux sand­box be­hav­iour (with Homebrew/homebrew-core set­ting the sand­box env in CI), hard­ened sand­boxed in­stall phases, sand­boxed cask ex­e­cutable hooks, al­lowed logs in the build sand­box, in­stalled Bubblewrap on hosted Ubuntu and skips sand­box setup for syn­tax-only jobs.

⚙️ Better de­faults

Following our Homebrew user sur­vey, we have made many changes based on the re­sults. The most no­table is mak­ing ask mode the de­fault for de­vel­op­ers, so brew in­stall and brew up­grade show a de­pen­dency sum­mary and con­fir­ma­tion prompt be­fore mak­ing changes.

Homebrew adds ask de­pen­dency plans and cask sup­port, ac­cepts one-key ask con­fir­ma­tions and aligns ask dry-run prompts.

Homebrew fetches ask up­grades to­gether, prints the ask up­grade sum­mary sooner, skips the up­grade ask prompt when empty, adds a fi­nal brew up­grade sum­mary and ex­plains the up­grade meta­data fetch.

📦 brew bun­dle

brew bun­dle gains many im­prove­ments, most no­tably par­al­lel for­mula in­stal­la­tion that now runs jobs au­to­mat­i­cally by de­fault, plus npm and krew ex­ten­sions, wider cleanup sup­port and, on Windows, winget sup­port.

Homebrew adds cleanup sup­port to npm, cargo, go and uv ex­ten­sions and asks be­fore re­mov­ing dur­ing cleanup.

Homebrew runs brew bun­dle krew via kubectl-krew di­rectly, re­spects CARGO_HOME and friends for cargo, adds a –describe flag to brew bun­dle add and tries mas in­stall be­fore falling back to mas get.

Homebrew adds bun­dle type dis­able flags, im­proves check guid­ance and checks for­mula link sta­tus.

Homebrew se­ri­alises for­mula locks, makes non-core DSLs a sin­gle file, re­moves de­scrip­tion com­ments from brew bun­dle/​re­mover and avoids pars­ing the out­put of brew ser­vices list.

brew bun­dle per­forms npm in­stalls more se­curely.

🏎️ Performance

Homebrew is faster across the board, with startup per­for­mance tweaks, a ~30% faster brew leaves, par­al­lelised bot­tle tab fetch­ing on up­grade and less work load­ing Ruby li­braries at startup.

🍎 ma­cOS 27 (Golden Gate)

Homebrew adds ini­tial sup­port for ma­cOS 27 (Golden Gate).

🔮 Upcoming changes

ma­cOS 27 (Golden Gate) drops Intel sup­port, so per our Support Tiers: in September 2026, ma­cOS Intel x86_64 moves to Tier 3 with no CI sup­port and no new bot­tles (binary pack­ages) built for ma­cOS Intel; in September 2027, ma­cOS Intel x86_64 will be un­sup­ported en­tirely and all re­lated code deleted.

The mas­ter to main mi­gra­tion be­gun in 4.6.0 con­tin­ues: more repos­i­to­ries no longer up­date mas­ter, GitHub Actions warn @master users to mi­grate to @main and the sync-de­fault-branches work­flows are re­moved from Homebrew/homebrew-cask and Homebrew/homebrew-core.

Casks that fail ma­cOS Gatekeeper checks, dep­re­cated in 5.0.0, re­main on track to be dis­abled in September 2026.

🔒 Security

🚨 Security ad­vi­sories

Homebrew pub­lished three se­cu­rity ad­vi­sories:

The POST down­load strat­egy by­passed the doc­u­mented HTTPS-to-HTTP redi­rect pro­tec­tion by dis­card­ing the re­solved URL (GHSA-7699-qf8c-q47m), fixed by en­forc­ing se­cure redi­rects.

Root code ex­e­cu­tion was pos­si­ble via Git hooks in the ma­cOS .pkg postin­stall (GHSA-6689-q779-c33m), fixed by clean­ing Homebrew git state and re­plac­ing the in­staller git di­rec­tory.

The ma­cOS in­staller pack­age trusted a user-con­trolled /var/tmp plist and could as­sign Homebrew own­er­ship to a lo­cal at­tacker (GHSA-59v8-x8q4-px5c), fixed by tweak­ing the ma­cOS .pkg pack­age-user plist han­dling.

🛡️ Other se­cu­rity im­prove­ments

Homebrew fil­ters sen­si­tive en­vi­ron­ment vari­ables dur­ing Ruby eval­u­a­tions and de­fers HOMEBREW_* en­vi­ron­ment se­crets to down­load time.

Homebrew runs for­bid­den checks for casks and for­mu­lae be­fore down­load and lets you re­quire check­sums for casks with HOMEBREW_CASK_OPTS_REQUIRE_SHA.

Homebrew links to a shared se­cu­rity pol­icy.

🗑️ Deprecations

Homebrew dep­re­cates de­fault opt-ins.

Homebrew dep­re­cates now-de­fault bun­dle and in­ter­nal API en­vi­ron­ment vari­ables such as HOMEBREW_BUNDLE_NO_SECRETS and HOMEBREW_USE_INTERNAL_API.

Homebrew marks un­used op­tions for dep­re­ca­tion.

Various other Homebrew 6.0.0 dep­re­ca­tions.

Homebrew’s SBOM sup­port is now opt-in with HOMEBREW_SBOM.

🎁 Features

🖥️ Casks

Homebrew can pin casks and sup­ports casks in brew miss­ing.

Homebrew adds AppImage sup­port for Linux and im­ple­ments a Linux freedesk­top trash for casks.

Homebrew im­proves cask up­grades by shar­ing up­grade down­load queues, mov­ing up­grade sum­maries be­fore fetch, adding a quit opt-out and re­open­ing closed apps dur­ing up­grade.

Homebrew im­proves au­to_up­dates casks: im­prov­ing how they up­date, re­fin­ing the be­hav­iour fur­ther, gat­ing auto-up­dates be­hind opt-in and up­grad­ing them when the bun­dle ver­sion is stale.

cask adds a gen­er­ate_­com­ple­tion­s_from_ex­e­cutable DSL ar­ti­fact and in­cludes re­solved ar­ti­fact tar­gets in JSON out­put.

Homebrew shows a cask ver­sion tran­si­tion in per-cask up­grade out­put, skips valid cached cask fetches, speeds up cask backup copies and has caskroom use the user’s pri­mary group on Linux.

brew doc­tor and brew cleanup han­dle cor­rupt Caskroom di­rec­to­ries.

💻 Operating sys­tem sup­port

Homebrew makes Linux cask re­quire­ments ex­plicit, aligns cask ma­cOS de­pen­den­cies, sup­ports bare de­pend­s_on :macos in casks, tracks ma­cOS sup­port ex­plic­itly and emits Linux vari­a­tions for casks with Linux check­sums.

Homebrew adds a max­i­mum ma­cOS for cask de­pen­den­cies. Homebrew/homebrew-cask adopts the new de­pend­s_on max­i­mum_­ma­cos: syn­tax and fixes its ma­cOS de­pen­den­cies in Homebrew/homebrew-cask and Homebrew/homebrew-core.

Homebrew adds M5 and M5 Pro/Max CPU recog­ni­tion and caps the OCLP tier when ma­cOS is out­dated.

Homebrew la­bels WSL an­a­lyt­ics, shows the Windows build on WSL in brew con­fig and moves the wsl? boolean from OS::Linux up to the OS mod­ule.

🚰 Taps

Homebrew recog­nises more equiv­a­lent tap re­mote forms, ig­nor­ing a .git suf­fix when match­ing GitHub re­motes and con­sol­i­dat­ing tap re­mote nor­mal­i­sa­tion. (and more)

Homebrew han­dles for­mu­lae and casks more uni­formly across com­mands, in­stalls ex­plic­itly re­quested taps and stops im­plicit tap in­stal­la­tion.

Homebrew uses work­trees for lo­cal core taps and blocks work­tree up­dates.

Homebrew shares full-name pars­ing helpers and uses full-name helpers for split names.

ℹ️ brew info and brew tap-info

brew info out­put is clearer: more con­sis­tent and help­ful, with a Binaries sec­tion list­ing ex­e­cuta­bles, a clearer re­cur­sive run­time de­pen­den­cies line, clearer same-named con­flicts and shad­owed for­mu­lae and a list ver­sions JSON out­put.

brew info shows in­stalled state bet­ter: the up­grade tar­get for out­dated @-versioned for­mu­lae, in­stalled de­pen­dents with –verbose, dep­re­cated and dis­abled pack­ages in in­stall sta­tus, in­stalled for­mu­lae re­solved from the re­ceip­t’s tap with a shad­ow­ing warn­ing, the in­stalled ver­sion and an up­grade hint on the head­line, other in­stalled ver­sions and an in­stalled info in­ven­tory.

brew info and brew tap-info skip the unin­stalled marker when not a prob­lem, show more tap info for pack­ages and brew tap-info lists for­mu­lae and casks.

brew which-for­mula shows in­stall sta­tus and Homebrew shows quar­an­tine script us­age.

🆕 New com­mands, flags and out­put

brew exec is a new com­mand, like npx, that sup­ports for­mu­lae en­vi­ron­ments.

brew as-con­sole-user is a new com­mand for run­ning Homebrew as the right user un­der MDM/root en­vi­ron­ments and brew up­date <formula> is aliased to up­grade.

Homebrew ti­dies help and com­ple­tions: omit­ting aliases from com­ple­tions, hid­ing HOMEBREW_CASK_OPTS_* from help, hid­ing main­tainer com­mands and hid­ing hide_from_­man_­page com­mands from brew com­mands.

Homebrew avoids in­stall warn­ing an­no­ta­tions and warns when for­mula ex­e­cuta­bles are shad­owed on PATH.

🧊 Cooldowns, livecheck and bump­ing

Homebrew adds down­load cooldowns for Bundler, RubyGems livecheck, npm and pip de­faults, PyPI re­source res­o­lu­tion and npm and PyPI in bump to avoid up­stream sup­ply-side se­cu­rity risks.

Homebrew prints bump skip sta­tus, mes­sages and er­rors and checks RubyGems li­cences.

Homebrew re­spects livecheck throt­tle days in au­dit, adds livecheck throt­tling by days and speeds up the for­mula throt­tle days check.

⬇️ Downloads and fetch­ing

brew fetch –all-platforms fetches every vari­ant, Homebrew prints down­load er­ror de­tails when us­ing con­cur­rency, pre­serves par­tial down­loads on net­work er­rors, avoids cached man­i­fest down­loads and hints when a down­load is HTML, not a bi­nary.

Homebrew avoids re­dun­dant Caskroom chgrp.

🛎️ Services

Homebrew starts sys­temd timers for ser­vices, cre­ates ser­vice path di­rec­to­ries au­to­mat­i­cally (with Homebrew/homebrew-core adopt­ing the new ser­vice path cre­ation logic) and au­dits re­dun­dant ser­vice path setup.

brew ser­vices no longer fails to load with –sudo-service-user.

🧪 Formulae and pack­ag­ing

Homebrew adds the VCS re­vi­sion as scm_re­vi­sion in the tab, sup­ports in-repos­i­tory patch files, sup­ports CPS meta­data di­rec­to­ries and in­cludes patches in for­mula to_hash.

Homebrew re­spects in­stalled de­pen­dents dur­ing au­tore­move and cross-checks au­tore­move can­di­dates against for­mula de­f­i­n­i­tions.

🪜 Install steps frame­work

The in­stall steps frame­work ex­presses com­mon postin­stall, pre­flight and post­flight be­hav­iour as or­dered, lit­eral-only DSL data that is ex­posed through the JSON APIs. Where a for­mula or cask only does sim­ple file prepa­ra­tion, it no longer needs to down­load and eval­u­ate a Ruby file at in­stall time. Homebrew adds for­mula in­stall steps, cask in­stall steps, an au­dit for for­mula in­stall steps, in­stall step re­build ac­tions, re­build step meth­ods, re­build step RuboCop checks and an au­dit of cask flight step con­ver­sions; home­brew/​core and home­brew/​cask adopt the new DSLs (post_install_steps, postin­stall and flight steps). In home­brew/​core and home­brew/​cask this cov­ers a large share of post_in­stall and *flight blocks (creating di­rec­to­ries, touch­ing mark­ers, mov­ing and sym­link­ing files), with more op­er­a­tion types planned.

🔀 Other changes

brew vulns is a new Homebrew tap and sub­com­mand that checks in­stalled pack­ages for known vul­ner­a­bil­i­ties 🔒.

Homebrew warns for Nix-managed Homebrew.

🧹 Internals, typ­ing and refac­tors

Homebrew re­places brew which-up­date, uses an AST for source rewrites and en­forces pub­lic API vis­i­bil­ity and docs.

Homebrew re­works com­mand pars­ing: parser sub­com­mand scaf­fold­ing, con­vert­ing the bun­dle, ser­vices and re­main­ing sub­com­mands, scop­ing sub­com­mand op­tion con­straints and us­age help, and no longer re­strict­ing global op­tions to sub­com­mands.

Homebrew lim­its Sorbet run­time de­faults and lim­its re­cur­sive Sorbet in test-bot.

🛠️ Continuous in­te­gra­tion and de­vel­oper tool­ing

The Ubuntu 24.04 CI mi­gra­tion flagged in 5.1.0 for 6.0.0 has now landed, rais­ing the Linux base­line.

We’re check­ing if you’re a real per­son and not an au­to­mated bad bot. Usually, the captcha be­low will com­plete it­self. If it does­n’t, sim­ply click the check­box in the captcha to ver­ify. Once ver­i­fied, you’ll be taken to the page you wanted to visit.

If for some rea­son af­ter ver­i­fy­ing the captcha above, you are con­stantly be­ing redi­rected to this ex­act same page to re-ver­ify the captcha again, then please click on the but­ton be­low to get in touch with the sup­port team.

Even as Donald Trump boosts coal over clean en­ergy, so­lar power is hit­ting new mile­stones in the US and re­mains the lead­ing source of new power.

Data re­leased on Wednesday by the global en­ergy think­tank Ember, along with a re­port by the Solar Energy Industries Association (Seia) and an­a­lyt­ics firm Wood Mackenzie, show the con­tin­ued growth of so­lar and de­cline of coal in the United States de­spite fed­eral pol­icy. In May, for the first time, so­lar sup­plied more of the na­tion’s elec­tric­ity than coal, or 12.8%, Ember said. Coal sup­plied 12.2%, its fourth-low­est monthly share ever.

“For years so­lar power has risen in the US elec­tric­ity mix,” said Nicolas Fulghum, se­nior en­ergy and data an­a­lyst at Ember. “At the same time, coal power has lost its sta­tus, first as the largest source in the US mix, and then grad­u­ally over the years has fallen even fur­ther.”

Solar also be­came the third-largest source of elec­tric­ity in the US in May, be­hind nat­ural gas and nu­clear, Fulghum said. Coal gen­er­a­tion hit an all-time monthly low in April and re­bounded only mod­estly in May, al­low­ing in­creas­ing so­lar gen­er­a­tion to over­take coal, he added.

Electricity is pro­duced by con­vert­ing sources of en­ergy — fos­sil fu­els, re­new­able re­sources and nu­clear — into elec­tri­cal power. Burning coal, oil and nat­ural gas for elec­tric­ity emits car­bon diox­ide, trap­ping heat in the at­mos­phere and warm­ing the planet. By con­trast, so­lar, wind, ge­ot­her­mal, hy­dropower and nu­clear are car­bon-free.

After about two decades of es­sen­tially flat elec­tric­ity con­sump­tion in the US, elec­tric­ity de­mand is in­creas­ing to power ar­ti­fi­cial in­tel­li­gence, grow do­mes­tic man­u­fac­tur­ing and elec­trify trans­porta­tion and heat­ing. Fulghum said he ex­pected to see more months when so­lar ex­ceeds coal gen­er­a­tion, be­fore over­tak­ing it on an an­nual ba­sis in a few years.

These mile­stones sig­nify that so­lar “has stay­ing power” at a time when there is less sup­port for re­new­able en­ergy at the fed­eral level, he added.

Wind and so­lar com­bined have over­taken coal in the past, and wind power alone has out­paced coal dur­ing spring months when wind speeds pick up. Ember gets its hourly and monthly data from the US Energy Information Administration.

Globally, elec­tric­ity gen­er­a­tion from re­new­ables is grow­ing rapidly. Renewables will be­come the largest global en­ergy source, used for al­most 45% of elec­tric­ity gen­er­a­tion by 2030, ac­cord­ing to the International Energy Agency.

Last week, Trump, a Republican, an­nounced a plan to boost the strug­gling US coal in­dus­try by spend­ing nearly $700m to sup­port coal-fired power plants and coal ex­ports. Trump said at a White House event that “coal’s a great busi­ness” and that “in terms of power, there’s re­ally noth­ing like it”.

Martin Pochtaruk, CEO and founder of Canadian-based so­lar panel man­u­fac­turer Heliene, said Trump can say that coal is com­ing back but in­vestors will in­vest their money in what­ever brings the best re­turn. And for power gen­er­a­tion that is so­lar, mak­ing it the fastest-grow­ing fuel, he added.

A White House spokes­woman de­fended the Trump ad­min­is­tra­tion’s over­all en­ergy poli­cies, say­ing they were geared to­ward strength­en­ing the coun­try’s se­cu­rity.

“The President has re­versed the Left’s dev­as­tat­ing poli­cies, saved the American coal in­dus­try, pre­vented the re­tire­ment of more than 17 gi­gawatts of power, and saved lives dur­ing height­ened de­mand pe­ri­ods,” Taylor Rogers said in a state­ment.

While Trump is try­ing to re­verse the coal in­dus­try’s de­cline, so­lar has been the top source for new power for five years, Seia said. Seia and Wood Mackenzie said so­lar and bat­tery stor­age were prac­ti­cally the only en­ergy re­sources be­ing built in the first quar­ter, mak­ing up 91% of all new gen­er­at­ing ca­pac­ity.

The Trump ad­min­is­tra­tion has can­celed so­lar and wind pro­jects, im­ple­mented poli­cies that slowed clean en­ergy per­mit­ting and de­vel­op­ment and ter­mi­nated $7bn in fund­ing in­tended for af­ford­able so­lar en­ergy pro­jects across the US.

e-7416

Petition to the House of Commons

Whereas:

Bill C-22 au­tho­rizes reg­u­la­tions re­quir­ing des­ig­nated “core providers” to col­lect and re­tain meta­data on all Canadians for up to one year with­out any in­di­vid­ual be­ing un­der sus­pi­cion or in­ves­ti­ga­tion, and grants the Minister of Public Safety power to im­pose these same re­quire­ments on any elec­tronic ser­vice provider by min­is­te­r­ial or­der. Such meta­data can re­veal highly sen­si­tive in­for­ma­tion in­clud­ing pat­terns of move­ment, as­so­ci­a­tion, med­ical ac­tiv­ity, re­li­gious par­tic­i­pa­tion, and po­lit­i­cal ac­tiv­ity;

The de­f­i­n­i­tion of elec­tronic ser­vice provider is broad enough to in­clude any on­line ser­vice, in­clud­ing en­crypted mes­sag­ing apps, VPNs, email providers, bank­ing apps, and cloud stor­age ser­vices;

Bill C-22 grants the Minister of Public Safety broad au­thor­ity to com­pel any elec­tronic ser­vice provider to im­ple­ment in­ter­cep­tion ca­pa­bil­i­ties or tech­ni­cal as­sis­tance mea­sures that could weaken en­crypted sys­tems, with com­pli­ance be­ing manda­tory. This cre­ates cy­ber­se­cu­rity vul­ner­a­bil­i­ties ex­ploitable by crim­i­nals and hos­tile for­eign ac­tors, as demon­strated by the 2024 Salt Typhoon at­tack on United States tele­coms;

Suspicionless, in­dis­crim­i­nate bulk meta­data re­ten­tion and in­ter­cep­tion ca­pa­bil­i­ties raise se­ri­ous con­cerns un­der the Canadian Charter of Rights and Freedoms, which pro­tects Canadians against un­rea­son­able search and seizure; and

The gov­ern­ment re­tains broad reg­u­la­tory power to re­de­fine key terms in­clud­ing “encryption” and “systemic vul­ner­a­bil­ity” with­out re­turn­ing to Parliament, ren­der­ing the bil­l’s stated pri­vacy pro­tec­tions un­re­li­able.

We, the un­der­signed, cit­i­zens and res­i­dents of Canada, call upon the House of Commons to

1. Withdraw Bill C-22, An Act re­spect­ing law­ful ac­cess, or vote against it at all stages;

2. Remove all sus­pi­cion­less bulk meta­data re­ten­tion re­quire­ments from any fu­ture law­ful ac­cess leg­is­la­tion; and

3. Explicitly pro­hibit any fu­ture law­ful ac­cess leg­is­la­tion from re­quir­ing the weak­en­ing or break­ing of en­cryp­tion.

If you wish to sign this pe­ti­tion, please pro­vide the re­quired in­for­ma­tion in the fields be­low. Your per­sonal in­for­ma­tion will not be made pub­lic.

Personal Information

FIRST NAMERequired

LAST NAMERequired

EMAILRequired

PHONERequired

Address

COUNTRYRequired

PROVINCE / TERRITORYRequired

POSTAL CODERequired

I am a Canadian cit­i­zen or a res­i­dent of Canada.Disclaimer: Only Canadian cit­i­zens (whether liv­ing in­side or out­side Canada) or res­i­dents of Canada can sub­mit pe­ti­tions.Re­quired

I ac­knowl­edge, un­der­stand and ac­cept the terms of use and other con­di­tions con­tained in Electronic Petitions — Guide and Terms of Use. I con­sent to the use and dis­clo­sure of my per­sonal in­for­ma­tion for the pur­poses out­lined in this doc­u­ment.Re­quired

I wish to re­ceive email up­dates on this pe­ti­tion (optional).

It’s fif­teen years ago (bear with me, I’ve been in this in­dus­try since the late 90s, most of my good sto­ries start this way), and you’ve got two se­nior de­vel­op­ers at a SaaS com­pany. One of them writes 40% more lines of code than the other. Is that de­vel­oper bet­ter? More im­pact­ful for the busi­ness? Should the other one be pol­ish­ing their CV?

Of course not. You’d want to know what ac­tu­ally shipped. What it did for cus­tomers, for rev­enue, for re­li­a­bil­ity. Lines of code, PR counts… we spent a cou­ple of decades learn­ing these are stereo­typ­i­cally bad ways to mea­sure a de­vel­oper, to the point where sug­gest­ing them to­day is laugh­able.

Sooooo… Here’s what the in­dus­try put on the bill­board this year:

Google: 75% of new code is AI-generated .

Anthropic: ~80% of merged pro­duc­tion code is writ­ten by Claude , and en­gi­neers ship “8x more code per quar­ter”.

OpenAI: also ~80% , ap­par­ently.

Cursor: “100M+ lines of en­ter­prise code writ­ten per day” .

Every sin­gle one is a vol­ume claim. “Percent of code writ­ten by AI” is just lines of code with a bet­ter pub­li­cist. (The scep­tic in me edit­ing this draft would like to point out that it’s no co­in­ci­dence that all of these are AI ven­dors of some kind, so pump­ing adop­tion is pretty im­por­tant to them.)

We used to claim out­comes

Rewind a few years and the head­line num­ber was dif­fer­ent in kind, not just size. GitHub’s flag­ship claim was that de­vel­op­ers com­pleted tasks 55% faster with Copilot. Say what you like about that study (plenty did), but it was an out­come claim. Bold, fal­si­fi­able, about value. If it was wrong, you could show it was wrong.

The 2026 claims can’t fail. That’s the ge­nius of them; “75% of our code is AI-written” could be true, and will keep go­ing up, re­gard­less of whether any­thing got bet­ter (faster de­liv­ery, fewer in­ci­dents, hap­pier cus­tomers, etc). A vol­ume num­ber can only ever dis­ap­point you if adop­tion stalls, and adop­tion is the one thing most of us agree is real. 📈

So the claims got big­ger and started say­ing less. What hap­pened in be­tween?

The bit no­body puts on a bill­board

The out­come ev­i­dence got com­pli­cated, that’s what hap­pened.

The strongest pro-adop­tion re­sult is still Cui et al. ; nearly 5,000 de­vel­op­ers, +26% com­pleted tasks, with the biggest gains for ju­nior devs. Not re­ally in dis­pute. But then GitClear showed code churn ris­ing and refac­tor­ing col­laps­ing as Copilot adop­tion deep­ened. Then METR ran the study many have quoted: ex­pe­ri­enced open-source devs were 19% slower with AI in their own code­bases, while be­liev­ing they were 20% faster.

But! Hold my beer… in February 2026 METR ef­fec­tively walked it back : their fol­low-up es­ti­mates flipped to a speedup (with er­ror bars wide enough to ride a Moto Guzzi, with pan­niers, through!), and they aban­doned the study de­sign en­tirely - be­cause de­vel­op­ers now refuse to work with­out AI, and can’t re­li­ably self-re­port time on agen­tic work. Their lat­est po­si­tion: AI prob­a­bly speeds de­vel­op­ers up in 2026, and we can no longer cleanly mea­sure by how much.

Meanwhile at the com­pany level, an NBER sur­vey of ~6,000 ex­ec­u­tives found 69% of firms ac­tively us­ing AI and roughly nine in ten re­port­ing no mea­sur­able pro­duc­tiv­ity im­pact. The cross-study con­sen­sus sits some­where around 10% or­gan­i­sa­tional gains. Not noth­ing! Still bloody use­ful! Buuuut, also not “you don’t need de­vel­op­ers any­more” ter­ri­tory.

And if you’re a scep­tic still quot­ing “19% slower”, you’re cherry-pick­ing too. The re­search keeps up­dat­ing; the in­dus­try just changed what it counts.

Vanity met­rics, now in AI flavour

It’s not just AI ven­dor claims, to be fair. Carnegie Mellon’s SEI and Accenture launched an AI Adoption Maturity Model just a few days ago: five lev­els, eight di­men­sions, mar­keted off a stat about 95% of or­gan­i­sa­tions see­ing no re­turns. Steve Yegge’s “8 lev­els of AI-assisted de­vel­op­ment” ranks you by which tools you run and how much su­per­vi­sion you give them. And every tools ven­dor now ships a ma­tu­rity lad­der whose top rung is, usu­ally, “use more of our prod­uct”. These lad­ders mea­sure adop­tion in­ten­sity and call it ma­tu­rity. Same sub­sti­tu­tion, nicer pack­ag­ing.

My favourite data point in this whole genre: Augment sur­veyed 219 en­gi­neer­ing lead­ers and asked them to de­fine “AI-native en­gi­neer­ing” . They got 219 dif­fer­ent an­swers. 🫠

And the prize for hold­ing both ends of the rope goes to Anthropic, who gave us the “8x more code shipped” claim and one of the more rig­or­ous stud­ies of the year: an RCT find­ing that AI-assisted de­vel­op­ers scored 17% lower on com­pre­hen­sion of the code they’d just shipped, with no sta­tis­ti­cally sig­nif­i­cant pro­duc­tiv­ity gain. I use Claude every sin­gle day (it rec­om­mended half the links I read for this post, so the irony is not lost on me), the prod­ucts are gen­uinely ex­cel­lent, and their re­search arm up­dates while their mar­ket­ing arm counts vol­ume. Both things are true at once, which is kinda the point.

Why I ac­tu­ally care

Because these num­bers aren’t dec­o­ra­tive. They move bud­gets, per­for­mance ex­pec­ta­tions, and head­count plans. In February, Jack Dorsey cut over 40% of Block’s work­force (4,000+ peo­ple) with AI as the ex­plicit core the­sis: “A sig­nif­i­cantly smaller team, us­ing the tools we’re build­ing, can do more and do it bet­ter.” A cou­ple weeks later, Atlassian cut 10% (~1,600 peo­ple) , while con­ced­ing it would be “disingenuous to pre­tend AI does­n’t change the mix of skills we need or the num­ber of roles re­quired”. And there’s a key de­tail that gets me: Dorsey said, in the same an­nounce­ment, that the busi­ness was strong and gross profit was grow­ing.

When a com­pany says “AI made every­one more pro­duc­tive, so we need fewer peo­ple”, I want to see the ev­i­dence - and I don’t be­lieve it ex­ists to­day. Show me that x% of your work­force is gen­uinely idle (or even just un­der­utilised) be­cause the work can now be done by fewer peo­ple. Even then: I’ve never seen a prod­uct/​SaaS com­pany that did­n’t have an end­less roadmap. If you got a free head­count in­crease es­sen­tially overnight, why would­n’t you use it to de­liver more value to your cus­tomers, faster? That should show up as MAU, con­ver­sion, rev­enue. Choosing the lay­off in­stead tells me the pro­duc­tiv­ity claim is do­ing PR work for a de­ci­sion that was al­ready made for other rea­sons (over-hiring, in­vestor pres­sure, take your pick).

Look, every busi­ness car­ries some fat, and I can ac­cept ef­fi­ciency-dri­ven trim­ming as a thing that some­times le­git­i­mately hap­pens - it has at every step change in this in­dus­try. But when it hap­pens, try to do so us­ing the in­di­vid­ual per­for­mance sys­tems you al­ready run, the ones that sur­face who’s cruis­ing and who’s dis­en­gaged. Not to­ken counts. Not “% of code AI-written” or some­body’s level on a ma­tu­rity lad­der. If your se­lec­tion ev­i­dence is a van­ity met­ric, your se­lec­tion is a lot­tery wear­ing lip­stick.

Where I land

As I’ve said in pre­vi­ous posts , don’t read any of this as anti-AI. I think every en­gi­neer should be us­ing AI daily. Call it AI-first, AI-proficient, what­ever you like. Be cu­ri­ous, try the new tools, test the lat­est mod­els. To not do so is silly. I’ve watched this in­dus­try ab­sorb higher-level lan­guages, IDEs, au­to­com­plete, ag­ile and de­vops, and there were al­ways crusty hold-outs rem­i­nisc­ing about the good old days be­fore X came along and ru­ined every­thing. The hold-outs even­tu­ally got on board (usually). The dif­fer­ence this time is pace: you could de­lay adopt­ing “the cloud” for a cou­ple of years and sur­vive. With AI you might get a few months. The way we work has al­ready changed, and it’s not chang­ing back as far as I can tell.

But adop­tion is the start­ing line, not the score­board. We al­ready know how to mea­sure whether en­gi­neer­ing is de­liv­er­ing: DORA met­rics, re­li­a­bil­ity, rate of mean­ing­ful change, and ul­ti­mately rev­enue and cus­tomer value. Battle-tested, crusty stuff. Why are we throw­ing all of that out for bull­shit AI van­ity scores? (I could be wrong about plenty in this post, but I don’t think I’m wrong about that one.)

So here’s the ques­tion to smug­gle into your next ven­dor pitch, exec re­view, or LinkedIn doom-scroll: is that an out­come, or a vol­ume? It’s amaz­ing how quickly a po­si­tion or state­ment de­flates when you ask that.

The change is here to stay and the tools are good. The hope­ful part is that we al­ready know how to mea­sure what mat­ters (and none of it is counted in to­kens).

Be AI-first in how you work, but bat­tle-tested in how you mea­sure it.

Cheers, Dave

Many en­gi­neers should be do­ing less work. I don’t nec­es­sar­ily mean pro­duc­ing less code or fewer changes, but lit­er­ally work­ing fewer hours in the day. When they do work, they should be work­ing at a slower pace. I like to aim to be run­ning at 80% uti­liza­tion by de­fault: un­less I have a high-pres­sure pro­ject go­ing on, I spend 20% of my work­day away from the com­puter.

High-impact op­por­tu­ni­ties

Why? Performance at tech com­pa­nies is dom­i­nated by out­lier events. When I think about the most im­pact­ful changes I’ve made, many of them in­volved a sur­pris­ingly triv­ial amount of work. There are no points for ef­fort in soft­ware de­vel­op­ment. What mat­ters is solv­ing the right prob­lem at the right time.

In large en­gi­neer­ing or­ga­ni­za­tions, there are usu­ally triv­ial pieces of en­gi­neer­ing work you could do that would make tens or hun­dreds of mil­lions of dol­lars for the com­pany. Here are three com­mon ex­am­ples:

First, when the com­pany is try­ing to sign a big en­ter­prise deal, step­ping in with a fea­ture or bug­fix can make the deal hap­pen. It does­n’t even have to be a good fea­ture: some­times just show­ing that you’re will­ing and able to make a con­crete change will be enough.

Second, pre­vent­ing or mit­i­gat­ing an in­ci­dent early (even by just know­ing the right fea­ture flag to turn off) can save huge amounts of money: both im­me­di­ate lost rev­enue dur­ing the in­ci­dent and fu­ture lost rev­enue from cus­tomers who would have pulled their busi­ness or re­fused to sign pend­ing con­tracts.

Third, when the com­pany is try­ing to ship a high-pro­file fea­ture, suc­cess or fail­ure of­ten hinges on triv­ial but ob­scure changes (e.g. the abil­ity to rapidly add a new field in user set­tings, or to up­date the crufty en­ter­prise-data-ex­port func­tion­al­ity no­body has touched in years). Familiarity with the sys­tem can be the dif­fer­ence be­tween one of these changes tak­ing a few hours or a whole week.

What do these ex­am­ples have in com­mon? They’re all time-de­pen­dent. You can’t just log on in the morn­ing and de­cide to un­block a big deal, or mit­i­gate an in­ci­dent, or speed up a high-pro­file fea­ture. Is it just a mat­ter of be­ing in the right place at the right time? Not quite. You also have to not al­ready be busy.

Staying loose

I wrote about this a cou­ple of years ago in Crushing JIRA tick­ets is a party trick, not a path to im­pact. If you’re al­ways 100% uti­lized on a steady stream of low-pri­or­ity work (for in­stance, if you’re just pick­ing up tick­ets from the back­log, crush­ing them, then pick­ing up the next one), you’ll miss your chance to do high-im­pact work in two ways.

First, you’ll be too busy to even no­tice the op­por­tu­ni­ties. You won’t be chat­ting with peo­ple who are work­ing on other things, or read­ing team up­dates, or keep­ing an eye on on­go­ing in­ci­dents. So you’ll miss out on the best way to get in­volved in high-im­pact work, which is to vol­un­teer your ex­per­tise.

Second, if you per­pet­u­ally look busy, your man­ager won’t want to vol­un­teer for you. This is the sec­ond-best way to get in­volved in high-im­pact work: to have your man­ager or prod­uct man­ager say “oh, Sean has ca­pac­ity to help out here, let me tag him in”. Why is this bet­ter? Because man­agers and prod­uct man­agers usu­ally have a much bet­ter read on what high-im­pact work is go­ing on. They’re in meet­ings that you aren’t in.

Doing noth­ing

If you’re sup­posed to keep your time free for high-im­pact work, and you’re not sup­posed to just grind tick­ets, what should you be do­ing on a minute-by-minute ba­sis? Should you just be do­ing noth­ing? Yep!

Doing noth­ing is good, ac­tu­ally. Software en­gi­neer­ing can be a stress­ful job, but it’s typ­i­cally not con­sis­tently stress­ful: the stress comes from the oc­ca­sional in­ci­dent, or high-pres­sure ur­gent piece of work, or (these days) lay­off. If you ap­proach the com­par­a­tively low-pres­sure parts of your work with ur­gent in­ten­sity, you’ll al­ready be ex­hausted and fraz­zled when you have to han­dle the high-pres­sure parts.

Even in high-pres­sure parts of the job, do­ing noth­ing can still be good. One thing I rec­om­mend for en­gi­neers new to on-call is to avoid rush­ing: take a few breaths be­fore join­ing the call or be­fore speak­ing, and in gen­eral try to “think in slow mo­tion”. Most in­ci­dents re­solve on their own. Most fran­tic “maybe this will help” changes dur­ing in­ci­dents make things worse, not bet­ter. As a gen­eral rule, if you can sim­ply avoid pan­ick­ing, you will be do­ing bet­ter than most en­gi­neers at in­ci­dent re­sponse.

Nothing is a space things can hap­pen in1. If you give your brain a chance to rest, you will find you’re more likely to have new ideas. If some­one hands you an im­por­tant task, you can tackle it with your full at­ten­tion (instead of jug­gling it with the three other things you’re work­ing on in the back­ground). When you’re not busy, you have time to just look at things and take in new data.

Deliberately not do­ing spe­cific things

A lot of en­gi­neers are un­com­fort­able see­ing a task that needs do­ing and not do­ing it. I’m like this as well. I wrote about it in I’m ad­dicted to be­ing use­ful: it’s a psy­cho­log­i­cal quirk that many soft­ware en­gi­neers share, be­cause hav­ing that quirk (to a point) makes you a good fit for the job. In or­der to spend time do­ing noth­ing, some­times you need to force your­self to not step in.

For in­stance, I be­lieve that en­gi­neers should gen­er­ally avoid glue work2. Most glue work - mak­ing sure peo­ple talk to each other, up­dat­ing docs for work you’re not lead­ing, vol­un­teer­ing to ad­dress tech­ni­cal debt - re­flects the fact that the or­ga­ni­za­tion is not ex­plic­itly pri­or­i­tiz­ing this work. If they were, you would­n’t need to vol­un­teer for it. Either that’s fine, or it’s a big mis­take. If it’s fine, then you should­n’t step up and do it: you’ll be wast­ing your time and an­noy­ing your man­ager. If it’s a big mis­take, you still should­n’t do it, be­cause you’ll be in­su­lat­ing the com­pany from the con­se­quences of its own mis­takes at the cost of your own ca­reer and men­tal well-be­ing.

That’s a bad deal for you, and a bad ex­am­ple for your ju­nior col­leagues, and sets a bad prece­dent for some­one else to jump into the same po­si­tion when you in­evitably burn out3. If the con­se­quences truly are se­vere, let them hap­pen, so the or­ga­ni­za­tion can feel the pain and change its poli­cies.

I also be­lieve that be­ing too help­ful leaves you vul­ner­a­ble to preda­tors. Tech com­pa­nies are full of peo­ple who want to ex­tract un­com­pen­sated work from soft­ware en­gi­neers4. This is dif­fer­ent from work that ar­rives via nor­mal chan­nels, and for which you’re com­pen­sated by pro­mo­tions, bonuses (and just your nor­mal salary). I’m talk­ing about work that ar­rives via backchan­nels, from peo­ple who don’t have the abil­ity or will­ing­ness to en­sure that work is for­mally recorded un­der your name. For in­stance, a prod­uct man­ager from an­other or­ga­ni­za­tion mes­sag­ing you to say “you’re so good at query­ing data, would you mind pulling some sta­tis­tics for me about X?”, or an en­gi­neer from an­other team ask­ing you to “pair” on a piece of work that will ul­ti­mately in­volve you writ­ing all the code and them qui­etly sub­mit­ting the change un­der their own name.

Doing some amount of this kind of work is fine. You may as well help peo­ple out when you can. But you need to be able to ap­ply back­pres­sure, ei­ther by say­ing no or sim­ply de­lay­ing your re­sponse by a few hours or days.

It’s also a good idea to avoid in­vest­ing too much in work that is likely go­ing to dis­ap­pear. For in­stance, sup­pose you’re work­ing with a prod­uct de­signer who is fig­ur­ing out what they want in real time. At 9am they mes­sage you say­ing they want the page header to look one way, then at 10am they have tweaks, and more changes at 11am, and so on. You should not throw your­self into fully rewrit­ing the page every hour. Instead, you should do noth­ing (say, go for a walk) and rewrite the page once in the af­ter­noon, based on the most re­cent de­sign. Another com­mon in­stance of this is “big idea from a man­ager with­out the po­lit­i­cal clout to fol­low through on it”. Often you can just run out the clock un­til the pro­ject gets in­evitably can­celled5.

Conclusion

A lot of soft­ware en­gi­neer­ing ad­vice and tool­ing is de­signed around the abil­ity to scale up your abil­ity to ex­ert tech­ni­cal ef­fort: to do more things at the same time, to take on pro­jects of larger scope, or to just write more code. But soft­ware en­gi­neer­ing suc­cess is not de­ter­mined by any of these. It is de­ter­mined by the abil­ity to do the right things at the right time, which re­quires that you de­lib­er­ately hold back some of your ef­fort dur­ing or­di­nary work.

In my ex­pe­ri­ence, it’s still pos­si­ble to be a “high per­form­ing en­gi­neer” at 80% ef­fort. In fact, it’s eas­ier, be­cause you’ll be less likely to make silly mis­takes from stress, and you’ll be in a po­si­tion to jump on the kind of high-im­pact tasks that de­liver out­sized re­turns.

This does­n’t mean you should never grind at 100% ef­fort. I think there are prob­a­bly two or three times a year where I work as hard as I pos­si­bly can: long hours, in­tense fo­cus, think­ing about the prob­lem from when I wake up to when I go to bed. But I re­serve this mode of work for when the re­wards are re­ally high. For the rest of the year, I take it rel­a­tively easy.

edit: this post got some com­ments on Hacker News. Commenters dis­cuss how to not get in trou­ble with your man­ager when you’re tak­ing slack time (in my ex­pe­ri­ence, if you’re gen­er­ally pro­duc­tive it’s fine, but man­agers vary a lot) and whether en­gi­neers re­ally do have con­trol over their work­load.

One of my big in­flu­ences is Rich Hickey’s talk Hammock Driven Development. This is kind of like what he’s talk­ing about, ex­cept (a) Hickey is more talk­ing about what it takes to de­sign so­lu­tions to re­ally hard prob­lems, rather than what it takes to be a strong en­gi­neer in an or­di­nary tech com­pany, and so (b) Hickey rec­om­mends us­ing your time-away-from-the-com­puter to fo­cus on a hard prob­lem, in­stead of to sim­ply de­com­press and let so­lu­tions con­geal in your head. It’s also like Zvi Mowshowitz’s post on “slack”. ↩

One of my big in­flu­ences is Rich Hickey’s talk Hammock Driven Development. This is kind of like what he’s talk­ing about, ex­cept (a) Hickey is more talk­ing about what it takes to de­sign so­lu­tions to re­ally hard prob­lems, rather than what it takes to be a strong en­gi­neer in an or­di­nary tech com­pany, and so (b) Hickey rec­om­mends us­ing your time-away-from-the-com­puter to fo­cus on a hard prob­lem, in­stead of to sim­ply de­com­press and let so­lu­tions con­geal in your head. It’s also like Zvi Mowshowitz’s post on “slack”.

I wrote about this a lot more in Glue work con­sid­ered harm­ful. ↩

I wrote about this a lot more in Glue work con­sid­ered harm­ful.

Why in­evitably? Because in my view, burnout is hard work un­re­warded, and tak­ing on a per­sonal cru­sade that your job does­n’t care about is a great way to do a lot of un­re­warded work. ↩

Why in­evitably? Because in my view, burnout is hard work un­re­warded, and tak­ing on a per­sonal cru­sade that your job does­n’t care about is a great way to do a lot of un­re­warded work.

I wrote about this in Protecting your time from preda­tors in large tech com­pa­nies. ↩

I wrote about this in Protecting your time from preda­tors in large tech com­pa­nies.

Of course, you have to be care­ful with this. If you try this strat­egy and you’re wrong about the level of po­lit­i­cal sup­port for the pro­ject, you will come off like a slacker and then have to de­liver in a rush. ↩

Of course, you have to be care­ful with this. If you try this strat­egy and you’re wrong about the level of po­lit­i­cal sup­port for the pro­ject, you will come off like a slacker and then have to de­liver in a rush.

If you liked this post, con­sider sub­scrib­ing to email up­dates about my new posts, or shar­ing it on Hacker News.

Here’s a pre­view of a re­lated post that shares tags with this one.

The just-say-no en­gi­neer was a ZIRP phe­nom­e­non­The en­gi­neer who says no all the time is a real ar­che­type among se­nior and staff en­gi­neers. Their role is to slow things down, to block the de­vel­op­ment of fea­tures that add com­plex­ity, and to en­sure that as lit­tle code gets writ­ten as pos­si­ble (since code is a li­a­bil­ity).We can think of this as the just-say-no en­gi­neer, as op­posed to the just-say-yes en­gi­neer. The just-say-yes en­gi­neer is ob­sessed with mov­ing fast, ap­proves code changes by de­fault, val­ues MTTR over MTBF, and tends to ship a lot of code. The just-say-no en­gi­neer is ob­sessed with qual­ity, is happy to move slowly, and blocks code changes by de­fault. Most en­gi­neers are some­where in the mid­dle of the spec­trum. By “just-say-no en­gi­neer”, I’m talk­ing about the group of en­gi­neers who most strongly iden­tify with that ar­che­type.Con­tinue read­ing…

The just-say-no en­gi­neer was a ZIRP phe­nom­e­non

The en­gi­neer who says no all the time is a real ar­che­type among se­nior and staff en­gi­neers. Their role is to slow things down, to block the de­vel­op­ment of fea­tures that add com­plex­ity, and to en­sure that as lit­tle code gets writ­ten as pos­si­ble (since code is a li­a­bil­ity).

We can think of this as the just-say-no en­gi­neer, as op­posed to the just-say-yes en­gi­neer. The just-say-yes en­gi­neer is ob­sessed with mov­ing fast, ap­proves code changes by de­fault, val­ues MTTR over MTBF, and tends to ship a lot of code. The just-say-no en­gi­neer is ob­sessed with qual­ity, is happy to move slowly, and blocks code changes by de­fault. Most en­gi­neers are some­where in the mid­dle of the spec­trum. By “just-say-no en­gi­neer”, I’m talk­ing about the group of en­gi­neers who most strongly iden­tify with that ar­che­type.Con­tinue read­ing…

An ever-in­creas­ing vol­ume of de­bug in­ves­ti­ga­tions, doc­u­ment writ­ing, and code is writ­ten by ro­bots. This has cre­ated a new eti­quette ques­tion when work­ing with a team - when is it OK to for­ward the out­put of an AI to an­other hu­man to read?

On one hand, an AI with ro­bust in­te­gra­tion to in­ter­nal code bases and doc­u­men­ta­tion of­ten pro­duces gen­uine­ly1 use­ful out­put.

On the other, as an in­creas­ing amount of a soft­ware en­gi­neer’s day is spent read­ing AI text, a fa­tigue sets in. If I can have a ro­bot say some­thing, so can you. It reads as in­con­sid­er­ate to post un-di­gested AI out­put as though it’s your own writ­ing.

I re­mem­ber the first time I ex­pe­ri­enced this an­noy­ance. I pro­posed a de­sign, and a team­mate prompted an AI to cri­tique it. The team­mate sent an AI doc­u­ment to me, with the dis­claimer: “I did­n’t read this, so it might not be en­tirely ac­cu­rate”. My thought was, _if read­ing this was­n’t worth your time, why is it worth mine?”

Therefore, I’ve adopted this prin­ci­ple in my work:

If you are re­quest­ing hu­man at­ten­tion, demon­strate hu­man ef­fort.

If use­ful, I send AI gen­er­ated con­tent to team­mates. But when do­ing so, I take care to clearly la­bel what is AI gen­er­ated, and I add my own com­men­tary along­side it. For hu­man code re­view re­quests, I al­ways re­view my AI-generated code first.

Attention was al­ready a scarce re­source be­fore AI, and it is even more so now. Keeping AI gen­er­ated con­tent clearly la­beled and demon­strat­ing hu­man ef­fort helps show con­sid­er­a­tion for team­mates, and keeps a touch of hu­man­ity alive in our work.

Footnotes​

I promise I wrote this (and all the words in this post) with my meat fin­gers! ↩

I promise I wrote this (and all the words in this post) with my meat fin­gers! ↩

Anthropic has apol­o­gized for stealth­ily throt­tling its new AI model, Claude Fable 5, with hid­den guardrails that un­der­mine both re­searchers and ri­vals us­ing it to de­velop com­pet­ing sys­tems. The com­pany says it is re­vers­ing course and will be more trans­par­ent about when the re­stric­tions kick in, even if that means Fable re­fuses more queries.

Fable is the first widely avail­able model in Anthropic’s Mythos class of AI sys­tems, a group the com­pany has spent months warn­ing are too dan­ger­ous for pub­lic re­lease. Anthropic says it has ad­dressed some of those risks by launch­ing Fable with safe­guards that pre­vent it from re­spond­ing to cer­tain “high-risk” queries. One of the ar­eas Anthropic said it would re­strict Fable’s re­sponses is dis­til­la­tion, a tech­nique for train­ing smaller AI mod­els us­ing the out­puts of larger ones.

In Fable’s sys­tem card — a pub­lic doc­u­ment AI de­vel­op­ers re­lease to ex­plain how a sys­tem works — Anthropic said it would han­dle queries it be­lieved were dis­til­la­tion at­tempts by al­ter­ing and de­grad­ing the mod­el’s an­swers di­rectly. Users would not be no­ti­fied that they had trig­gered the safety mea­sure or in­formed that the re­sponses had been changed.

Anthropic said it is now chang­ing its ap­proach to dis­til­la­tion: Queries will now fall back to Claude Opus 4.8, Anthropic’s pre­vi­ous flag­ship model, the com­pany said in a post on X. Anthropic will promi­nently tell users too: “You will see this every time it hap­pens.”

This is sim­i­lar to how Fable han­dles queries in other high-risk ar­eas. When safety fea­tures are trig­gered in ar­eas like bi­ol­ogy, chem­istry, and cy­ber­se­cu­rity, queries are routed through Opus 4.8 un­less they are blocked out­right un­der the com­pa­ny’s broader safety rules, such as those cov­er­ing drugs, weapons, or other pro­hib­ited con­tent. In some cases, no­tably bi­ol­ogy, the safe­guards have been cal­i­brated so broadly that Fable is prac­ti­cally un­us­able for even ba­sic queries, some­thing Anthropic spokesper­son Paruul Maheshwary ac­knowl­edged in a com­ment to The Verge.

“Visible safe­guards can be probed, so they have to be ro­bust, which takes time to get right,” Anthropic wrote on X. “Invisible safe­guards can be tar­geted more nar­rowly, al­low­ing us to ship quickly with very few false pos­i­tives. We went with in­vis­i­ble safe­guards for this rea­son—and that was the wrong trade­off. You should have vis­i­bil­ity into the safe­guards we have in place, and why. We’re sorry for not get­ting the bal­ance right.”

The change fol­lows in­tense back­lash from the AI re­search com­mu­nity over Anthropic’s de­ci­sion to silently limit users sus­pected of try­ing to dis­till Fable into com­pet­ing mod­els — a safe­guard crit­ics warned could also af­fect third par­ties try­ing to eval­u­ate the fron­tier model. In the sys­tem card, Anthropic said newer mod­els’ abil­ity to ac­cel­er­ate AI de­vel­op­ment jus­ti­fied tar­get­ing those re­quests, not­ing that “using Claude to de­velop com­pet­ing mod­els al­ready vi­o­lates our Terms of Service.” Anthropic has pre­vi­ously ac­cused Chinese ri­vals like DeepSeek of un­fairly dis­till­ing its mod­els on an “industrial” scale.

Follow top­ics and au­thors from this story to see more like this in your per­son­al­ized home­page feed and to re­ceive email up­dates.

Robert Hart

Perhaps the worst UI crime in MacOS 26 Tahoe was the in­ex­plic­a­ble de­ci­sion to add in­scrutable, dis­tract­ing icons next to every item in the menu bar. You will re­call Jim Nielsen writ­ing about it, rightly de­scrib­ing it as ex­actly the sort of thing that Mac users look down upon in plat­forms like Google Docs and Windows. You will also re­call Nikita “Tonsky” Prokopov writ­ing about it, il­lus­trat­ing that the bad idea was­n’t even im­ple­mented well, with dif­fer­ent Apple apps us­ing en­tirely dif­fer­ent icons for the same menu items. You will also re­call my link­ing to Nielsen (“I can tol­er­ate be­ing an­gry about UI changes Apple makes to the Mac. But I can’t tol­er­ate be­ing heart­bro­ken.”) and to Prokopov (“The fact that Tahoe’s menu item icons are glar­ingly in­con­sis­tent and of­ten ut­terly in­scrutable is the fudge ic­ing on a shit cake, but the real em­bar­rass­ment is that the idea ever got past the pro­posal stage. No real UI or icon de­sign­ers think this is a good idea. None.”)

Top third-party de­vel­op­ers rightly re­jected the de­sign, adopt­ing open source code from Brent Simmons to dis­able the de­fault “icons in all stan­dard menu items” be­hav­ior.

Wonderful news in MacOS 27 Golden Gate: the icons are gone. It’s like Tahoe’s menu item icons never hap­pened. Prokopov noted it on Mastodon with be­fore and af­ter screen­shots, and men­tions that Apple has up­dated the Human Interface Guidelines ac­cord­ingly:

Use menu item icons spar­ingly and with pur­pose. Icons al­low peo­ple to find menu items more quickly, and help clar­ify what se­lect­ing an item does. Use an icon to high­light the most com­mon ac­tions and key fea­tures of your app, file sys­tem lo­ca­tions, con­nected de­vices, vi­sual con­cepts like ro­tat­ing or flip­ping an im­age, and user-gen­er­ated con­tent like fold­ers and doc­u­ments. Don’t dis­play an icon if you can’t find one that clearly rep­re­sents the menu item.

Use menu item icons spar­ingly and with pur­pose. Icons al­low peo­ple to find menu items more quickly, and help clar­ify what se­lect­ing an item does. Use an icon to high­light the most com­mon ac­tions and key fea­tures of your app, file sys­tem lo­ca­tions, con­nected de­vices, vi­sual con­cepts like ro­tat­ing or flip­ping an im­age, and user-gen­er­ated con­tent like fold­ers and doc­u­ments. Don’t dis­play an icon if you can’t find one that clearly rep­re­sents the menu item.

This up­dated ad­vice in the HIG is per­fect. Screenshot:

MacOS 26 Tahoe — across every Apple app on the sys­tem — is a liv­ing ex­am­ple of the up­dated HIG’s “what not to do” ex­am­ple il­lus­tra­tions (including the sec­ond sec­tion about groups within a menu). If you’re stuck us­ing Tahoe un­til Golden Gate ar­rives, re­call this tip to al­le­vi­ate the prob­lem to some ex­tent.

This is my fa­vorite news from all of WWDC this week. I mean that. In a small way I mean it be­cause I so loathe this as­pect of MacOS Tahoe. But in a large way I mean it be­cause it’s proof that the rot has been rooted out of Apple’s soft­ware de­sign team. I don’t know if all the un­tal­ented hacks are gone, but the un­tal­ented mag­a­zine-de­signer hacks with clout and in­flu­ence all left with Alan Dye. I’ve chat­ted with a few peo­ple from Apple’s de­sign team this week and they’re all lov­ing the work they’re do­ing and the di­rec­tion they’re tak­ing Apple’s plat­forms. Backtracking on these id­i­otic menu item icons was a nec­es­sary first step.