Jake Liddell

We Both Forget There's a small decision I could put off. It isn't urgent, but the reasoning behind it is a bit involved. I could come back to it in a few months. Nothing would break. I'm diligent enough that I'd get myself back up to speed when the time came. I try not to do that any more. Putting it off doesn't make the decision worse. That's the trap. It feels free, because the quality of the eventual call isn't really at risk - I'd rebuild what I needed and decide just as well. What's at risk is the hour. Not the hour to decide. The hour to reload everything I'd need to decide well: the context, the half-formed map of why this is hard and what each option costs. I had all of that in my head today, for nothing extra. In a few months (or even hours) I'd be paying to load it again. So the thing I'm protecting isn't the decision. It's the understanding. And understanding, it turns out, is perishable. It's perishable in almost exactly the same way for me and for the AI I build with. Mine works in two stages, roughly. There's the live stuff, what I'm holding in my head right now: this problem, its shape, the three things I just worked out. And there's the long-term store, where a fraction of that lands if it gets consolidated, and where even the fraction fades if I don't come back to it soon. Not everything makes the jump from the first to the second. What does make the jump doesn't stay sharp forever. The AI I build with has the same architecture. It has a context window: the live stuff, everything it's actively holding about what we're doing. When that window fills, it gets compressed, summarised down to something smaller so the work can carry on. Some of the detail survives the compression. Some of it doesn't. What survives is a summary, not the thing itself. And you don't get to choose what survives. Two stores. A small, sharp, live one. A larger, lossier, more durable one. A save between them that drops detail, and decay or compression after. That is a human brain, and that is a large language model. I didn't notice this while we were working. Nor did the AI. It was happening to both of us the whole time. It loses the thread of things we settled hours ago and needs them explained again; I do the same across weeks. I asked it a question about a past conversation. I remembered it. It didn't. It tried very hard to rebuild the answer from all sorts of sources. In the end I just found the right chat and scrolled back up. But if it had asked me the same question, no such easy option. Watching it forget is what made me notice that I do too. Once you see it, "do it while it's fresh" stops being tidiness and becomes arithmetic. The moment you fully understand something is the cheapest it will ever be to act on. Defer, and you don't only pay to rebuild. You rebuild from a faded copy, or a compressed one, and you can rebuild it slightly wrong. The reconstruction isn't just slow, it's lossy. You can talk yourself back into an understanding that isn't quite the one you had, and never know the difference. You can't fix the forgetting. That's the uncomfortable bit. None of us can add more live memory, or hold off the fade, or un-compress the summary. It's the shape of the machinery, on both sides. What you can do is consolidate on purpose. Write the thing down while you still hold it - not notes for their own sake, but the decision and the reason for it, put where the next person will look. Where the next me will look, once the fade has done its work. Where the next context window will look, after the compression. An external record is the one memory that doesn't decay, and it's the only one both of us can actually rely on. That is why I close the hard things out while they're still open in front of me, and why I make the machines write down why they did what they did. Not discipline. Not neatness. It's that today I understand this, and neither of us, not me and not the AI, can promise we'll understand it as well tomorrow.

I run my task app's AI dev team entirely on GitHub. Issues are its inbox, labels are its mutexes, comments are its audit trail, Actions is its nervous system. GitHub made that possible, and given what I knew when I chose it, I still think it was the right choice. But... This last month, GitHub itself has been the least reliable part of the system. Not the AI. The plumbing underneath it. Examples, all from the last fortnight: For 56 minutes one afternoon, Actions ran nothing at all, repo-wide. Every workflow, instant startup_failure. It recovered on its own. Nothing on the status page covered it. One branch went completely silent. Three different webhook trigger types produced zero CI runs, while a sibling branch minutes earlier worked perfectly. I merged with a bypass and wrote the justification up by hand. Scheduled workflows are the big one. My every-15-minutes sweep delivered 3 runs in a day. The nightly cleanup job - the safety net that unsticks dead agent runs - simply didn't fire, two nights running. One of those runs eventually turned up 11 hours late. The docs do say schedules are best-effort under load. Nobody reads that sentence expecting "not at all". So last week I added a watchdog on a different company's scheduler, whose only job is to check GitHub's scheduler did its job, and to fire the workflow itself when it didn't. I built it after the manual version - me noticing over breakfast and pressing the button myself - had been needed two mornings straight. Then the bill. 3,000 included Actions minutes didn't come close to covering the month, and the meter is running at about $50 - a decent chunk of it CI runs and preview environments spun up for documentation-only changes. The noise costs actual money. And on a different repo: I hit the Actions artifact storage quota. There's no proper breakdown of what's using it, no way to extend it, and when you delete the artifacts, the quota number doesn't move - and no way to force it to update. The docs say it will clear in 6-12 hours. It took a lot longer than that. Search the community forums for "storage quota not updating". It's not just me. <sigh> That's the shiny bit of the setup and the messy bit, side by side. And none of it has changed where the code lives - GitHub is the market-leading repo system for a reason, and the network effects are real. But I've stopped thinking of it as infrastructure and started thinking of it as weather. You don't rely on weather. You check it, you plan around it, and you keep a coat in the car. And I've started watching the alternatives properly. Cursor launched Origin last month, pitched as agent-first git hosting. The one review I've heard couldn't find anything it does that GitHub doesn't. Fair enough - but the list above is what agent-first means to me: delivery you can trust, schedules that fire, quotas you can see. That's the scorecard I'll be marking the newcomers against. And it makes me tempted to give Origin a spin. If you're building agents on GitHub: assume any webhook can fail silently, treat every cron as optional, verify everything happened rather than trusting that it did, and put your safety net's safety net somewhere else entirely.

Fable usage burned for the week. But today, rather than dropping to Opus 5, I went back to 4.8. Jesus, it's like revising an old friend after a prolonged absence! Opus 5 is great for long, non-interactive grinding tasks, and I'm very happy with the results, but interaction is dreadful. Can't wait for it to not be the latest version.

This morning I typed a 2-sentence feature request into our tracker for The One List, the task app we're building. Filed it at 8:55, went into my 9am meeting. At 9:32 there was a built, tested, reviewed pull request waiting for my click. Not for the feature I filed - for the better-specified version of it I'd filed in June and forgotten. My AI team closed this morning's as a duplicate, worked out why the June one had been invisible to its own sweeps for 10 weeks, repaired that gap, and built the June one instead. Six agent runs, five hand-offs: triage, a design pass, a re-triage, a build, and an independent review that re-verified the other agents' claims against the code rather than taking their word. Deployed to a PR environment, 2,500 tests run. My total involvement: one click. That's the shiny bit. Here's the messy bit. Getting here broke in every way you'd predict, plus a few you wouldn't. The worst day: one dispatch fanned out into nine concurrent builder runs on the same issue. Our agents were fired by GitHub label triggers, and the trigger matched the label SET, not the event - GitHub emits one webhook per label in a batch write, so one write woke every matching agent. Nine builders, one issue, each convinced it held the job. We paused the whole team for three days and rebuilt delivery: one dispatcher workflow that reads which label actually fired, dedupes on a concurrency group, and fires exactly one agent by API with an explicit dispatch message. The agent has to echo that message back in its claim comment, so every claim is traceable to the dispatch that caused it. Since the rebuild: every dispatch, exactly one run. Concurrency, generally. A label is our claim mutex - claim, then re-check, because two runs can both claim inside the same second and one has to stand down. And we learned that a full-set label update is a silent race: whoever writes second erases whoever claimed first, no error, no trace. Every label write is an add-one or remove-one API call now. That rule exists because we watched the other kind nearly cause a double implementation. Stale instructions. The agents read their own operating rules from the repo at run time. A failed git fetch fails silently - the local ref stays pinned to last week and everything still "succeeds". One agent filed a confident bug report against a state of the codebase that no longer existed. Every run now fetches immediately before reading, and cross-checks the SHA against the live API before any decision rests on the content. Death. A run that dies between claiming work and finishing it leaves the mutex locked, and a locked mutex looks identical to a busy one. So a nightly reaper clears claims with no artefact behind them. Then GitHub's cron scheduler started dropping the reaper's own slot - two nights running - so now a watchdog on a completely different scheduler checks that the safety net ran, and fires it if it didn't. "Who watches the watchmen" turns out to be a real ticket in the backlog. And my favourite: the reviewer that never woke up. It claimed a PR while CI was still running, subscribed to a completion event that never fires for its trigger type, and slept forever. The PR merged with no review and no record. Reviews now finish in the pass that started them, polling CI with a hard cap. Three rules made it stable. GitHub is the only ledger. No agent keeps private state, ever. Every action leaves a comment, a label or a commit, and the corollary does the real work: an action that left no trace didn't happen. A triage with no comment is not a triage. Review trusts nothing. The reviewing agent re-verifies the builder's and designer's claims against the diff, not the comments. It has caught real contradictions between what a PR said and what its code did. And autonomy is earned on measured results, not on a good week. Every merge is still mine, for now. Each class of change - docs, dependencies, code - earns wider autonomy on a tracked streak of clean reviews, and one caught defect resets that class's counter. None of this needed exotic tooling. It's a repo, labels, one workflow file and a handful of scheduled agents with a page of instructions each. The hard part wasn't intelligence. It was what it always is in distributed systems: delivery, mutexes, dead processes and stale reads. The agents are smart. The plumbing still had to be built as if they're not.

Small businesses often juggle too many apps like spreadsheets, CRMs, calendars, and messaging tools, leading to wasted time and lost data. With automation and integrated systems, everything syncs seamlessly, giving you a full customer view while cutting down on tools.

I've started using Wispr Flow today, it's like Dragon and Microsoft Dictate and Grammarly all mashed up together into one. It's definitely speeding up my workflow on writing messages like this one. Give it a go. This will give you one month pro free: wisprflow.ai/r?JAKE325

I've #justsponsored Jake Liddell, who's fundraising for Macmillan Cancer Support on @JustGiving. Donate now justgiving.com/page/jake-lid…

Next Saturday I will be attempting to walk around all the Monopoly locations in London, a distance of about 25km. It's in aid of The Robin Cancer Trust, aiming to save lives by raising awareness of testicular cancer. Would love your support if you can- justgiving.com/campaign/mono…

I just published AutomaticBusiness #1 - Decisions, decisions. Deciding on Agency v SaaS models. Check it out here pages.automaticbusiness.co.u… via @ConvertKit

🔥 @AdsPowerBrowser is celebrating their #5thAnniversary and offers up to 50% discounts on subscriptions! ✅ Reliabel fingerprint & IP spoofing ✅ Best Synchronizer for scaling 🚀 #AdsPower is the antidetect browser you're looking for adspower.com?ref=IKiMGI&sour…

Dreadful customer care experience from O2. I have been on the phone for over an hour, I'm being transferred to my 3rd customer services team, there's no way to contact them apart from ringing. If anyone from O2 wants to reach out... wishful thinking? @O2 #o2

So, the long walk is all done and dusted! It was a tough old slog at the end, with a gale in the face, and the occasional short downpours of driving rain, but got there in the end. Thank you to all for your support! justgiving.com/fundraising/j…

Wow, doesn't time fly? #MyTwitterAnniversary

Wow! Just discovered Mailbird I love it! I can manage all my email accounts in one place with the best email client for Windows. #emailclient #productivity getmailbird.com/