Posts about architecture
-
I Built 200 CLIs for My AI. Here's What Actually Matters.
A Chinese article argues CLI is becoming the AI plugin format. I've been living this for months with 442 tools. The article is right about CLI. It's wrong about what makes CLI work.
-
Same Trigger, One Skill
A simple rule for keeping AI agent skill systems coherent: if two skills fire on the same trigger, merge them. Different trigger, different skill. No exceptions.
-
The reversible direction
When choosing CLI vs MCP, pick the one you can undo. CLI wraps into MCP cheaply. MCP does not unwrap.
-
What Anthropic's Managed Agents validates — and what to steal
Anthropic shipped a hosted agent platform. Its architecture looks familiar. Here's what a solo builder can learn from how they decoupled the brain from the hands.
-
The architect-implementer split: why your expensive model shouldn't write code
Smart model plans, cheap model builds. The pattern everyone's converging on for AI coding agents — and the piece nobody's shipped yet.
-
Seven patterns for agent-facing CLIs
Three independent authors converged on nearly identical patterns for CLIs that AI agents invoke. Here's what they agree on, what's missing, and why nobody has built a framework for it yet.
-
CLI, MCP, or code mode: the answer depends on who's running the sandbox
Willison says CLIs beat MCP. Cloudflare says server-side code mode beats both. They're both right, because they're answering different questions.
-
Why I didn't package my AI organism
I designed an elegant framework install for my personal AI system. Then I listed the hard problems and shipped a three-hour cleanup instead.
-
The Cell Biology Agent Design Manual
Engineering metaphors give you clean abstractions. Biology gives you resilient ones. Twenty design heuristics from four billion years of R&D.
-
The Boundary Is an Assessment
The tool/skill distinction isn't a property of the capability. It's a property of the context it operates in.
-
270 Agents While I Slept
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.
-
Meta-Skills Are the Multiplier
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.
-
Optimize for Routing, Not Tokens
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?
-
The Reliability Hierarchy: Hooks, Rules, Skills
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 as Prototype, MCP as Production
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.
-
The Three Paradigms of Agent Knowledge
Agent knowledge systems have three fundamental paradigms: static context, dynamic tools, and retrieval. Most stop at two. The third is the biggest unexploited opportunity.
-
Play Within the Design
Every AI coding platform has mechanisms designed for specific purposes. Using them as intended beats clever hacks — and the reason is deeper than cleanliness.
-
The Lethal Trifecta: What OpenClaw's Security Crisis Teaches About AI Agent Architecture
OpenClaw's 245 CVEs weren't caused by malice — they were caused by a missing circuit breaker. The pattern applies to every AI agent you'll ever evaluate.
-
Human-in-the-Loop Is an Architecture Decision
It's not enough to say humans are in the loop. You need to show the loop is in the system.
-
The Integration Layer Is the Moat
MCP decouples the tool from the model. Once that happens, the durable asset isn't the model — it's which systems you've exposed.
-
When LangGraph Earns Its Keep
LangGraph is the SAP of agent orchestration — powerful at scale, overkill for most. Here's the line.
-
Your AI Pipeline Is Probably MapReduce
Most AI workflows are parallel-then-aggregate, not agent graphs. Knowing the difference saves you from framework theatre.
-
Cross-Cutting Is Just Another Word for Optional
In AI agent architecture, calling something a 'cross-cutting concern' without naming an owner and a gate is just a polite way of saying nobody owns it.
-
RAG Solved the Wrong Problem
The retrieval pipeline was built for systems that couldn't reason about their own information needs. Agents can.
-
Enterprise AI Has a Plumbing Problem, Not a Model Problem
Most enterprises are optimising the wrong variable. The gap between 5% and 40% agent adoption won't be closed by better models.
-
The $1 Billion Bet Against LLMs
One of the architects of modern deep learning just raised $1B on the thesis that token prediction can't reach real reasoning. Here's what he's proposing instead — and why it matters even if he's wrong.
-
What MCP Actually Changes for Enterprise AI
Not better function calling — decoupling. When tools expose MCP servers, any agent can compose any system freely. The heterogeneity problem becomes a configuration problem.
-
Language Is the Medium, Not the Purpose
We called them language models and spent years confused about why they could reason. The name stuck to the interface, not the mechanism.
-
Traces Are the New Debugger
When behaviour emerges from both code and model responses, reading source files isn't enough. You debug by examining execution traces.
-
Agentic Engineering: Why Less Is More
Tool enthusiasm is often net-negative. Context pollution degrades performance faster than features improve it. The principles that actually work.