The shelf life

In the rewrite I wrote that every application is going to be rewritten, native and close to the metal. I did not expect the first one I would finish to be my kids’ music player.

A cheap player

A while ago I bought a cheap music player for my kids, a HiBy R1, mostly so they could listen to stories. The hardware was fine. I always felt disappointed by its stock interface, running on HiBy’s own build of Linux 4.4, a kernel released in 2016.

That is how most devices die. Not because the hardware wears out, but because the software around it stops moving. Nobody updates it, nobody fixes what annoys you, and one day it is easier to buy a new one than to keep living with it. The vendor moves on to the next model, and nobody else will spend months porting a recent kernel to a small music player.

A few prompts later

So I asked my agents to do it.

Getting in was the first problem. HiBy’s firmware has no developer access, so the first step was a patched update that opened a shell. Its kernel also cannot start another one, so the agent wrote a small kernel module that loads a new kernel into memory and jumps into it, a trampoline, with the watchdog armed to bring the player back if it hung. The first thing it ever ran was a few lines that painted the screen, the only way to see anything before there were drivers.

Two days after the first commit, the R1 was booting mainline Linux from its own flash. Today it runs Linux 7.3 with new drivers for the display, the touchscreen, the keys, the DAC, the battery, the internal storage, USB and Bluetooth headphones. HiBy’s system is gone. The kernel side is on GitHub, with the patches and the tools to install it. On top of the new kernel runs a new player, written from scratch in Rust: it reads the card, shows the covers, plays MP3, M4A and Opus, and pairs with headphones. It also has games, Snake, Tetris, 2048 and a memory game, and a few learning apps: sums, times tables and reading the clock, each one moving up a level as it is played.

My kids were quite happy to discover the new interface, with some disbelief that “I” had made it. Then we worked on the games together, making changes to make them more fun, and they discovered the iterative side of building something: try a change, play it, try the next one. A glimpse into all the possibilities.

“A few prompts” is how I put it on X, and it undersells it a bit. It was a side project, picked up in the gaps between other work over about three weeks, but it still came to around 220 commits across the kernel and the player, and a little over 7,000 model responses. I did not write the code. My part was mostly pressing buttons: rebooting the player whenever the agent needed to run a test, which was critical while mainline was coming up, because the player was often stuck. At one point I even considered a robotic arm to press the buttons for me, so the agent could drive it on its own.

Upstream

What matters most here is not the player. It is that the drivers did not stay in my repository.

The patches went to the kernel mailing lists one series at a time, and maintainers reviewed them like anyone else’s. Some came back with real objections, some were wrong and got withdrawn, and some are already in: the audio driver and a DAC fix are queued for Linux 7.5, and an SD card fix is on its way to the stable kernels.

There was also a moment I did not see coming. One maintainer asked me to slow down: too many series and too many versions during the merge window, and he had been reviewing versions that were already out of date. The agents can produce patches faster than the people who have to read them. That is a bottleneck nobody had to think about before, and it is a human one.

It matters for the lifespan, though. Once a driver is upstream, the R1 does not depend on HiBy anymore, and it does not depend on me either. Every future kernel carries it.

The bill

The obvious objection is that I spent a lot of datacenter energy to save one music player. So I counted.

Across every session on the project, my agents went through about 2.3 billion tokens. Almost all of it is the same context being re-read on every turn, which is cheap, plus about 40 million tokens written to the cache and 6 million generated. That sounds like a lot for 7,000 responses, and it is, because an agent’s response is not a chat message. Every turn re-reads the whole working context, a median of 285,000 tokens per response here, so each one is closer to reading a long document than to answering a question.

With Simon Couch’s per-token estimates for coding agents, that comes to roughly 120 kWh. They are napkin numbers, his own words, and most of that total comes from his guess for re-reading cached context, which nobody outside the labs can check. Anthropic serves its models on a mix of Google TPUs, Amazon’s Trainium and Nvidia GPUs and publishes no per-token figure, while Zeke Hausfather’s replication came out higher. Call it somewhere between 50 and 250 kWh.

On an average US grid, that is roughly 20 to 90 kg of CO2. On the French grid, 95% low-carbon and mostly nuclear, the same work would be 1 to 5 kg. Building a new smartphone emits about 50 to 60 kg before it is ever switched on, and for small electronics, manufacturing is most of the footprint over the whole life of the device.

So for one player in one house, it is somewhere between a small win and a wash. I did not save the planet by keeping my kids’ player out of a drawer.

Why I still think it adds up

What changes the arithmetic is that the cost is paid once and the result is not. The whole bill is about one new phone. Every device that keeps running instead of being replaced pays back about that much, so the second R1 kept out of a drawer already puts it ahead, and every one after that is free. The port works on any R1 whose owner is willing to flash it, not only mine.

The upstream part goes further. The SD card fix is tagged for stable, so it reaches every Ingenic chip with the same controller, on older kernels too. The audio and pin drivers serve any board built on the R1’s chip, and the DAC fix lands in a driver everything with that DAC shares. None of that has to be paid for again. And the next port, to the next abandoned device, will cost less, because the models keep getting better and the patterns are now in the open.

Until now, keeping old hardware alive was the job of volunteer communities, and they could only afford to do it for popular devices: a few phones, a few routers, some old laptops. Everything else ended up in a drawer when its vendor moved on. Agents make the long tail affordable. One person with a device they care about can now do what used to take a community and a few years.

We mostly count what AI costs: the datacenters, the water, the power plants coming back online. We rarely count what it saves, because the savings are spread across millions of small decisions like this one, and nobody adds them up.

A music player is a small example, but I am confident it is not an isolated one. The same economics apply to everything we throw away because fixing it costs more than replacing it, and to far bigger problems than that: energy, materials, climate. AI is going to produce huge savings across the board, and it is the best tool we have had in a long time to take on the natural and economic challenges in front of us.

That is why now is not the time to be a degrowther. The answer to the cost of a new technology is not to use less of it. It is to point it at the problems that matter.