What is context engineering?

Ask ten people why their AI disappoints them and you'll get ten versions of the same two complaints: it forgets what I told it, and it keeps using things that are no longer true. Both have the same root cause, and it isn't the model.

It's the context.

The model isn't the bottleneck anymore

Today's models are past the capability threshold for most knowledge work. The gap between what your AI could do for you and what it actually does is no longer intelligence — it's what the model knows about you at the moment you ask.

Every impressive AI output you've ever seen had the right context behind it: the right facts, the right examples, the right constraints, loaded at the right time. Every disappointing one was mostly a context failure wearing a model's name tag.

Context engineering is the discipline of making that happen on purpose: deciding what an AI should know, structuring it so the right depth loads for the right task, connecting it to where your information actually lives — and, hardest of all, keeping it current as your life moves on.

Prompting is a sentence. Context is a system.

Prompt engineering had its moment, and it taught a real lesson: how you ask matters. But a prompt is a one-shot instruction. It can't hold your client list, your pricing history, what you decided on Monday, or the way you write when you're being careful.

Context engineering operates a level below the prompt:

• What gets stored — facts, preferences, voice, workflows; not chat transcripts hoarded wholesale.
• How it's structured — layered, so a quick question doesn't drag in your whole history, and a deep task gets everything relevant.
• Where it connects — the tools you actually work in, not text pasted into a chat box.
• What gets superseded — the part almost everyone skips. New facts must replace old ones, on the record. A memory that only accumulates becomes confidently wrong.

That last point is the sharp edge. AI memory features mostly remember by piling up. Nothing retires the note from October when the plan changes in March. So the system doesn't just forget — worse, it remembers wrong, and answers from what stopped being true with total confidence.

Why "just install a skill" doesn't fix it

The market's answer to this has been downloadable skills and prompt packs: someone else's instructions, generically written, promising expertise. Here's the honest assessment of what those can and can't do.

A skill is in-context text. It can inject knowledge, elicit capability the model already has, and scope behavior. It cannot install judgment or competence that isn't in the weights — "you are a world-class CFO" adds framing, not finance.

And skills inherit the two failure modes of all context:

• Fail-safe skills (procedure, formatting, voice) degrade gracefully. Worst case: mediocre output you can see.
• Fail-dangerous skills (baked-in knowledge and "facts") degrade invisibly. Worst case: anti-knowledge — wrong information delivered with authority, in your name.

A generic skill file can't know your prices, your clients, your standards, or what changed last week. When it pretends to, it fails dangerous. That's not a quality problem with any particular pack — it's structural. (If you want to see how a specific skill holds up, run it through the Skill Auditor — it grades exactly these failure modes, free.)

What good context engineering looks like

The test is simple: does your AI work from your current truth, the same way, every time — without you re-briefing it?

Getting there means treating your context as a system rather than a pile:

1. One home per fact. Your AI shouldn't hold five versions of you across five tools, none current.
2. Supersession, not accumulation. When something changes, the new fact replaces the old — with a record of what replaced what, and when.
3. Bound to real sources. Context that rides your actual calendar, inbox, docs, and data stays true. Context typed into a memory box rots.
4. Governed. Explicit rules for what gets remembered, what gets retired, and what the AI is allowed to act on.

None of this is exotic. It's the same discipline every reliable information system is built on — applied, finally, to the layer that decides what your AI knows. That layer is what we build. The vocabulary in this post — fail-safe versus fail-dangerous, anti-knowledge, supersession — is the working language of how we build it.

This is the first post in the context-engineering series. The next ones go deeper on each failure mode — and on what a memory you can trust actually requires.