Context engineering is the only AI skill that compounds

Andrej Karpathy gave us "vibe coding" in early 2025 — describe what you want, let the agent generate it, ship. Eighteen months later the phrase is everywhere and the practice is failing the people who took it literally. The post-mortems read the same way every time: shipped fast, broke in production, couldn't reproduce the working version a week later, gave up.

The diagnosis isn't that AI can't code. It's that one-shot prompting doesn't compound. You write a prompt, get a result, close the tab, and the next session starts from zero. Skill that doesn't accumulate isn't skill — it's a treadmill.

The thing that actually compounds is context engineering: the work of designing the persistent environment your agent operates inside. System prompts. Project specs. Decisions logs. CLAUDE.md files. Memory. The Model Context Protocol. The boring scaffolding nobody screenshots for X.

I run a solo studio. One human, a Next.js monorepo, Claude Code in the terminal, Cursor on the laptop, Claude in the browser for planning chats. The thing that makes the setup work isn't the models — those will be replaced inside a year. It's the four-layer context system sitting between me and them.

Why the tool doesn't matter as much as you think

Anthropic shipped Claude 4.7 with a 2-million-token context window. Cursor shipped Agent Mode. GitHub Copilot bolted on PR review and agent mode and cross-IDE support. Every tool got better at the same time, and the gap between them stopped mattering for most work. The Stack Overflow 2026 Developer Survey put it at 92% of professional developers now using at least one AI coding tool daily. The tool is no longer the moat.

What still varies wildly is whether the person using the tool has built any structure around it. Two developers can sit down with the same Cursor license, the same Claude Code install, the same Vercel account. One ships a real product in six weeks. The other generates 500 lines of unmaintainable code and quits. The model didn't make the difference. The context did.

The four layers

Mine is documented as an ops playbook because future-me forgets things present-me thinks are obvious. The structure is portable — works whether you use Claude Code, Cursor, Cline, Codex, or whatever ships next quarter.

Layer 1: The spec. A single markdown file describing the platform as it exists today. Surfaces, schema, routes, infrastructure, conventions. Loaded into every chat automatically via Claude Projects. If a fact isn't in here, future-me doesn't know it. Mine is 16 sections, ~4,000 words, and reads like instructions for someone extending the system — because that's exactly what every new Claude chat is.

Layer 2: The decisions log. Append-only, newest at the top. Every non-obvious call gets one entry: what was decided, why, which spec section it affects. Five seconds to write. Hours saved the next time I wonder "wait, why did we pick terracotta over mustard for the HiBud palette?" The answer is in the log, dated, with the reasoning intact. Linear and Notion both pitch themselves as the place this happens; in practice a flat markdown file in the repo wins because the agent reads it for free.

Layer 3: Memory and instruction files. CLAUDE.md in the repo root. AGENTS.md if you're toolchain-agnostic. Project memory in Claude. These are the files the agent reads before it reads your message. They tell it the stack (Next.js 16, Drizzle ORM, Neon Postgres, Tailwind v4), the conventions (full file replacements over find-and-replace patches, explicit git commands over conceptual guidance), and the things it should never do (delete user data, bypass the proxy exclusions, regenerate the sitemap by hand).

Layer 4: The chat itself. Disposable. Scratch paper. Anything important gets promoted to layers 1-3 before close. The chat dying is fine. The chat being the only place a decision lived is the failure mode.

The discipline that actually matters

Promote before close. Every chat ends with thirty seconds of triage. Did anything ship that should be in the spec? Did any call get made that should be in the decisions log? If yes, promote it. If no, close the chat guilt-free.

This is the discipline that separates context engineering from note-taking. Note-taking accumulates. Context engineering distills. The spec gets edited, not appended to. The decisions log captures the reasoning that doesn't fit in the spec. Memory holds the distilled facts the agent needs by default. Each layer compresses the layer below it.

What sponsors and serious users have figured out

The tools that are winning the indie/solo-builder market in 2026 all sell context engineering whether they say so or not. Claude Code's differentiator is that it reads CLAUDE.md and MCP servers and persistent memory — context, not capability. Cursor's rules files do the same job in a different syntax. Vercel ships preview deploys so every PR gets a context-rich URL. Neon does database branching for the same reason. Plausible exposes custom events because raw pageviews aren't context, they're noise.

Anthropic's own product direction has been the loudest signal. The Model Context Protocol — open standard, no proprietary lock-in — is an admission that the value sits in the context layer, not the model layer. The model is the engine. Your context is the fuel and the steering and the map.

The thing you should do today

Write your CLAUDE.md file. Or AGENTS.md, or .cursorrules, or whatever format your toolchain reads. Twenty lines is enough to start. Stack, conventions, what not to touch. Commit it. Open a fresh chat with the file loaded and notice how much less you have to re-explain.

Then start a decisions log. Single markdown file. Newest at the top. Write one entry today about a call you made this week. Tomorrow, write another. In a month you'll wonder how you ever worked without it.

The next model release will be impressive. The one after that will make it look quaint. The CLAUDE.md you write today will still be earning its keep when both are deprecated. That's the difference between a tool and a skill — and in 2026, the skill is engineering the context, not crafting the prompt.