ai-agents

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.

Every AI coding platform has mechanisms designed for specific purposes. Using them as intended beats clever hacks — and the reason is deeper than cleanliness.

Most people scan competitors for positioning. I scan them for transferable patterns — and route each steal to every domain it applies to.

The real arrival of AI agents isn't spectacular. It's when you stop noticing.

Getting ahead of AI best practices is a treadmill. The durable skill is testing assumptions faster than they expire.

Persona prompting generates the exact type of hallucination that automated LLM judges reward as 'depth.' Two experiments, blind evaluation, and a fact-check that flipped the finding.

Personas hurt for structured tasks, help for judgment-heavy tasks. Two experiments, blind evaluation, frontier models. The distinction is task-dependent, not binary.

Independent parallel reviews produce overlapping findings. The cross-critique round produces resolution. That's where multi-agent value actually emerges.

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.

Documenting a rule is half a loop. The rule only works when it fires at the moment of decision — not when it sits in a file nobody reads.

A calculator doesn't simulate forgetting — it manages its context budget. What to cherry-pick from cognitive science for AI agent memory, and what to leave behind.

I benchmarked 10 memory backends and multiple embedding models on actual agent memory retrieval. The results challenge common assumptions about what matters.

Agentic AI isn't a future governance problem — it arrived ungoverned, and this week saw the first enforcement action.

Agent memory isn't knowledge management. It's performance infrastructure — and the gap between a stateless agent and one that accumulates context is measurable.

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

An open-source AI agent framework became the fastest-growing project in GitHub history — mostly in China. The pattern is the same as last year. So is the security panic.

Most enterprises are optimising the wrong variable. The gap between 5% and 40% agent adoption won't be closed by better models.

The shift from agents you summon to agents that watch. Enterprise AI workflows are becoming continuous loops — and the failure modes are different.

Not better function calling — decoupling. When tools expose MCP servers, any agent can compose any system freely. The heterogeneity problem becomes a configuration problem.

We called them language models and spent years confused about why they could reason. The name stuck to the interface, not the mechanism.

What changes when LLMs stop being the special thing and become just another software component? The answer is: everything about how you build.

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

The simplest agent architecture might already be the right one: give the agent a file explaining how to do something, and let it read when needed.

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.

The difference between writing down a rule and making the system enforce it — illustrated by a 15-line hook.

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

The instinct to add a rule to a skill file is usually the wrong abstraction. A CLI wrapper enforces at the tool level: zero deliberation, zero token cost.

LLM instruction files are code. They have the same failure modes — with one interesting twist that changes everything.

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