Topic
An agent as a collaborator rather than an autocomplete — design systems, durable knowledge, automation ladders, subagent fleets on my own source, and now in CI.
Running Anthropic's prompt-audit over 2,700 lines of Claude Code steering before moving to Fable 5.1. The grep for pressure language hit once. The cruft was drift and changelog phrasing, and seven of the eight recommended prompt snippets were already in the harness.
I had Anthropic's always-on security plugin installed for a month and assumed it was reviewing every turn. Its own log said otherwise. What each layer actually does, how far its configuration goes, and the one hook that says no.
Most 'chat with your docs' tools retrieve fragments at query time. OpenKB compiles the synthesis once, at ingest - into a Markdown wiki you can read, diff, and ship as an installable Claude Code skill.
I ran the /eli5 skill over a Jinja2 learning session and got back a self-contained, illustrated artifact. Here is what the skill is, why writing the five-year-old version sharpens your own understanding, and where it fits a learn-then-teach workflow.
I built a local instrument to look at embedding space, and most of what I assumed turned out to be wrong: nothing is orthogonal, no individual dimension means anything, and king minus man plus woman does not give you queen.
Claude Code's /insights command handed me a mirror: 82 sessions of my own habits, scored. Here is what it got right about how I work, and the one thing that quietly costs me the most.
Putting a self-hosted identity server in front of LinkedIn deleted 240 lines of workaround and turned PKCE back on. It also handed out a privilege escalation — because the claim never changed, but the trust underneath it did.
I gave three agents a worktree each and watched what landed on disk — the pid inside the lock file, the worktree that erased itself completely, and the shared site-packages that no amount of git isolation was ever going to protect.
I had written the same rule three times, which is a diagnostic, not a wording problem. Splitting my Claude Code config across the layer that fits each instruction: CLAUDE.md 250 to 163 lines, six path-scoped rules, and two hooks that cannot be talked out of it.
Claude Code keeps a usage ledger nobody reads. After 511 sessions I opened mine: 73 skills invoked, 31 of them exactly once, three still on disk. The survivors all have one thing in common.
I ran /install-github-app on my own repo and ten minutes later a README PR was merged. The timings are the least interesting part — the write path, the commit attribution and whose rules the CI agent followed are better.
I pointed the new claude-security plugin at this very site. It spawned 82 agents, proposed 10 vulnerabilities, and then argued itself out of 9 of them. The one that survived was real — and it shipped to prod the same afternoon.
How I turned my repo's operational knowledge into custom Claude Code skills — /dev, /code-review, /ship — so any change goes from idea to verified-in-production in a single session, with me still on the trigger.
An evening climbing the loop ladder in Claude Code, from a one-shot fix to an unattended cloud routine. The lessons had nothing to do with the code and everything to do with how a loop stops: unenforceable budgets, self-writing reward hacks, and why a trapped loop cannot free itself.
Open Knowledge Format (OKF) is a dead-simple convention for storing durable, executable knowledge alongside your code — no database, no network, just markdown files your AI agent can read and act on.
I love how my site looks, so I taught Claude to build with it — extracting a live React app into a real design system on claude.ai/design, verified component by component.
Posts that touch this subject but live under another topic.
Traces, Tempo and the LGTM stack
If you distribute a Claude Code agent to a marketplace, every developer who runs it spends your reasoning budget and yours to answer for. Here is how I wired Claude Code's built-in OpenTelemetry into a Grafana/LGTM stack to watch cost, tokens and tool decisions — per run.