ai

Long-running agents are not defined by the model call. They are defined by the state, rules, tools, failures, and corrections that survive it.

Ken Griffin watched PhD-level finance work compress from months to days. The interesting question is whether bank AI controls are designed for the layer where the work now lives.

Coding agents move the bottleneck from implementation to shared intent.

When execution gets cheap, the scarce work moves to framing, review, and the systems that preserve judgment.

Fast repair is useful, but it does not prove that a system remains understandable.

Finance agents are evidence custody systems before they are model systems.

Persona-based AI reviews predict how stakeholders will react to a paper. They cannot tell you whether to act on those predictions, because the commissioning history is invisible to the lens.

AI cannot help an enterprise that cannot describe itself, and governance failure surfaces faster than optimisation failure.

Five rounds of the same question produced diminishing returns by round three. Then I changed the question — same document, different reviewer.

If you can replace 'agent' with 'application' and the principle still reads fine, it was never about agents.

LLMs check whether each item in a list sounds right individually. They don't check whether all items are the same kind of thing.

Garry Tan's gstack arrived at the same architectural decisions I did, independently. The convergence matters more than either implementation.

Risk teams know risk. The open problem is designing controls for systems that are non-deterministic, probabilistic, and attackable in natural language.

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.

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.

I left an AI coding pipeline running overnight with 21 monitoring cycles. 5 features merged, 10 specs dispatched, 3 root causes found. Here's what worked, what broke, and the quality of the output.

ANTHROPIC_API_KEY vs ANTHROPIC_AUTH_TOKEN — how a single wrong environment variable made an AI coding pipeline silently fail for hours, and the debugging journey that found it.

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.

Karpathy's LLM Wiki pattern is a good starting point. Here's what changes when you run it for real — enforcement over convention, decay over growth, and knowledge that fires without being asked.

Most advice about making CLIs agent-friendly is just good CLI design. Only four principles are actually agent-specific.

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.

Multi-engine search agreement is not primary-source verification. A cautionary tale about hallucinating reference content from consistent secondary summaries.

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

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

Five skill repositories, a day of reading code, and a significant correction I had to make the same afternoon.

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

Compliance-first governance produces paperwork. Design-first governance produces systems you can actually explain to a regulator.

Engineering metaphors give you clean abstractions. Biology gives you resilient ones. Twenty design heuristics from four billion years of R&D.