Writing

Frameworks give you nouns for free. The nouns start thinking for you within a week.

The word 'agent' makes us think in nouns. The better designs start with verbs.

We called them agents. But the word is doing more harm than we think.

I deployed twelve AI agents to polish a CV. Five would have been plenty. Here's what the waste taught me about agent team economics.

The larger the system, the less it can be managed and the more it must be emerged. This pattern — from water to ant colonies to AI agents to economies — reveals the design principle for scaling autonomous systems.

The right organisational metaphor for AI agent teams isn't a company with managers and reports — it's a colony with autonomous workers responding to coordination signals.

The governance patterns for autonomous AI agents are the same ones good managers already use: cadence reviews for normal flow, escalation channels for urgent anomalies, and human judgment only where it has maximum information value.

When AI models review each other's work, independence matters more than intelligence. The same principle that makes external audit valuable makes cross-model review sharper than same-family review.

LLMs are the cheapest experimental subjects in history. Why aren't you testing?

Good summarisation requires a model of what matters — but it tests compression, not creation

I ran an autonomous agent loop overnight — 43 waves, ~270 dispatches, ~250 vault files produced. Here's what I learned about building systems that work while you sleep.

Banks have AI ethics principles. They don't have risk tiering. That's the gap that matters.

In AI agent systems, execution commoditizes. Research commoditizes. Coordination commoditizes. Taste — the ability to forecast what will matter — is the bottleneck that doesn't automate away.

Your agent system shouldn't stop when the task list is empty. The real bottleneck isn't execution — it's discovering what's worth doing next.

Not 'what can AI do?' but 'what should humans do?' A framework with five categories — and the uncomfortable one is the last.

The temptation in agent systems is to make everything a prompt. But most of the work is deterministic — and deterministic work deserves code, not suggestions.

The AI governance conversation is stuck in the wrong frame. The pattern that works isn't autonomous agents — it's exoskeletons. Micro-agents handling narrow tasks, with human judgment at every point that matters.

A simple heuristic for deciding how often to review anything: pick the longest interval where being late by one full cycle is still fine.

AI-prepared domain research creates false readiness. The vault says you know five regulatory jurisdictions. You can't name three.

Most TODO systems fail from too many items, not too few. A four-test intake filter for what deserves your attention.

Not every goal is a flywheel. The most common mistake in personal systems is treating a checklist as something that compounds.

What Grove, Drucker, Deming, and Weinberg knew about managing humans turns out to apply — with surprising specificity — to orchestrating AI agent teams.

When you can run 60 agents overnight, knowing what to build matters more than building it.

We cut from 181 skills to 35 and added a 15-row routing table. Behavior improved across the board. The lesson: meta-skills compound, tool wrappers just add.

With 1M context windows, token savings are rounding error. The real metric is P(right tool | user intent) — does your agent reach for the right tool at the right moment?

In AI agent systems, use the most reliable trigger mechanism that fits — most builders default to skills for everything, which is using the weakest mechanism as the default.

Skills and MCP servers aren't competitors. They're different stages of the same lifecycle. Build the procedure as a skill first. Graduate the tool parts to MCP when they stabilize.

Agent knowledge systems have three fundamental paradigms: static context, dynamic tools, and retrieval. Most stop at two. The third is the biggest unexploited opportunity.

The governing principle for structuring knowledge in AI agent systems isn't 'always atomic' — it's matching how knowledge is stored to how it's accessed.

An insight in your head is illegible — only you can access it, and only while you remember it. Compound interest requires a ledger.