Stay close to the primitives

A companion to everything through Claude is its sibling principle:

Stay close to the primitives. Avoid abstractions built on top of the LLM.

The LLM and the harness around it are the primitives. Everything else (the commercial wrappers, the “agent platforms,” the proprietary frameworks, the shiny workflow builders with branded terminology) is a derivative layer. Some are useful. Many fuzzy the concepts, and many have short half-lives.

This sits alongside everything through Claude without contradicting it. Claude Code is a harness: the primitive layer for agent work. The principle is use the harness; be skeptical of frameworks built on top of it.

The primitives are what’s durable

The things that don’t change much year-to-year:

• The LLM itself: tokens, context windows, reasoning, tool use, the input/output contract.
• The harness: how a session is built, what gets sent on every turn, how tool calls work, how context is managed.
• Markdown as the medium of communication with the model.
• Direct tool-use protocols like MCP, because the primitive is “the model calls a tool with arguments and reads a result.”

These are what everyone is actually working with, underneath whatever polished surface is layered on top. When a new feature ships, when a new product launches, when someone claims they’ve built the AI agent that will change the world: scratch the surface and you find the same primitives, configured differently.

Claude Code is a harness. It’s opinionated, makes tradeoffs, and is worth understanding fully: the harness is well documented, and everything it produces (transcripts, configs, Skills) is plain files on your machine you can inspect. But the primitives underneath Claude Code are even more durable than Claude Code itself. Learning those first makes every subsequent tool comprehensible in an afternoon.

Abstraction layers come with costs

Every wrapper between you and the primitives:

• Hides the actual levers. When the abstraction makes a choice for you, you often can’t see what it did or why. When it fails, you can’t debug past its boundary.
• Introduces concepts that may not map to anything real. “Agents,” “workflows,” “chains,” “crews,” “teams”: some describe real things; some are marketing that rebrands familiar primitives with new names that obscure rather than clarify.
• Locks you in. The more your mental model is shaped by a vendor’s framework, the harder it is to move when the vendor changes direction, gets acquired, raises prices, or goes away.
• Dates badly. Primitives evolve slowly; abstraction layers churn. Anything you learn at the primitive level transfers to the next wrapper. What you learn about a specific wrapper mostly doesn’t.

This doesn’t mean never use a wrapper. It means: before reaching for one, ask what primitive it’s wrapping and whether you could do the thing directly. Often you can.

The durability scale

Very durable:

• The transformer architecture’s basic behavior
• Context windows and the cost of filling them
• Tool use as “model requests a function call, reads the result”
• Markdown and plain text as the I/O format
• Git and file-system semantics

Reasonably durable:

• Claude Code and its major concepts (Skills, plan mode, sub-agents)
• MCP as the tool-call protocol standard
• The agentic retrieval pattern
• Anthropic’s, OpenAI’s, and Google’s SDKs and API shapes

Likely to churn:

• “Agent frameworks” (LangChain, CrewAI, AutoGen, etc.): useful today, but their abstractions keep shifting; expect a high replacement rate over the next few years
• AI workflow builders with proprietary node types
• Vendor-specific agent marketplaces and app stores
• Any product whose differentiation is “we wrap the LLM nicely”

The churning stuff is fine to touch. Know which tier you’re working in, so you know what’s transferable and what isn’t.

The practical discipline

• Read the Anthropic / OpenAI / Google API docs directly. Understand what the primitive call shape is.
• Use Claude Code and understand its architecture. It’s a good harness, and its docs plus the plain files it leaves on disk show you how it works. You’ll learn more from those than from any marketing post about a wrapper.
• Build your own tiny wrappers before adopting a framework. Forty lines of Python calling the API directly usually beats the framework that claims to save you from “boilerplate.”
• Treat every new “AI-powered product” with a clear question: what primitive is this, and could I do it myself in an afternoon if I understood the primitive directly?

Resources

• Anthropic: Claude Code docs
• MCP specification: modelcontextprotocol.io
• Anthropic API documentation: the canonical primitive reference