Getting the Most Out of Fable: Run It Like a Colleague, Not a Chatbot

In part 1 I made the case that your first homelab should cost £0 and start with the tower already under your desk. This part is about the other thing already sitting in front of you that most people are using at about 5% capacity: a frontier AI model.

Anthropic recently shipped Claude Fable 5 — the first of their Claude 5 family, a tier above the Opus models that came before it. I’ve been running it against my homelab and my notes system for a while now, and here’s the uncomfortable truth I’ve landed on: the model is not the bottleneck. I am. Or more precisely, the system I give it to work in is.

Ask Fable a question in a chat window and you get a very good answer. Give it a filesystem, a contract, and permission to actually do things, and you get an entirely different category of output — the kind where you come back from making a cup of tea and a container that’s been dead for two days has been forensically diagnosed, restored from backup, and configured, with a written report of what was checked.

This post is the difference between those two experiences, in five lessons. None of them require anything exotic — I run all of this through Claude Code (the terminal version) on an ordinary Windows PC, against the same Proxmox host you’ve seen in the Network Journey series.

Lesson 1: Give it a filesystem worth trusting

The single biggest upgrade wasn’t a prompt technique. It was boring: I organised my drive.

My setup is one dedicated drive with four top-level homes:

A:\Brain            # notes vault (PARA-style: Inbox / Projects / Areas / Resources / Archive)
A:\Repos            # one git repo per project or tool
A:\Sorting Office   # staging area for anything unsorted
A:\RecycleBin       # nothing gets deleted; it gets retired here, dated

Why does a model care? Because an agent’s competence is capped by how much of your world it can see and navigate. When every project has one obvious home, the model stops guessing. When there’s a designated staging area, “sort this mess out” becomes a tractable task with a defined done-state. And when the rule is retire, never delete — everything swept into a dated RecycleBin folder instead of erased — you can let it reorganise hundreds of files without holding your breath.

That last rule matters more than it looks. The reason I can hand over destructive-shaped work is that nothing is actually destructive. Every sweep is an undo away from recovery. Design for reversibility and you can delegate ten times more.

Field fix mindset: you don’t need to reorganise your life first. Pick one folder — downloads, documents, whatever’s worst — declare it the staging area, and let the model propose (not execute) a sort. You’ll learn its judgment before you trust its hands.

Lesson 2: Write the contract down

Somewhere early on, every agent user hits the same fear: what if it goes off and rewrites something I cared about? The answer isn’t hoping the model behaves. It’s a contract — a plain-text file the model reads at the start of every session.

Mine lives in the repo the agent runs from, and the core of it fits in four lines:

Read anything in the vault as source material.
Write only into the vault’s Inbox — one dated folder per delivery.
Never modify existing notes or live systems unless a handoff explicitly grants it.
Moving a delivery out of the Inbox is my approval. The agent never promotes its own work.

That fourth line is the load-bearing one. The model produces; I review; physically moving the folder is the sign-off. There’s no ambiguity about what “approved” means, no way for enthusiasm to leak into my live notes, and — the part nobody tells you — no anxiety on my side, which means I delegate more. The contract isn’t there to restrain the model so much as to let me relax my grip.

Claude Code reads these automatically (drop a CLAUDE.md in the repo). Whatever tool you use, the principle holds: rules in a file beat rules in your head, because the file is there at 2am when you’re not.

Lesson 3: Teach it your rituals once — then invoke them

Watch yourself use an assistant for a week and you’ll notice you re-explain the same procedures over and over. How you like work packaged. Where drafts go. What “verify it” means in your house.

Claude Code has a feature called skills — Markdown files describing a procedure, invoked like a command. The honest way to think of them: standard operating procedures the new colleague actually reads. Mine include:

/triage — sort loose files into the system, duplicates detected by hash, nothing deleted
/deliver — package finished work as a dated review folder with a what-was-verified note
/homelab-change — infrastructure changes must go inspect → plan → apply, with rollback stated per step
/article — draft for this site, in my voice, from my notes, never published directly

Each one took a few minutes to write, once. The compounding effect is hard to overstate — the difference between an assistant you brief every morning and a colleague who’s been here six months. If you do nothing else from this post: next time you catch yourself explaining a procedure to an AI for the third time, stop, and ask it to write the skill file itself. It’s very good at that.

Lesson 4: Make verification the house culture

A model that wants to be helpful will tell you the job is done. A system makes “done” mean something. The three rules that do the heavy lifting in mine:

Inspect first. No change to anything live until the current state has been captured — actual command output, not assumption. Half the value is that the model routinely discovers reality doesn’t match my mental map before acting on it.
Copy → verify → then retire the original. File moves are hash-checked (Get-FileHash, five seconds) before the source goes anywhere. Sounds paranoid; costs nothing; has caught real divergence — including a folder where “identical” copies turned out to be two different versions edited five hours apart.
Evidence in every report. Deliveries state what was checked, not just what was done. “Verified: page returns 200” is a claim I can audit. “It works” is vibes.

None of this slows the model down meaningfully. What it actually does is transfer trust from the model’s confidence to the system’s receipts — which is the only kind of trust that scales.

Lesson 5: Let it touch real things — behind gates

Here’s where most people never go, and it’s where the compounding actually lives. Everything above is preparation for this: giving the model real infrastructure access with graduated permissions.

A concrete story from this week. My Hermes agent container — the one from the Discord saga — went dark. I asked Fable to sort it out. What followed, unsupervised: it found the Proxmox host’s address from my own network inventory notes, established SSH access (asking me exactly once, to authorise a key — a genuine human-in-the-loop gate), discovered the container had been deliberately destroyed two days earlier during a half-finished migration I’d forgotten about, reconstructed that timeline from the task log, found the last nightly backup, stopped and asked which direction I wanted — restore the old build or complete the new one — then restored, dropped two dead mount points that referenced shares which no longer exist, applied the configuration guide from my notes, and produced the service status as proof.

Then it deployed an entire media stack — ZFS dataset, Samba container, Jellyfin with iGPU transcoding — from deployment scripts it had helped write in a previous session, catching along the way that my notes had the ZFS pool name wrong, and fixing an unprivileged-container GPU permission snag with a one-line udev rule.

The point isn’t “the model is clever”. The point is the shape of the workflow: plan mode before apply mode, at every step. Scripts that default to printing what they’d do. Explicit stop-points where a human decision is genuinely a human decision (restore vs rebuild — that’s my call, and it asked). Reversible actions everywhere else. The gates aren’t friction that slows the agent down; the gates are why the agent gets to do interesting work at all.

What I’d tell you to do this weekend

Make one tidy corner. A staging folder and a “retire, don’t delete” rule. Half an hour.
Write the four-line contract. Where it may read, where it may write, what approval means.
Turn your three most-repeated explanations into skills. Ask the model to draft them.
Demand receipts. “Tell me what you verified” in every piece of work it hands you.
Give it one real, gated job. Something reversible on real infrastructure. Watch what happens.

The 100x version of this tool isn’t a better prompt. It’s a better workplace — and you’re the one who builds it. The model turns up on day one already brilliant; whether it performs like a chat window or a colleague is decided entirely by what you hand it to work with.

Next in the series: the Discord panic that started all of this — what happens when your AI agent gets a messaging platform and opinions.