Archives

Anti-patterns are more valuable than patterns. The space of things that work is large. The space of things that fail in your specific context is small and worth encoding.

There are 58 public MCP servers in the awslabs catalog covering cloud infrastructure, databases, AI/ML, and ops tooling. Here's the enterprise pattern: proxy them locally, then host the proxy behind a gateway so every developer in your org gets them without setup.

AI crawlers are extracting content at 60,000 pages per visitor sent back. The website is becoming a fallback UI. The real distribution layer is structured, machine-readable context — and nobody is building for it yet.

The MCP token tax has a fix. The solution isn't fewer tools — it's a smarter way to load them. Here's the pattern.

The proxy pattern from part two, built and debugged. Two things broke: a missing dependency that crashed startup silently, and a response format that made the model do unnecessary work.

MCP won the read path. The token tax is what happened next. And the write path still doesn't have an answer.

Part four of the MCP series. The proxy from part three is running in production. Here's what it actually looks like.

When an agent makes a mistake, you have two choices: write it down or encode it. One survives the next session. One doesn't.

When you name a skill thesis-generator, you've already decided the user is a consumer not a practitioner. The name is the first design decision.

Voice mode is not who you are — it's the context you're in. What breaks multi-mode agents is conflating identity with register.

A single system prompt persona doesn't scale. When agents run at speed across contexts, voice consistency requires something more durable.

Running two AI tools built on the same model — one for co-piloting, one for delegating. A non-developer's frame for splitting knowledge work by workflow mode.

The startup playbook depended on code being expensive. AI made code cheap. What's expensive now — data, distribution, domain expertise — is what enterprises already own.

Everyone I talk to who works natively with AI says the same thing: more hours, more exhausted, more engaged than ever. The paradox is real — and there's a specific mechanism driving it that most productivity research misses.

After weeks of delegating nearly everything to AI agents, I found exactly four things that genuinely can't be handed off — not shouldn't, can't.

SaaS platforms auto-generate MCP servers. But auto-generated MCP does text search. If your use case requires metadata-filtered retrieval, you're comparing different architectures — not different feature sets. Capability first, cost second.

Engineering teams have used docs-as-code for a decade. In 2025, AI closed both the write path and the read path — contribution friction dropped to zero, and MCP plus llms.txt made knowledge retrievable at the point of work. For the first time, GTM and knowledge teams can match engineering velocity for maintaining artifacts. Docs-as-code is no longer an engineering practice. It's the de facto standard.

The stack behind artificialcuriositylabs.ai: Astro on S3 + CloudFront, DNS on Cloudflare, email forwarding via SES, and an AI-readable content layer. Every decision explained.

Knowledge agents and coding agents are powerful in isolation but can't talk to each other. The Agent Client Protocol (ACP) is the open standard that connects them — turning your orchestrator into a team lead that delegates build tasks without breaking flow.

Every AI session starts fresh. If your methodology lives only in your head, it resets too. The fix is treating it like code.

Cloud-synced filesystems (OneDrive, Dropbox, Google Drive) are eventually consistent layers masquerading as transactional storage. AI agents write at machine speed and expect durable writes. The architectural mismatch causes silent data loss. The collaboration model is wrong too.

Every AI platform treats voice as a single axis. But knowledge workers switch between six distinct communication registers daily. The fix is mode-specific profiles — engrams — not better cloning.

The friction you feel using the wrong AI tool isn't a prompting problem — it's a mode-matching problem.

AI collapsed the cost of building evidence. The rational response is to stop writing alignment documents and start showing working things.

HTML was designed for browsers. llms.txt is the interface layer that makes your site a first-class citizen in agent workflows — discoverable, consumable, and citable in a single request.

You built a workflow that saves four hours a week. It lives on your laptop. Nobody else benefits. That's not a knowledge management problem — it's a distribution architecture problem.

Writing samples teach the agent what you sound like. The never_say list teaches it what you'd never say. The second is more distinctive than the first.

The tool extracts a voice profile from your messages in one session. That's the easy part. Here's what's missing and how I extended it.

Every writing skill that embeds its own voice definition will drift. The fix is separating mode, voice, format, and publish into four independent layers.

Every agent session starts from zero. The model is brilliant. The tools are connected. And still — you spend the first ten minutes re-explaining how you work. Skills are the fix.

Tools are the atomic capabilities that let an agent interact with the world — read a file, send a message, query a CRM. APIs have existed for decades. What changed is who decides which one to call.

The industry talks about models. Which one is smartest. Which benchmark score is highest. That conversation misses the point. The model is the brain. Without a body, a brain sits in a jar.

Everyone calls everything an agent now. Chatbots, copilots, workflows, RPA scripts — all rebranded overnight. This post draws the line.

The cost of creating content dropped to near-zero. The real constraint is now getting knowledge to the right people — and the right agents — in the right format.

The tech industry is debating who counts as a builder. That's the wrong question. Builder is an orientation you adopt, not a credential you earn.

When an agent leaked a Slack channel ID by bypassing the scrub-and-publish skill, the fix wasn't a memory — it was wiring three skills together so the chain self-enforces.

AI agent behavior committed to a repo travels with the codebase — reviewable, diffable, available to every contributor on first checkout. Treating skills as code artifacts converts ad hoc agent use into an institutionalized team process.

We've been naming AI skills like tools. That's the wrong frame — and it's quietly limiting how much value teams get from them.

How a single misunderstood command caused a system crash — and the session hygiene pattern that fixes it.

Stop organizing your files for humans. Here's what changes when you organize them for agents instead.

Prompt caching cuts AI inference costs by up to 90% — here's how it works, why 5-minute TTL dominates coding workflows, and where this is heading beyond code.

Model selection is an architectural decision — defaulting to the strongest model for every step in a pipeline is a pattern worth breaking.

Claude Code ships with a full OTel SDK that's off by default — here's how to turn it on, run a local Prometheus/Grafana stack, and actually see what your sessions are doing.

The question splits into two: can is a systems problem, should is a human one — and most people crash on the wrong side.