nSpiredthe digital elder's logbook

I recently came across an interesting article by Sébastien Dubois about building an AI-ready second brain. Structured notes, metadata, connected knowledge. All sensible ideas. But it got me thinking about something I've been exploring myself.

Are we teaching AI to remember, or simply making information easier to retrieve? A conversation contains ideas, doubts, changing opinions and eventual decisions. A memory system might preserve the words, but does it preserve the reasoning, uncertainty or original intention?

And what happens when tomorrow's evidence contradicts yesterday's conclusions? Does the system reconsider, or does an old misunderstanding become a permanent truth?

We've become remarkably good at storing information. But storage isn't understanding, and retrieval isn't necessarily remembering. I've been quietly experimenting with some of these questions, and the deeper I go, the more interesting the problem becomes.

Perhaps the real challenge isn't teaching AI to remember more, but teaching it to remember responsibly.

Before the internet, before the dotcom boom, there was a grey box under the telly. The Nintendo Entertainment System arrived in British living rooms the way the best technology did back then: heavy, slightly mysterious, and plugged into the television with a lead you were told not to touch.

Every kid of that era knows the ritual. Cartridge out, blow across the contacts, push it back in, press it down until the spring caught. If the screen just flashed at you, you did it all again. It almost certainly made no difference — reseating the cartridge was doing the real work — but it felt like engineering, and we did it religiously.

Then came the negotiations. Whose turn it was, whose controller had the sticky button, who had to be Player 2. Evenings vanished into levels that took a hundred attempts, and the moment you finally beat one was worth every single death on the way. When the Super Nintendo arrived it felt like the future had been delivered early: sixteen bits, colours we'd never seen on a TV, and a pad with shoulder buttons that made the old one look like a calculator.

Looking back, those evenings taught me something I didn't have words for until much later. A machine has rules, and if you learn them well enough you can start to bend them. Warp zones, glitches, the occasional "that shouldn't be possible" — it was my first taste of thinking like a hacker, years before I knew what the word meant.

So, naturally, I built one. NESForge is my Nintendo Entertainment System emulator. Under the hood an emulator is a stack of small, very precise lies: a recreation of the NES's 6502-based processor, the picture unit that paints the screen one scanline at a time, and the sound chip that gives those games their unmistakable voice — all kept in lockstep, so the software inside never suspects it isn't sitting under a telly in the eighties.

A note from the security side of my brain: emulators are perfectly legal, the games are another matter. NESForge doesn't ship any, so bring your own dumps of cartridges you own, or explore the brilliant homebrew scene that's still making new NES games today.

Go on, fire up NESForge. No blowing required.

A small invention log. I've finally built a proper capture chain for the tapes and CDs before time gets to them — and it turns out they're two completely different jobs.

Tape is analogue, so the signal path is everything: a decent preamp, a line-level input with plenty of headroom, and capture at 24-bit so the converter is never the weakest link. The first pass came out hissy. The second taught me the deck's azimuth was off by a hair; nudge the head into line and the top end comes back like someone opened a window.

CD is the opposite problem. The music is already digital — 16-bit, 44.1kHz — so the aim isn't to capture it but to copy it exactly: rip securely, check the result against known-good checksums, store it as lossless FLAC. Bit-for-bit or bust. "Perfect sound forever" was never quite invincible; scratches and disc rot see to that, which is exactly why it's worth doing now.

There's a lovely moment in this hobby when an old physical medium meets modern measurement tools and the two agree on what the original performance sounded like. That, in miniature, is why I still enjoy engineering.

Which brings me to a dear friend who writes and sings. Many moons ago they were in a band, back when an eight-track recorder was the heart of a home studio: eight separate tracks, recorded together or one at a time, jamming and overdubbing instruments, vocals and percussion until something resembled a song. Anyone remember them?

No? Allow me to introduce — or remind you — with ROOM8, an eight-track recorder that runs entirely in your browser. It was designed and built in a single pass with AI, steered by a delivery framework of mine called FORGE. More on FORGE another time.

A few days ago I pointed my browser at the address I built websites under in my formative years. The server answered with a bare 403 Forbidden — a door locked since around 2014. That felt wrong. Not because the place should be busy, but because a piece of my history had quietly turned into dead air.

So this is me taking it back. Not for traffic, not for metrics, but as somewhere my own thinking has room to sit. Every era of technology I've lived through has taught me the same thing: the formats change, but the habit of writing things down survives them all.

I was born at the very start of the eighties, so my first music came from mum's vinyl and the odd cassette. There was ceremony in it: dust the record, set the stylus, watch it lower with that particular click. Tape had rituals of its own — the clatter of the deck, the satisfying clunk of the door closing, and rewinding with a pencil to spare the Walkman's batteries.

Nobody thinks about the ceremony any more, because there isn't one. A track streams and simply starts; nothing lowers onto anything. I'm not mourning that — I love what digital audio did for my world — but I've started noticing the small rituals we lose without ever naming them. This page is partly an attempt to remember what they were for.

Through the dotcom boom I ran web development from this domain. Hosting back then wasn't renting a button on a dashboard. It was knowing which box held your site, restarting a service at 3am, and explaining to clients why their "website" was really a directory of files with very particular opinions about permissions.

The industry moved on precisely because people like us made that chaos boring and reliable. Somewhere along the way we stopped being wizards and became infrastructure. I'm not sure that's a loss — but I am sure someone ought to keep the receipts for what it used to be like.

After decades of making computers do exactly what I told them, watching one learn to hold a conversation is equal parts exhilarating and unsettling. My security training insists every new capability needs a boundary; my engineer's instinct keeps wanting to take it apart to see how it works.

The honest field note is this: the most useful posture isn't awe or panic, it's auditability. Know what the thing was asked to do, know what it actually did, and make sure you can unwind either. The discipline that kept servers alive through the dotcom years turns out to be the right frame for the AI age. Some things don't change, even when they look like they're changing everything.