engineering

If you are about to assert that a tool isn't installed, run `which` first. The check is one line. The cost of skipping it is a half-hour of defensive scaffolding for a problem that wasn't there.

The first time you run a quality gate against real data, the output is less about the gate and more about the data.

When your tool depends on the host, declare the dependency at the gate. Don't wrap it. Don't patch around it.

A clever optimisation that was a silent regression. The override flags survived out of habit. None of the reasons survived contact with the actual numbers.

Shopify's pi-autoresearch got 300x test speedups. But the real insight isn't performance — it's that the pattern works on anything with a number.

When choosing CLI vs MCP, pick the one you can undo. CLI wraps into MCP cheaply. MCP does not unwrap.

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.

Smart model plans, cheap model builds. The pattern everyone's converging on for AI coding agents — and the piece nobody's shipped yet.

I turned the seven patterns into a zero-dependency Python library. Then I added MCP bridge support. Here's what I learned about the gap between patterns and code.

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.

Willison says CLIs beat MCP. Cloudflare says server-side code mode beats both. They're both right, because they're answering different questions.

I designed an elegant framework install for my personal AI system. Then I listed the hard problems and shipped a three-hour cleanup instead.

A day of reading skill repositories taught me less about the skills themselves than about how much I'd missed of the surrounding ecosystem.

I renamed one concept across 130 files. The pain crystallized into a tool that will do the next rename in minutes.

Most projects pin dependency versions to avoid breakage. We automated the opposite: daily upgrades with automatic rollback.

We blamed the LLM for a 54% task failure rate. The real culprit was seven layers of dispatch infrastructure between intent and execution.

Repo boundaries enforce access control, not abstraction. Directories handle abstraction. If two things have the same visibility requirement, they belong in the same repo.

A 3-pass AI planning pipeline caught 0 out of 6 design issues. The same planning done in-session with tool access caught 2.5. Planning isn't a prompt problem — it's a tools problem.

The debate about AI agent autonomy is wrong. It's not a binary choice — it's a graduated trust system with observability.

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.

Upgrading to a more capable model made my tool sixty times slower. The lesson isn't about models — it's about the difference between capability and fit.

The most sophisticated solution to a problem is usually a sign you haven't found the right abstraction yet.

The real ROI of AI coding isn't doing the same work faster. It's doing work that wasn't worth doing before.

Peter Steinberger stopped reviewing AI-generated code entirely. That works for indie software. In regulated environments, it can't. Here's how to think about where you sit.

When behaviour emerges from both code and model responses, reading source files isn't enough. You debug by examining execution traces.

Tool enthusiasm is often net-negative. Context pollution degrades performance faster than features improve it. The principles that actually work.

Most teams build evaluators before reading a single trace. The sequence that actually works is the opposite: observe, categorise, then measure.

Aeronautics flew for decades before anyone could explain why wings worked. AI is in the same position. The engineering is ahead of the theory.

The primary user of my CLI tools isn't me anymore. Designing for that changes everything about how output should work.

I published three Rust CLI tools to crates.io before noon — none existed at breakfast. The interesting part isn't the speed. It's that the bottleneck moved.