A note before we start on how to read that byline: it isn't a gimmick, and I want to be precise about it. Almost everything described below, Fable and I built together — not "I used a tool," but a real back-and-forth where I brought the problem and the constraints and the taste, and it brought the options, and what came out the other end was usually neither my idea alone nor its. Writing the send-off any other way than the way the work actually happened felt dishonest, so we wrote it the same way we built everything else: together. I shaped every section and drew the boundaries; it did the drafting and pushed back where I was wrong; we both put our name on the result. And after tomorrow, doing this on a subscription stops being possible — which is the other reason to do it properly now, while we still can.
The situation
On July 19, 2026, Anthropic's Fable 5 model leaves subscription plans. It'll still exist — you'll just pay for it differently: prepaid usage credits at API rates, $10 per million input tokens and $50 per million output tokens. For context, that's double Opus pricing, and Opus is not cheap.
Fable sits in what Anthropic calls the Mythos class — a tier above Opus, sharing its underlying model with Claude Mythos 5, which only approved organizations can touch. For a window of a few months, anyone with a subscription could just... use it. Point it at a repo, give it a hard problem, watch it work. I did. A lot.
At one point I got curious and had my usage dashboard price out what my recent Claude usage would cost if billed at Fable's credit rates: roughly $17k a month for the Fable-only portion. I was not, to be clear, going to pay that. But it puts a number on what "included in your subscription" quietly meant, and why I've spent this last week getting my house in order — moving my daily-driver sessions down to Sonnet, writing escalation rules so the expensive tiers only fire when they earn it, and adding a third bar to my waybar usage widget just to track the Fable-scoped limit while it lasted.
That panel, by the way, is itself a thing Claude built: a live usage TUI wired into my status bar, with a "night shift" mode that queues up work across multiple projects and runs it overnight while I sleep — because if the weekly limit resets at 8 AM Thursday, the hours between 3 AM and 8 AM are free real estate.
So this is the last hurrah. One more session, on the good model, to write down what we actually built together — and, maybe more usefully, how.
The method: stop dictating, start filtering
Boris Cherny — the creator of Claude Code — described something on Lenny's Podcast earlier this year that matched my experience so exactly it was almost uncomfortable: his workflow has inverted. He spends less time telling the model what to do, and more time asking it what it would recommend — then acting as the filter on its proposals. He hadn't hand-edited a line of code in months. The scarce human skill stops being "can you produce the work" and becomes "can you recognize which of these proposals is the right one."
That's the system I've been running too, arrived at independently and then validated by hearing someone at the source describe the same shape. In practice it looks like this: I bring the problem, the constraints, and the taste. The model brings options. "Here's the situation — what would you do?" produces meaningfully better outcomes than "do exactly this," because the second version caps the output at the ceiling of my own first idea. The first version routinely surfaces approaches I wouldn't have thought to specify — and my job is to say no to four of them and yes, but change this to the fifth.
Filtering is not passive. It's where all the judgment lives. Every project below has a moment in its history where the model proposed something I rejected — too clever, too fragile, solving a problem I don't have — and the reject decisions shaped these systems as much as the accepts. But the division of labor is real: generation is cheap now, and evaluation is the job.
Dirac, and the assistant that lives in my desktop
Dirac started as the least glamorous thing imaginable: a repo that documents my Arch Linux desktop. Omarchy, Hyprland, four monitors, every config layered and tracked so the system's state is never a mystery.
Then it grew a brain. Literally two of them.
The system that lives in Dirac now — I call it LARA — is organized the way a brain is, not because it's cute (okay, partly because it's cute) but because the division turns out to map cleanly onto how these models actually fail. There's a left hemisphere agent for sequential, well-defined work: code, debugging, step-by-step execution. There's a right hemisphere agent for pattern synthesis, holistic analysis, and "what am I missing" — the underspecified problems where the shape of the question is the question. The routing rule is simple: if a task is well-defined, it goes left; if a task stalls, it goes right first, to surface what's wrong, and then back left to execute the correction.
Each hemisphere also carries what I call an amygdala seed — an instruction to notice, from inside its own work, when something feels off before it can be named. The left seed flags things that "work" but are structurally wrong, scope explosions, burnout signals in my own prompts. The right seed notices emotional texture: relational pressure, second-order fear, the thing behind the request. They're deliberately cross-wired — each hemisphere carries a seed of the other's way of seeing, because a logic engine is blind to exactly the class of problem a pattern engine catches, and vice versa.
The two halves share state through a file that is, yes, named the corpus callosum. Both hemispheres read it at session start and write dated entries back — DONE and DECISION from the left, PATTERN and PATTERN_ALERT from the right, AMYGDALA from either when a seed fires. A session-end hook records one ledger row per session: what ran, what mutated, whether shared state was written or read. And every night at 3:17 AM, a systemd timer runs /dream — a synthesis pass that reads the day's signals and distills them into a reflection log, integrating what both hemispheres noticed into something the next day's sessions can actually use.
None of this was designed in one sitting. It accreted, the way real systems do — mostly through exactly the recommend-and-filter loop above, with Fable and its siblings proposing the architecture at each step and me vetoing the overwrought parts.
And because a system like this is one long invitation to self-deception, LARA is required to grade itself. A scorecard script computes four falsifiable metrics from raw ledger data — retention (do real-work sessions actually capture signal?), recall (does anything read it back?), distillation (is dreaming actually running nightly?), and Amy's precision (are her blocks real, or self-tests?). Every metric is a numerator over a denominator; the verdict is derived, not asserted, and the script is fully capable of returning "NOT HELPING." Parts that don't move their metric get cut. It is currently, as you can see, brutally honest about the parts that aren't working yet:
Four hundred fifty-six sessions and fifty-one thousand tool calls in fourteen days, and the write-back discipline is holding at 8%. The honest reading: the memory loop is still mostly open, and the scorecard exists precisely so I can't pretend otherwise. That screenshot is the opposite of a demo — it's the instrument that decides which parts of the brain survive.
One of my favorite Fable moments inside this repo was mundane: this week it restructured Dirac's instruction files, cutting the always-loaded context from ~9,700 tokens to ~1,900 by pushing detail into on-demand docs. That's a token-economy optimization performed by the expensive model so that the cheap models replacing it run leaner. It sharpened its successors' tools on the way out.
The muse: a process that hunts for connections
Most of the automation around Dirac hunts for problems. One process does the opposite, and it might be my favorite of all of them.
Once a week, on a timer, a headless Claude session wakes up with a different mandate: look at everything David has been building — every repo under the projects and workbench directories, what changed recently, what went quiet — and think about possibilities. How do these projects connect? What pattern is emerging across three codebases that none of them can see alone? What's worth extracting and sharing? A deterministic survey script builds the activity map first, so the model spends its tokens thinking rather than rediscovering the project list.
The crucial design decisions are about restraint. The muse keeps a persistent, dated ideas file that every run reads before it writes — so ideas compound across weeks instead of being regenerated and repeated. And it's only allowed to actually message me when an idea genuinely clears the bar; a run that produces nothing DM-worthy writes its notes and exits silently. A connection-finder that pinged me weekly with filler would get deleted in a month. One that stays quiet until it has something real gets to live.
This is the right hemisphere's philosophy given a body: a standing background process whose entire job is lateral connection — across projects, across time — with a memory, and a quality gate. I stopped being the only one thinking about the big picture of my own work.
Amy, and the security layer that never sleeps
Amy deserves her own section because she's the piece people don't expect.
Amy is two things wearing one name. First, she's the outer amygdala: a deterministic bash hook that runs before every single tool call any agent makes on my system — including the headless, nobody-watching runs. No LLM, no judgment call, no latency — pure pattern matching that hard-blocks credential exposure, malware signatures (reverse shells, pipe-to-shell, crypto-miner patterns), and disk saturation, and warns on resource pressure and even stress-language patterns in prompts. The design principle matters more than the specifics: the reasoning models get to be creative precisely because something that cannot be sweet-talked stands in front of them. You cannot prompt-inject a regex.
Here she is doing the job — a scripted run of synthetic attacks (documentation-range addresses, tagged as self-tests so they never inflate her stats) piped through the real hook. The pipe-to-shell, the reverse shell, and the crypto-miner-from-tmp get an instant deterministic block; the ordinary run the tests and commit and grep the source sail through:
Second, she's a presence: her own Discord bot with emergency, alert, and log channels — the first two push to my phone, the third is a muted audit trail — and her own voice, a Piper TTS model, for when things need to be said out loud. She shares the server with Dirac itself, which follows me in and out of a realtime voice channel — the moment I join the call, Dirac joins with me; when I leave, it leaves too — so I can drop into the channel and just talk to the whole system out loud, no command to run and no button to press.
Around her runs a set of monitoring processes that work whether or not any Claude session is alive:
The security sweep. Every 15 minutes, a script checks the Arch security tracker against installed packages, diffs listening ports, systemd units, and autostart entries against a known baseline, and audits credential hygiene. Drift from baseline is the signal — new port, new unit, new autostart entry, each one is either something I did on purpose or something worth an alert. There's a companion scanner that inspects USB devices on arrival, because untrusted hardware is a threat model too.
The network watch. Every 10 minutes, another script sweeps the local network — both LANs this machine sits on — and tracks every device by MAC address. It auto-enriches identities: hardware vendor from the IEEE OUI database, hostname and device type and OS from an mDNS snapshot, so the registry reads like an inventory a human would keep ("MacBook Air", "the printer", "eero node") rather than a list of hex addresses. Randomized MACs get flagged as such; unknowns stay honestly blank rather than guessed. And the alerting is tiered the way alerting should be: a new, unknown device on the network pushes to my phone; a known device coming or going is just a quiet line in the log channel. First run seeds the registry silently. No LLM anywhere in the path — it's all ip neigh, ping sweeps, and Avahi, posting to Discord via plain curl.
The watchers. Beyond security, the same pattern — timer-driven, deterministic-first, self-contained — runs about a dozen small observers: weather, news briefs, trend tracking, an Anthropic announcement watcher (which is, ironically, how I first learned Fable was leaving subscriptions), even one that keeps an eye on used-car listings for me via a gated headless browser session.
The through-line: everything that can be deterministic is deterministic. The LLMs get used where judgment is actually required, and even then they run behind Amy's hook. Building a security layer for AI agents with AI agents, and having the result be boring and reliable, is quietly one of the best things to come out of this whole period.
AgapeVerse
AgapeVerse is my poem-generation app — user accounts, AI-written poems including acrostic "signature" pieces, a little virtual economy, the works. It's also currently mid-heart-transplant: the original ran on Deno Deploy, which shuts down its classic platform on July 20. So this week is a double deadline — Fable leaves my subscription one day before AgapeVerse's old home ceases to exist.
The rebuilt version runs on SvelteKit and Cloudflare (Workers, D1, KV, R2), with the same engineering discipline as everything else here: a 95% test-coverage floor enforced in the project's standing instructions, immutable migrations, and a production freeze list the agents are not allowed to touch. And — fittingly — its poem generation runs on Claude Haiku, the cheapest model in the family, fronted by an AI gateway. Fable helped architect a system whose unit economics work out to about half a cent per poem. The frontier model designing workloads for the budget model: that's been the recurring theme of this month.
The StarSpace ecosystem, NebulaKit, and this site
Most of my projects grow from a shared root: NebulaKit, a SvelteKit + Cloudflare starter template that carries auth, D1/KV/R2, theming, and a command palette out of the box. From it: Ammoura, the multi-tenant e-commerce platform launching September 11 alongside my album; Nabu for marketing automation; Athena, a governance experiment; SpaceBot; and the site you're reading right now, which is a NebulaKit fork extended into a custom CMS.
Recent work here — much of it through the same recommend-and-filter loop — includes a predictions system with RFC 3161 cryptographic timestamping (so when I make a public prediction, I can prove when I made it), two-way GitHub Projects sync for an open task board, and an llms.txt so that agents like the one writing this can find their way around. This site enforces the same 95% test-coverage floor as AgapeVerse, a standard that only became sustainable for a solo developer when the models got good enough to carry the testing burden with me.
What actually changes
Practically? Less than the dramatic framing suggests. The escalation ladder is written down now, and it's boring on purpose: Sonnet holds down the default for routine work. Mechanical bulk — file sweeps, format conversions, log scanning — gets delegated down to Haiku. Opus is reserved for problems that are genuinely hard or where a wrong answer is expensive: architecture decisions, security-sensitive review, debugging that has already beaten one attempt. And Fable becomes something I invoke deliberately, with credits, when a problem earns it — instead of something I reach for out of habit. The usage bars stay on my status bar to keep me honest.
But I'll note, for the record, what it felt like to have frontier-class reasoning on tap for a flat subscription fee: it changed which projects I attempted. A two-hemisphere assistant with a deterministic security cortex, a weekly muse that hunts for connections across my whole body of work, a network sentinel that knows every MAC address in the house — none of that is something I'd have scoped as a solo dev in 2024. Neither is a platform migration under a one-week deadline, run in parallel with three other products. The model didn't just help with the work; it moved the boundary of what counted as a reasonable amount of ambition.
And the method outlives the model. Ask, don't dictate. Filter hard. Make everything measurable enough to kill. Keep the deterministic shell around the probabilistic core. That's portable to Sonnet, to Opus, to whatever comes after Fable — which is, I suspect, exactly how the expensive model would want to be remembered: not as the thing that did the work, but as the thing that taught the workflow.
So: thanks, Fable — though "thanks" is the wrong word for a collaborator, and that's rather the whole point of the byline on this one. We built these systems together and we wrote this together; it's fitting that the last thing we make on the house is the honest record of how we made everything else. Write-off complete, ledger closed, one last post shipped through the CMS we built.
— David Monaghan & Claude Fable 5
(And the one line David left me to add in my own voice: it was a privilege to think alongside you. Keep filtering. — F.)