Skip to main con­tent

🚨 The Conservatives (EPP) are at­tempt­ing to force a new vote on Thursday (26th), seek­ing to re­verse Parliament’s NO on in­dis­crim­i­nate scan­ning. This is a di­rect at­tack on democ­racy and bla­tant dis­re­gard for your right to pri­vacy. No means no. Take ac­tion now!

It’s been about a year since cod­ing agents ap­peared on the scene that could ac­tu­ally build you full pro­jects. There were pre­cur­sors like Aider and early Cursor, but they were more as­sis­tant than agent. The new gen­er­a­tion is en­tic­ing, and a lot of us have spent a lot of free time build­ing all the pro­jects we al­ways wanted to build but never had time to.

And I think that’s fine. Spending your free time build­ing things is su­per en­joy­able, and most of the time you don’t re­ally have to care about code qual­ity and main­tain­abil­ity. It also gives you a way to learn a new tech stack if you so want.

During the Christmas break, both Anthropic and OpenAI handed out some free­bies to hook peo­ple to their ad­dic­tive slot ma­chines. For many, it was the first time they ex­pe­ri­enced the magic of agen­tic cod­ing. The fold’s get­ting big­ger.

Coding agents are now also in­tro­duced to pro­duc­tion code­bases. After 12 months, we are now be­gin­ning to see the ef­fects of all that “progress”. Here’s my cur­rent view.

While all of this is anec­do­tal, it sure feels like soft­ware has be­come a brit­tle mess, with 98% up­time be­com­ing the norm in­stead of the ex­cep­tion, in­clud­ing for big ser­vices. And user in­ter­faces have the weird­est fuck­ing bugs that you’d think a QA team would catch. I give you that that’s been the case for longer than agents ex­ist. But we seem to be ac­cel­er­at­ing.

We don’t have ac­cess to the in­ter­nals of com­pa­nies. But every now and then some­thing slips through to some news re­porter. Like this sup­posed AI caused out­age at AWS. Which AWS im­me­di­ately “corrected”. Only to then fol­low up in­ter­nally with a 90-day re­set.

Satya Nadella, the CEO of Microsoft, has been go­ing on about how much code is now be­ing writ­ten by AI at Microsoft. While we don’t have di­rect ev­i­dence, there sure is a feel­ing that Windows is go­ing down the shit­ter. Microsoft it­self seems to agree, based on this fine blog post.

Companies claim­ing 100% of their pro­duc­t’s code is now writ­ten by AI con­sis­tently put out the worst garbage you can imag­ine. Not point­ing fin­gers, but mem­ory leaks in the gi­ga­bytes, UI glitches, bro­ken-ass fea­tures, crashes: that is not the seal of qual­ity they think it is. And it’s def­i­nitely not good ad­ver­tis­ing for the fever dream of hav­ing your agents do all the work for you.

Through the grapevine you hear more and more peo­ple, from soft­ware com­pa­nies small and large, say­ing they have agen­ti­cally coded them­selves into a cor­ner. No code re­view, de­sign de­ci­sions del­e­gated to the agent, a gazil­lion fea­tures no­body asked for. That’ll do it.

We have ba­si­cally given up all dis­ci­pline and agency for a sort of ad­dic­tion, where your high­est goal is to pro­duce the largest amount of code in the short­est amount of time. Consequences be damned.

You’re build­ing an or­ches­tra­tion layer to com­mand an army of au­tonomous agents. You in­stalled Beads, com­pletely obliv­i­ous to the fact that it’s ba­si­cally unin­stal­lable mal­ware. The in­ter­net told you to. That’s how you should work or you’re ngmi. You’re ral­ph­ing the loop. Look, Anthropic built a C com­piler with an agent swarm. It’s kind of bro­ken, but surely the next gen­er­a­tion of LLMs can fix it. Oh my god, Cursor built a browser with a bat­tal­ion of agents. Yes, of course, it’s not re­ally work­ing and it needed a hu­man to spin the wheel a lit­tle bit every now and then. But surely the next gen­er­a­tion of LLMs will fix it. Pinky promise! Distribute, di­vide and con­quer, au­ton­omy, dark fac­to­ries, soft­ware is solved in the next 6 months. SaaS is dead, my grandma just had her Claw build her own Shopify!

Now again, this can work for your side pro­ject barely any­one is us­ing, in­clud­ing your­self. And hey, maybe there’s some­body out there who can ac­tu­ally make this work for a soft­ware prod­uct that’s not a steam­ing pile of garbage and is used by ac­tual hu­mans in anger.

If that’s you, more power to you. But at least among my cir­cle of peers I have yet to find ev­i­dence that this kind of shit works. Maybe we all have skill is­sues.

The prob­lem with agents is that they make er­rors. Which is fine, hu­mans also make er­rors. Maybe they are just cor­rect­ness er­rors. Easy to iden­tify and fix. Add a re­gres­sion test on top for bonus points. Or maybe it’s a code smell your lin­ter does­n’t catch. A use­less method here, a type that does­n’t make sense, du­pli­cated code over there. On their own, these are harm­less. A hu­man will also do such boo­boos.

But clankers aren’t hu­mans. A hu­man makes the same er­ror a few times. Eventually they learn not to make it again. Either be­cause some­one starts scream­ing at them or be­cause they’re on a gen­uine learn­ing path.

An agent has no such learn­ing abil­ity. At least not out of the box. It will con­tinue mak­ing the same er­rors over and over again. Depending on the train­ing data it might also come up with glo­ri­ous new in­ter­po­la­tions of dif­fer­ent er­rors.

Now you can try to teach your agent. Tell it to not make that boo­boo again in your AGENTS.md. Concoct the most com­plex mem­ory sys­tem and have it look up pre­vi­ous er­rors and best prac­tices. And that can be ef­fec­tive for a spe­cific cat­e­gory of er­rors. But it also re­quires you to ac­tu­ally ob­serve the agent mak­ing that er­ror.

There’s a much more im­por­tant dif­fer­ence be­tween clanker and hu­man. A hu­man is a bot­tle­neck. A hu­man can­not shit out 20,000 lines of code in a few hours. Even if the hu­man cre­ates such boo­boos at high fre­quency, there’s only so many boo­boos the hu­man can in­tro­duce in a code­base per day. The boo­boos will com­pound at a very slow rate. Usually, if the boo­boo pain gets too big, the hu­man, who hates pain, will spend some time fix­ing up the boo­boos. Or the hu­man gets fired and some­one else fixes up the boo­boos. So the pain goes away.

With an or­ches­trated army of agents, there is no bot­tle­neck, no hu­man pain. These tiny lit­tle harm­less boo­boos sud­denly com­pound at a rate that’s un­sus­tain­able. You have re­moved your­self from the loop, so you don’t even know that all the in­no­cent boo­boos have formed a mon­ster of a code­base. You only feel the pain when it’s too late.

Then one day you turn around and want to add a new fea­ture. But the ar­chi­tec­ture, which is largely boo­boos at this point, does­n’t al­low your army of agents to make the change in a func­tion­ing way. Or your users are scream­ing at you be­cause some­thing in the lat­est re­lease broke and deleted some user data.

You re­al­ize you can no longer trust the code­base. Worse, you re­al­ize that the gazil­lions of unit, snap­shot, and e2e tests you had your clankers write are equally un­trust­wor­thy. The only thing that’s still a re­li­able mea­sure of “does this work” is man­u­ally test­ing the prod­uct. Congrats, you fucked your­self (and your com­pany).

You have zero fuck­ing idea what’s go­ing on be­cause you del­e­gated all your agency to your agents. You let them run free, and they are mer­chants of com­plex­ity. They have seen many bad ar­chi­tec­tural de­ci­sions in their train­ing data and through­out their RL train­ing. You have told them to ar­chi­tect your ap­pli­ca­tion. Guess what the re­sult is?

An im­mense amount of com­plex­ity, an amal­gam of ter­ri­ble cargo cult “industry best prac­tices”, that you did­n’t rein in be­fore it was too late. But it’s worse than that.

Your agents never see each oth­er’s runs, never get to see all of your code­base, never get to see all the de­ci­sions that were made by you or other agents be­fore they make a change. As such, an agen­t’s de­ci­sions are al­ways lo­cal, which leads to the ex­act boo­boos de­scribed above. Immense amounts of code du­pli­ca­tion, ab­strac­tions for ab­strac­tions’ sake.

All of this com­pounds into an un­re­cov­er­able mess of com­plex­ity. The ex­act same mess you find in hu­man-made en­ter­prise code­bases. Those ar­rive at that state be­cause the pain is dis­trib­uted over a mas­sive amount of peo­ple. The in­di­vid­ual suf­fer­ing does­n’t pass the thresh­old of “I need to fix this”. The in­di­vid­ual might not even have the means to fix things. And or­ga­ni­za­tions have su­per high pain tol­er­ance. But hu­man-made en­ter­prise code­bases take years to get there. The or­ga­ni­za­tion slowly evolves along with the com­plex­ity in a de­mented kind of syn­ergy and learns how to deal with it.

With agents and a team of 2 hu­mans, you can get to that com­plex­ity within weeks.

So now you hope your agents can fix the mess, refac­tor it, make it pris­tine. But your agents can also no longer deal with it. Because the code­base and com­plex­ity are too big, and they only ever have a lo­cal view of the mess.

And I’m not just talk­ing about con­text win­dow size or long con­text at­ten­tion mech­a­nisms fail­ing at the sight of a 1 mil­lion lines of code mon­ster. Those are ob­vi­ous tech­ni­cal lim­i­ta­tions. It’s more de­vi­ous than that.

Before your agent can try and help fix the mess, it needs to find all the code that needs chang­ing and all ex­ist­ing code it can reuse. We call that agen­tic search. How the agent does that de­pends on the tools it has. You can give it a Bash tool so it can rip­grep its way through the code­base. You can give it some queryable code­base in­dex, an LSP server, a vec­tor data­base. In the end it does­n’t mat­ter much. The big­ger the code­base, the lower the re­call. Low re­call means that your agent will, in fact, not find all the code it needs to do a good job.

This is also why those code smell boo­boos hap­pen in the first place. The agent misses ex­ist­ing code, du­pli­cates things, in­tro­duces in­con­sis­ten­cies. And then they blos­som into a beau­ti­ful shit flower of com­plex­ity.

How do we avoid all of this?

Coding agents are sirens, lur­ing you in with their speed of code gen­er­a­tion and jagged in­tel­li­gence, of­ten com­plet­ing a sim­ple task with high qual­ity at break­neck ve­loc­ity. Things start falling apart when you think: “Oh golly, this thing is great. Computer, do my work!”.

There’s noth­ing wrong with del­e­gat­ing tasks to agents, ob­vi­ously. Good agent tasks share a few prop­er­ties: they can be scoped so the agent does­n’t need to un­der­stand the full sys­tem. The loop can be closed, that is, the agent has a way to eval­u­ate its own work. The out­put is­n’t mis­sion crit­i­cal, just some ad hoc tool or in­ter­nal piece of soft­ware no­body’s life or rev­enue de­pends on. Or you just need a rub­ber duck to bounce ideas against, which ba­si­cally means bounc­ing your idea against the com­pressed wis­dom of the in­ter­net and syn­thetic train­ing data. If any of that ap­plies, you found the per­fect task for the agent, pro­vided that you as the hu­man are the fi­nal qual­ity gate.

Karpathy’s auto-re­search ap­plied to speed­ing up startup time of your app? Great! As long as you un­der­stand that the code it spits out is not pro­duc­tion-ready at all. Auto-research works be­cause you give it an eval­u­a­tion func­tion that lets the agent mea­sure its work against some met­ric, like startup time or loss. But that eval­u­a­tion func­tion only cap­tures a very nar­row met­ric. The agent will hap­pily ig­nore any met­rics not cap­tured by the eval­u­a­tion func­tion, such as code qual­ity, com­plex­ity, or even cor­rect­ness, if your eval­u­a­tion func­tion is foo­bar.

The point is: let the agent do the bor­ing stuff, the stuff that won’t teach you any­thing new, or try out dif­fer­ent things you’d oth­er­wise not have time for. Then you eval­u­ate what it came up with, take the ideas that are ac­tu­ally rea­son­able and cor­rect, and fi­nal­ize the im­ple­men­ta­tion. Yes, sure, you can also use an agent for that fi­nal step.

And I would like to sug­gest that slow­ing the fuck down is the way to go. Give your­self time to think about what you’re ac­tu­ally build­ing and why. Give your­self an op­por­tu­nity to say, fuck no, we don’t need this. Set your­self lim­its on how much code you let the clanker gen­er­ate per day, in line with your abil­ity to ac­tu­ally re­view the code.

Anything that de­fines the gestalt of your sys­tem, that is ar­chi­tec­ture, API, and so on, write it by hand. Maybe use tab com­ple­tion for some nos­tal­gic feels. Or do some pair pro­gram­ming with your agent. Be in the code. Because the sim­ple act of hav­ing to write the thing or see­ing it be­ing built up step by step in­tro­duces fric­tion that al­lows you to bet­ter un­der­stand what you want to build and how the sys­tem “feels”. This is where your ex­pe­ri­ence and taste come in, some­thing the cur­rent SOTA mod­els sim­ply can­not yet re­place. And slow­ing the fuck down and suf­fer­ing some fric­tion is what al­lows you to learn and grow.

The end re­sult will be sys­tems and code­bases that con­tinue to be main­tain­able, at least as main­tain­able as our old sys­tems be­fore agents. Yes, those were not per­fect ei­ther. Your users will thank you, as your prod­uct now sparks joy in­stead of slop. You’ll build fewer fea­tures, but the right ones. Learning to say no is a fea­ture in it­self.

You can sleep well know­ing that you still have an idea what the fuck is go­ing on, and that you have agency. Your un­der­stand­ing al­lows you to fix the re­call prob­lem of agen­tic search, lead­ing to bet­ter clanker out­puts that need less mas­sag­ing. And if shit hits the fan, you are able to go in and fix it. Or if your ini­tial de­sign has been sub­op­ti­mal, you un­der­stand why it’s sub­op­ti­mal, and how to refac­tor it into some­thing bet­ter. With or with­out an agent, don’t fuck­ing care.

All of this re­quires dis­ci­pline and agency.

All of this re­quires hu­mans.

Tesla runs a bug bounty pro­gram that in­vites re­searchers to find se­cu­rity vul­ner­a­bil­i­ties in their ve­hi­cles. To par­tic­i­pate, I needed the ac­tual hard­ware, so I started look­ing for Tesla Model 3 parts on eBay. My goal was to get a Tesla car com­puter and touch­screen run­ning on my desk, boot­ing the car’s op­er­at­ing sys­tem.

The car com­puter con­sists of two parts - the MCU (Media Control Unit) and the au­topi­lot com­puter (AP) lay­ered on top of each other. In the car, the com­puter is lo­cated in front of the pas­sen­ger seat, roughly be­hind the glove­box. The part it­self is the size of an iPad and the thick­ness of a ~500 page book and is cov­ered in a wa­ter-cooled metal cas­ing:

By search­ing for “Tesla Model 3 MCU” on Ebay, I found quite a lot of re­sults in the $200 - $300 USD price range. Looking at the list­ings, I found that many of these sell­ers are “salvaging” com­pa­nies who buy crashed cars, take them apart, and list all parts for sale in­di­vid­u­ally. Sometimes, they even in­clude a photo of the orig­i­nal crashed car and a way to fil­ter their list­ings for parts ex­tracted from the same ve­hi­cle.

To boot the car up and in­ter­act with it, I needed a few more things:

* The dis­play ca­ble to con­nect them to­gether

For the power sup­ply, I went with an ad­justable 0-30V model from Amazon. There was a 5 am­pere and a 10A ver­sion avail­able, at the time, I fig­ured it’s safer to have some head­room and went with the 10A ver­sion — it was a very good de­ci­sion, as it later turned out, the full setup could con­sume up to 8A at peak times. The Model 3 screens were sur­pris­ingly ex­pen­sive on Ebay, I as­sume that is be­cause it is a pop­u­lar part to re­place. I found a pretty good deal for 175 USD.

The last and most dif­fi­cult part to or­der was the ca­ble which con­nects the MCU to the screen. I needed this be­cause both the com­puter and a screen were be­ing sold with the ca­bles cut a few cen­time­ters af­ter the con­nec­tor (interestingly most sell­ers did that, in­stead of just un­plug­ging the ca­bles).

This is when I dis­cov­ered that Tesla pub­lishes the wiring “Electrical Reference” for all of its cars pub­licly. On their ser­vice web­site, you can look up a spe­cific car model, search for a com­po­nent (such as the dis­play), and it will show you ex­actly how the part should be wired up, what ca­bles/​con­nec­tors are used, and even what the dif­fer­ent pins are re­spon­si­ble for in­side a sin­gle con­nec­tor:

Turns out the dis­play uses a 6-pin ca­ble (2 for 12V and ground, 4 for data) with a spe­cial Rosenberger 99K10D-1D5A5-D con­nec­tor. I soon dis­cov­ered that un­less you are a car man­u­fac­turer or­der­ing in bulk, there is no way you are buy­ing a sin­gle Rosenberger ca­ble like this. No Ebay list­ings, noth­ing on Aliexpress, es­sen­tially no search re­sults at all.

After dig­ging around a bit, I found that this ca­ble is very sim­i­lar to a more widely used au­to­mo­tive ca­ble called “LVDS”, which is used to trans­fer video in BMW cars. At first sight, the con­nec­tors looked like a per­fect match to my Rosenberger, so I placed an or­der:

The com­puter ar­rived first. To at­tempt to power it on, I looked up which pin of which con­nec­tor I needed to at­tach 12V and ground to us­ing the Tesla schemat­ics & the few pic­tures on­line of peo­ple do­ing the same desk-MCU setup. Since the com­puter in­cluded the shortly cut ca­bles, I was able to strip the rel­e­vant wires and at­tach the power sup­ply’s clips to the right ones:

I saw a cou­ple of red LEDs start flash­ing, and the com­puter started up! Since I had no screen yet, there were not many ways to in­ter­act with the car. Reading @lewurm’s pre­vi­ous re­search on GitHub I knew that, at least in older car ver­sions, there was a net­work in­side the car, with some com­po­nents hav­ing their own web­server. I con­nected an Ethernet ca­ble to the port next to the power con­nec­tor and to my lap­top.

This net­work does not have DHCP, so you have to man­u­ally set your IP ad­dress. The IP you se­lect has to be 192.168.90. X/24, and should be higher than 192.168.90.105 to not con­flict with other hosts on the net­work. On Reddit, I found the con­tents of an older /etc/hosts file from a car which shows the hosts that are nor­mally as­so­ci­ated with spe­cific IPs:

@lewurm’s blog men­tioned that SSH on port :22 and a web­server on :8080 was open on 192.168.90.100, the MCU. Was this still the case on newer mod­els? Yes!

I had al­ready found 2 ser­vices to ex­plore on the MCU:

* An SSH server which states “SSH al­lowed: ve­hi­cle parked” - quite funny given the cir­cum­stances

This SSH server re­quires spe­cially signed SSH keys which only Tesla is sup­posed to be able to gen­er­ate.

Interestingly, Tesla of­fers a “Root ac­cess pro­gram” on their bug bounty pro­gram. Researchers who find at least one valid “rooting” vul­ner­a­bil­ity will re­ceive a per­ma­nent SSH cer­tifi­cate for their own car, al­low­ing them to log in as root and con­tinue their re­search fur­ther. — A nice perk, as it is much eas­ier to find ad­di­tional vul­ner­a­bil­i­ties once you are on the in­side.

* This SSH server re­quires spe­cially signed SSH keys which only Tesla is sup­posed to be able to gen­er­ate.

* Interestingly, Tesla of­fers a “Root ac­cess pro­gram” on their bug bounty pro­gram. Researchers who find at least one valid “rooting” vul­ner­a­bil­ity will re­ceive a per­ma­nent SSH cer­tifi­cate for their own car, al­low­ing them to log in as root and con­tinue their re­search fur­ther. — A nice perk, as it is much eas­ier to find ad­di­tional vul­ner­a­bil­i­ties once you are on the in­side.

* A REST-like API on :8080 which re­turned a his­tory of “tasks”

This ser­vice is called “ODIN” (On-Board Diagnostic Interface Network), and is in­ten­tion­ally ex­posed to be used by Tesla’s di­ag­nos­tics tool “Toolbox”.

* This ser­vice is called “ODIN” (On-Board Diagnostic Interface Network), and is in­ten­tion­ally ex­posed to be used by Tesla’s di­ag­nos­tics tool “Toolbox”.

Around this time, I also re­moved the metal shield­ing to see ex­actly what the boards look like in­side. You can see the two dif­fer­ent boards which were stacked on top of each other:

Once the screen and the BMW LVDS ca­ble ar­rived, it un­for­tu­nately be­came clear that the con­nec­tor is not go­ing to fit. The BMW con­nec­tor was much thicker on the sides and it was not pos­si­ble to plug it into the screen. This led to some su­per sketchy im­pro­vised at­tempts to strip the two orig­i­nal “tail” ca­bles from the MCU and the screen and con­nect the in­di­vid­ual wires to­gether. The wires were re­ally sen­si­tive and thin. The setup worked for a cou­ple of sec­onds, but caused wire de­bris to fall on the PCB and short it, burn­ing one of the power con­troller chips:

It was ex­tremely hard to find the name/​model of the chip that got burned, es­pe­cially since part of the text printed on it had be­come un­read­able due to the dam­age. To be able to con­tinue with the pro­ject, I had to or­der a whole other car com­puter.

In the mean­time, my friend Yasser (@n3r0li) some­how pulled off the im­pos­si­ble and iden­ti­fied it as the “MAX16932CATIS/V+T” step-down con­troller, re­spon­si­ble for con­vert­ing power down to lower volt­ages. We or­dered the chip and took the board to a lo­cal PCB re­pair shop, where they suc­cess­fully re­placed it and fixed the MCU. Now I had two com­put­ers to work with.

So I re­ally did need that Rosenberger ca­ble, there was no get­ting around it.

After hav­ing no luck find­ing it on­line and even vis­it­ing a Tesla ser­vice cen­ter in London (an odd en­counter, to say the least), I had to ac­cept what I had been try­ing to avoid: buy­ing an en­tire Dashboard Wiring Harness.

Back in the Tesla Electrical Reference, in ad­di­tion to the con­nec­tors, one can find every part num­ber. Looking at the ca­ble which con­nects the MCU to the screen, the num­ber 1067960-XX-E shows. Searching for it on Ebay brings up this mon­stros­ity:

Turns out that ac­tual cars don’t have in­di­vid­ual ca­bles. Instead they have these big “looms”, which bun­dle many ca­bles from a nearby area into a sin­gle har­ness. This is the rea­son why I could not find the in­di­vid­ual ca­ble ear­lier. They sim­ply don’t man­u­fac­ture it. Unfortunately I had no other choice but to buy this en­tire loom for 80 USD.

Despite how bulky it was, the loom worked per­fectly. The car booted, the touch screen started up, and I had a work­ing car com­puter on my desk, run­ning the car’s op­er­at­ing sys­tem!

Having the sys­tem run­ning, I can now start play­ing with the user in­ter­face, in­ter­act­ing with the ex­posed net­work in­ter­faces, ex­plor­ing the CAN buses, and per­haps even at­tempt­ing to ex­tract the firmware.

Apple has just lost me as an user. It will take me a while be­fore I can fully mi­grate away from their de­vices, and I sus­pect I might need to keep a mac around for my work, but I will move all my per­sonal com­put­ing to Linux and Android again.

I been an Apple user since MacOS 8. I had both a Newton MessagePad 2000 and an eMate 300. I got the orig­i­nal blue toi­let-seat iBook G3. I was there for the de­vel­oper road show in­tro­duc­ing MacOS X. I paid for my de­vel­oper ac­count since then. Recently, I had a Macbook Air, iPhone 17, iPad Mini.

I’m gonna throw all of them away — not lit­er­ally ofc — be­cause of re­cent slop this com­pany been ship­ping. It is death through a thou­sand pa­per­cuts. To sum­marise for yous there are three main is­sues for me and the last one hap­pened to­day and is what pushed me through the thresh­old.

I ab­solutely hate Apple quar­an­tine and gate­keep­ing of soft­ware. As a de­vel­oper, I should just be able to ship soft­ware to those in­ter­ested in my apps. Be aware that I don’t give a fly­ing fuck about mo­bile de­vel­op­ment, I’m talk­ing about desk­top apps here.

I gave in to the Apple rack­e­ter­ing scheme and got my­self a de­vel­oper ac­count from the very start. I had to fax my card de­tails to them, that is how long I had my ac­count.

Even though my soft­ware is pack­aged and no­tarised as per their re­quire­ments, they still show my users a di­a­log box con­firm­ing they want to run my app, some­thing they do not for apps in­stalled through their walled gar­den. This is just fric­tion to pun­ish de­vel­op­ers out­side their store. I am very tired of it.

That has been an ab­solute fi­asco. Liquid glass is com­pletely bro­ken from a de­sign point of view. I have no idea how that got out of the door, and now mul­ti­ple up­dates in, it still just as bad.

Not only it looks ugly, and that is sub­jec­tive of course, but it is vi­su­ally bro­ken. Interfaces built with AppKit or SwiftUI that ren­dered per­fect, are now over­lap­ping con­trols and clip­ping stuff. They have no con­sis­tency at all in terms of icons, place­ment, cor­ners…

I am not a de­signer, I don’t even care about de­sign much, but when a bad de­sign spreads like ink on a glass of wa­ter poi­son­ing my work­flows, it is when I no­tice it.

My iPhone up­dated last night and per UK laws, it in­tro­duced age ver­i­fi­ca­tion. The way Apple de­cided to im­ple­ment this is through credit card check­ing.

First it at­tempted to check my Apple Wallet, it failed even though I have five cards in it and am able to use the App Store fine.

Then it moved onto want­ing me to man­u­ally add a card to ver­ify my­self. It failed with all my five cards. Four were debit cards, and one was a credit card from an­other coun­try, cause you know I am an im­mi­grant who has ac­counts still in my own orig­i­nal birth place.

So it failed age ver­i­fi­ca­tion and locked me out of many fea­tures. Bear in mind, I am 45 years old. I have an Apple ac­count for 25 years, the age of my per­sonal ac­count alone should al­ready ver­ify my age.

Credit cards are not doc­u­ments. Many peo­ple don’t have them. Apple don’t pro­vide any other way to ver­ify your age be­cause they are a stu­pid American com­pany with American val­ues in which you’re just as hu­man as your credit score.

Age ver­i­fi­ca­tion is a scam, but check­ing it with a credit card is even worse.

Next steps for me

I was al­ready done with Apple for some months now, but due to that hap­pen­ing to­day, I am an­gry af and will speed up my plans.

I’m tired of de­vices that are not ac­tu­ally mine, of work­flows that with­out bless­ing from a higher cor­po­rate au­thor­ity won’t work. I’m gonna move back to Linux and Android.

Yeah, I know Google gonna fuck Android soon the same way, but at least with Android you tend to have more op­tions.

For my com­put­ing needs, I pur­chased a MNT Pocket Reform. It will take them a while to as­sem­ble and send it to me, but once I have it, my mac­book will be­come a work lap­top only. All soft­ware I make al­ready ships for Linux.

I am con­sid­er­ing get­ting a Fairphone Gen 6. Not sure if I will go with stock Android or their Murena /e/OS ver­sion. It de­pends how the de­gog­gled ver­sion han­dles my bank­ing apps. I might need to go with stock Android.

After those two, I plan to as­sem­ble a lit­tle home­lab us­ing ei­ther a TinyMiniMicro form fac­tor PC run­ning Linux and if I have the bud­get an ugreen NAS. On those ma­chines, I want to have some­thing to han­dle my photo backup and shared drive. Will prob­a­bly use ei­ther tailscale or some cloud­flare bull­shit to con­nect them to each other.

This is it, mov­ing back to­wards tak­ing con­trol of my com­put­ing again.

Did you en­joyed read­ing this con­tent? Want to sup­port me?

You can buy me a cof­fee at ko-fi.

You can reach out to me on Bluesky, or Mastodon, Secure Scuttlebutt, or through WebMentions.

Why do I file bug re­ports with Apple Feedback Assistant? I plead in­san­ity. Or per­haps ad­dic­tion. I see­saw be­tween phases of ab­sti­nence and falling off the wagon. I’ve even tried or­ga­niz­ing a pub­lic boy­cott of Feedback Assistant, with a list of de­mands to im­prove the ex­pe­ri­ence for users, but the boy­cott never caught on with other de­vel­op­ers. Regardless, an in­cen­tive still ex­ists to file bug re­ports, be­cause Apple ac­tu­ally fixes some of my bugs. My main com­plaint about the bug re­port­ing process is not the un­fixed bugs but rather the dis­re­spect for bug re­ports and the peo­ple who file them. Apple in­ten­tion­ally wastes our time with no re­grets, as if our time had no value, as if we had some kind of duty to serve Apple.

In March 2023, I filed FB12088655 “Privacy: Network fil­ter ex­ten­sion TCP con­nec­tion and IP ad­dress leak.” I men­tioned this bug re­port at the time in a blog post, which in­cluded the same steps to re­pro­duce and ex­am­ple Xcode pro­ject that I pro­vided to Apple. In the three years since I filed the bug re­port, I re­ceived no re­sponse what­so­ever from Apple… un­til a cou­ple of weeks ago, when Apple asked me to “verify” the is­sue with ma­cOS 26.4 beta 4 and up­date my bug re­port.

I in­stall the WWDC be­tas every year in June but don’t run OS be­tas af­ter September when the ma­jor OS up­dates are re­leased. I don’t have enough time or in­deed enough Apple de­vices to be an un­paid tester year round. Thus, ver­i­fy­ing is­sues in be­tas is a has­sle for me. I’ve been burned by such re­quests in the past, asked by Apple to ver­ify is­sues in be­tas that were not fixed, so I asked Apple di­rectly whether beta 4 fixed the bug: they should al­ready know, since they have my steps to re­pro­duce! However, their re­sponse was eva­sive, never di­rectly an­swer­ing my ques­tion. Moreover, they threat­ened to close my bug re­port and as­sume the bug is fixed if I did­n’t ver­ify within two weeks! Again, this is af­ter Apple silently sat on my bug re­port for three years.

Although I did­n’t in­stall the beta my­self, I spoke to the de­vel­op­ers of Little Snitch, who do run the ma­cOS be­tas, and they kindly in­formed me that in their test­ing, they could still re­pro­duce my is­sue with ma­cOS 26.4 beta 4. It was no sur­prise, then, that when I up­dated to ma­cOS 26.4, re­leased to the pub­lic yes­ter­day by Apple, I could still re­pro­duce the bug with my in­struc­tions and ex­am­ple pro­ject. It ap­pears that Apple know­ingly sent me on a wild goose chase, de­mand­ing that I “verify” a bug they did noth­ing to fix, per­haps pray­ing that the bug had mag­i­cally dis­ap­peared on its own, with no ef­fort from Apple.

By the way, a few weeks ago I pub­lished a blog post about an­other bug, FB22057274 “Pinned tabs: slow-load­ing tar­get=“_blank” links ap­pear in the wrong tab,” which is also 100% re­pro­ducible but nonethe­less was marked by Apple with the res­o­lu­tion “Investigation com­plete - Unable to di­ag­nose with cur­rent in­for­ma­tion.” On March 9, I up­dated the bug re­port, ask­ing what ad­di­tional in­for­ma­tion Apple needs from me—they never asked for more in­for­ma­tion—but I’ve yet to re­ceive a re­sponse.

I can only as­sume that some bo­zos in Apple lead­er­ship in­cen­tivize un­der­lings to close bug re­ports, no mat­ter whether the bugs are fixed. Out of sight, out of mind. Apple’s in­ter­nal met­rics prob­a­bly tell them that they have no soft­ware qual­ity prob­lem, be­cause the num­ber of open bug re­ports is kept lower ar­ti­fi­cially.

Ironically, the iPa­dOS 26.4 be­tas in­tro­duced a Safari crash­ing bug that I re­ported a month ago, but Apple failed to fix the bug be­fore the pub­lic re­lease. What’s the pur­pose of be­tas? As far as I can tell, the pur­pose is just to an­noy peo­ple who file bugs, with­out do­ing any­thing use­ful.

ARC-AGI-3 is an in­ter­ac­tive rea­son­ing bench­mark which chal­lenges AI agents to ex­plore novel en­vi­ron­ments, ac­quire goals on the fly, build adapt­able world mod­els, and learn con­tin­u­ously.

A 100% score means AI agents can beat every game as ef­fi­ciently as hu­mans.

Instead of solv­ing sta­tic puz­zles, agents must learn from ex­pe­ri­ence in­side each en­vi­ron­ment—per­ceiv­ing what mat­ters, se­lect­ing ac­tions, and adapt­ing their strat­egy with­out re­ly­ing on nat­ural-lan­guage in­struc­tions.

Antimatter is mat­ter’s equal and op­po­site. If the two meet, they an­ni­hi­late each other, turn­ing en­tirely into en­ergy. This makes it in­cred­i­bly dif­fi­cult to store or move an­ti­mat­ter.

On 24 March, a team at CERN, the European par­ti­cle-physics lab­o­ra­tory near Geneva, Switzerland, trans­ported 92 an­tipro­tons in a spe­cially de­signed bot­tle that traps the par­ti­cles us­ing mag­netic fields. The bot­tle trav­elled on the back of a truck, tak­ing a 30-minute jour­ney around the lab’s site.

The ex­per­i­men­t’s ul­ti­mate goal is to take the an­tipar­ti­cles to a lo­ca­tion free of ex­per­i­men­tal noise, where an­tipro­tons can be stud­ied with greater pre­ci­sion than is pos­si­ble in the CERN ‘antimatter fac­to­ry’ where they are cre­ated.

CERN is the only place in the world that pro­duces us­able quan­ti­ties of an­tipro­tons. Many staff mem­bers turned out with their mo­bile-phone cam­eras to cap­ture the truck as it trav­elled more than 8 kilo­me­tres around the site, reach­ing a max­i­mum speed of 42 kilo­me­tres per hour.

“It is some­thing hu­man­ity has never done be­fore, it is his­toric,” says team mem­ber Stefan Ulmer, a physi­cist at Heinrich Heine University Düsseldorf (HHU) in Germany. “We bought a lot of cham­pagne, and we in­vited the en­tire an­ti­mat­ter com­mu­nity to cel­e­brate with us to­day.”

How to trans­port an­ti­mat­ter — stick it on the back of a van

Antimatter can be used to study other phe­nom­ena, such as the struc­ture of ra­dioac­tive nu­clei, or re­searched it­self to un­ravel some of the Universe’s deep­est mys­ter­ies. Physicists who cre­ated the an­ti­mat­ter fac­tory more than 30 years ago dreamed that some­day it might be pos­si­ble to trans­port the ma­te­r­ial, says Christian Smorra, a physi­cist at the HHU who led the pro­ject. “Now it’s fi­nally pos­si­ble.”

“This is a great tech­no­log­i­cal achieve­ment,” says Tara Shears, a physi­cist at the University of Liverpool, UK. Antimatter is the most frag­ile type of mat­ter there is, so stor­ing it, let alone dri­ving it around CERN, is “a tech­no­log­i­cal mar­vel”, she says.

“I love the idea of CERN be­com­ing the Deliveroo [a food-de­liv­ery com­pany] of an­ti­mat­ter,” she adds.

Antiparticles are like their or­di­nary coun­ter­parts, ex­cept with their charge and mag­netic prop­er­ties re­versed. Although mat­ter is abun­dant, an­ti­mat­ter oc­curs nat­u­rally only very rarely. No one knows why this dis­par­ity ex­ists, when both should have been cre­ated in equal amounts dur­ing the Big Bang.

CERN makes an­ti­mat­ter by col­lid­ing beams of pro­tons into a dense metal, then us­ing elec­tric and mag­netic fields to slow and cap­ture the an­tipro­tons that emerge. Most par­ti­cles are lost in the painstak­ing process.

LLMs are too im­por­tant to be left to big tech. There is a gap be­tween fron­tier mod­els and mod­els that can run on your de­vice, but lo­cal mod­els im­prove each day, and once they cross a cer­tain ca­pa­bil­ity thresh­old, they will be good enough for most pur­poses; and will come with full pri­vacy and con­trol.

Based on these as­sump­tions, we’ve been work­ing on Ensu, Ente’s of­fline LLM app. Today is our first re­lease.

In the rest of this post, we’ll ex­plain why we think the as­sump­tions hold, what we’re do­ing, and how you can get in­volved.

LLMs are too im­por­tant to be left to big tech. We’ve writ­ten in depth about this ear­lier, here and here.

Briefly, those posts come at it from two an­gles:

If you’re some­one who hates LLMs, you would still be able to rec­og­nize in clearer mo­ments of thought that LLMs are a tech­nol­ogy that can’t just be wished away. If you’re some­one who finds joy in in­ter­act­ing with LLMs, you would rec­og­nize the lack of pri­vacy and the high de­pen­dency (arbitrary bans, con­tent shap­ing, non-portable mem­ory) you have on cen­tral­ized providers.

And in both cases it is also clear that LLMs can be used to ma­nip­u­late peo­ple en masse. Ergo, we can’t be at the mercy of big tech con­trol­ling them.

The is­sue is that there is a ca­pa­bil­ity gap be­tween large cen­tral­ized mod­els and smaller mod­els that can be run of­fline on your de­vice.

But we’re prob­lem solvers, and this is not our first rodeo. When we first started Ente Photos, it seemed un­think­able that we’d be able to de­liver face recog­ni­tion, per­son clus­ter­ing and nat­ural lan­guage im­age search all run­ning lo­cally on your de­vice. People called us crazy.

It took many years, but we did it. Our users en­joy these fea­tures every day. Everything is done lo­cally on de­vice, and also synced, end-to-end en­crypted, across all your de­vices. Full pri­vacy, full con­trol, with­out loss of con­ve­nience; tech­nol­ogy in ser­vice of peo­ple, not as a tool of sur­veil­lance.

In the same vein, while we have been itch­ing for a long time to do some­thing about lo­cal LLMs, it is only re­cently that smaller mod­els are be­com­ing fea­si­ble to run on con­sumer de­vices. We now think there are ac­tion­able steps we can take.

This is where the sec­ond as­sump­tion comes in. While smaller de­cen­tral­ized mod­els im­prove every day, so do the larger cen­tral­ized mod­els. However, we think the gap is not what is im­por­tant - in­stead, it is about a thresh­old, and about how the mod­el’s ca­pa­bil­i­ties are used. Once smaller mod­els will cross a cer­tain thresh­old, they will be suf­fi­cient to pro­vide joy, util­ity and con­ve­nience in the life of peo­ple.

Today we’re re­leas­ing Ensu. It is a chat­gpt-like app that runs com­pletely on your de­vice with full pri­vacy and zero cost. Soon, you’ll also be able to backup and sync your chats across your de­vices by con­nect­ing your Ente ac­count (or self host­ing), with full end-to-end en­cryp­tion.

This is not the be­gin­ning, nor is this the end. This is just a check­point.

Ensu is cur­rently an Ente Labs pro­ject. For now, we want to only it­er­ate on the prod­uct and its di­rec­tion, with­out bring­ing pric­ing and sta­bil­ity too early into the pic­ture.

Just to set ex­pec­ta­tions right, it is cur­rently not as pow­er­ful as ChatGPT or Claude Code. Still, it is al­ready quite fun! Here are some things we’ve been do­ing with it:

* Introspecting about thoughts we would­n’t risk putting into a non-pri­vate LLM.

* Talking about books (Ensu cur­rently does­n’t have web search, but you’ll be sur­prised how well it knows clas­sics like the Gita or the Bible)

* Jabbering with it on flights when there is no in­ter­net.

The app is open source, and avail­able for iOS, Android, ma­cOS, Linux and Windows. We also have an ex­per­i­men­tal web based ver­sion. Image at­tach­ments are also sup­ported. The core logic is writ­ten in Rust, and for each plat­form we have na­tive (mobile) and Tauri (desktop) apps that use the same shared logic.

We’ve al­ready im­ple­mented (optional) E2EE sync­ing and back­ups so that you can ac­cess your chats across de­vices. This uses the Ente ac­count you al­ready have, and it can also be self hosted just like Ente Photos. However, at the last minute we de­cided not to en­able sync in the check­point we’re re­leas­ing to­day. That’s the story of the next sec­tion.

We’re view­ing Ensu as a jour­ney. There is a pre­cise des­ti­na­tion - a pri­vate, per­sonal LLM with en­crypted sync - how­ever the path to it is hazy. There are mul­ti­ple di­rec­tions we could take:

* Instead of gen­eral chat, we shape Ensu to have a more spe­cial­ized in­ter­face, say like a sin­gle, never-end­ing note you keep writ­ing on, while the LLM of­fers sug­ges­tions, cri­tiques, re­minders, con­text, al­ter­na­tives, view­points, quotes. A sec­ond brain, if you will.

* A more util­i­tar­ian take, say like an Android Launcher, where the LLM is an im­ple­men­ta­tion de­tail be­hind an ex­ist­ing in­ter­ac­tion that peo­ple are al­ready used to.

* Your agent, run­ning on your phone. No setup, no man­age­ment, no man­ual back­ups. An LLM that grows with you, re­mem­bers you, your choices, man­ages your tasks, and has long-term mem­ory and per­son­al­ity.

For now we will just wait a while for feed­back be­fore tak­ing the next step. And be­cause these fu­ture di­rec­tions might change the per­sis­tence ar­chi­tec­ture, we’ve de­layed en­abling sync.

When sync does ar­rive, your ex­ist­ing lo­cal chats will get backed up and sync too.

We would love your feed­back. The next steps are un­clear, and we want you to in­flu­ence what we build. Tell us what you want, and we’ll make it. You can write to us at [email protected], or join our Discord and head over to the #ensu chan­nel.

You can down­load Ensu here.

Today, we’re an­nounc­ing an up­date on how GitHub will use data to de­liver more in­tel­li­gent, con­text-aware cod­ing as­sis­tance. From April 24 on­ward, in­ter­ac­tion data—specif­i­cally in­puts, out­puts, code snip­pets, and as­so­ci­ated con­text—from Copilot Free, Pro, and Pro+ users will be used to train and im­prove our AI mod­els un­less they opt out. Copilot Business and Copilot Enterprise users are not af­fected by this up­date.

Not in­ter­ested? Opt out in set­tings un­der “Privacy.” If you pre­vi­ously opted out of the set­ting al­low­ing GitHub to col­lect this data for prod­uct im­prove­ments, your pref­er­ence has been re­tained—your choice is pre­served, and your data will not be used for train­ing un­less you opt in.

This ap­proach aligns with es­tab­lished in­dus­try prac­tices and will im­prove model per­for­mance for all users. By par­tic­i­pat­ing, you’ll help our mod­els bet­ter un­der­stand de­vel­op­ment work­flows, de­liver more ac­cu­rate and se­cure code pat­tern sug­ges­tions, and im­prove their abil­ity to help you catch po­ten­tial bugs be­fore they reach pro­duc­tion.

Our ini­tial mod­els were built us­ing a mix of pub­licly avail­able data and hand-crafted code sam­ples. This past year, we’ve started in­cor­po­rat­ing in­ter­ac­tion data from Microsoft em­ploy­ees and have seen mean­ing­ful im­prove­ments, in­clud­ing in­creased ac­cep­tance rates in mul­ti­ple lan­guages.

The im­prove­ments we’ve seen by in­cor­po­rat­ing Microsoft in­ter­ac­tion data in­di­cate we can im­prove model per­for­mance for a more di­verse range of use cases by train­ing on real-world in­ter­ac­tion data. Should you de­cide to par­tic­i­pate in this pro­gram, the in­ter­ac­tion data we may col­lect and lever­age in­cludes:

Outputs ac­cepted or mod­i­fied by you

Inputs sent to GitHub Copilot, in­clud­ing code snip­pets shown to the model

This pro­gram does not use:

Interaction data from users who opt out of model train­ing in their Copilot set­tings

Content from your is­sues, dis­cus­sions, or pri­vate repos­i­to­ries at rest. We use the phrase “at rest” de­lib­er­ately be­cause Copilot does process code from pri­vate repos­i­to­ries when you are ac­tively us­ing Copilot. This in­ter­ac­tion data is re­quired to run the ser­vice and could be used for model train­ing un­less you opt out.

The data used in this pro­gram may be shared with GitHub af­fil­i­ates, which are com­pa­nies in our cor­po­rate fam­ily in­clud­ing Microsoft. This data will not be shared with third-party AI model providers or other in­de­pen­dent ser­vice providers.

We be­lieve the fu­ture of AI-assisted de­vel­op­ment de­pends on real-world in­ter­ac­tion data from de­vel­op­ers like you. It’s why we’re us­ing Microsoft in­ter­ac­tion data for model train­ing and will be­gin us­ing in­ter­ac­tion data from GitHub em­ploy­ees as well.

If you choose to help us im­prove our mod­els with your in­ter­ac­tion data, thank you. Your con­tri­bu­tions make a mean­ing­ful dif­fer­ence in build­ing AI tools that serve the en­tire de­vel­oper com­mu­nity. If you pre­fer not to par­tic­i­pate, that’s fine too—you will still be able to take full ad­van­tage of the AI fea­tures you know and love.

Together, we can con­tinue to build AI that ac­cel­er­ates your work­flows and em­pow­ers you to build bet­ter, more se­cure soft­ware faster than ever.

If you have ques­tions, visit our FAQ and re­lated dis­cus­sion.

Mario Rodriguez leads the GitHub Product team as Chief Product Officer. His core iden­tity is be­ing a learner and his pas­sion is cre­at­ing de­vel­oper tools—so much so that he has spent the last 20 years liv­ing that mis­sion in lead­er­ship roles across Microsoft and GitHub. Mario most re­cently over­saw GitHub’s AI strat­egy and the GitHub Copilot prod­uct line, launch­ing and grow­ing Copilot across thou­sands of or­ga­ni­za­tions and mil­lions of users. Mario spends time out­side of GitHub with his wife and two daugh­ters. He also co-chairs and founded a char­ter school in an ef­fort to progress ed­u­ca­tion in rural re­gions of the United States.

Everything you need to mas­ter GitHub, all in one place.

Build what’s next on GitHub, the place for any­one from any­where to build any­thing.

Meet the com­pa­nies and en­gi­neer­ing teams that build with GitHub.

Catch up on the GitHub pod­cast, a show ded­i­cated to the top­ics, trends, sto­ries and cul­ture in and around the open source de­vel­oper com­mu­nity on GitHub.

We do newslet­ters, tooD­is­cover tips, tech­ni­cal guides, and best prac­tices in our bi­weekly newslet­ter just for devs.

Yes please, I’d like GitHub and af­fil­i­ates to use my in­for­ma­tion for per­son­al­ized com­mu­ni­ca­tions, tar­geted ad­ver­tis­ing and cam­paign ef­fec­tive­ness. See the GitHub Privacy Statement for more de­tails.