Context engineering

Foundations

This is the heart of it, and it’s the craft machtsinn is built on. AI is an accelerator with no opinion about direction. Context is the steering. Two people with the same tool and the same model get wildly different results, and the difference is almost never the prompt phrasing. It’s what context they put around it. The winners use AI right; they don’t use it most.

Context engineering is the deliberate practice of giving the model the right information, in the right form, at the right time.

Specific beats vague

The model fills gaps with guesses. The more you specify, the less it has to guess.

Weak:   Fix the form.
Better: The login form doesn't show an error when the password is
        wrong. Validate on submit and show the message under the field.

Same model, same tool. The second prompt names the file’s behaviour, the trigger, and the expected result, so there’s nothing left to invent.

Bring rich context

A prompt is just text. You can hand the model far more than text, and you usually should:

Bring this	When it helps
Files	The model reasons over your real code, not a generic guess
Images / screenshots	A broken UI, a design mockup, a chart, an error dialog
URLs	Current docs or a spec it wasn’t trained on
Data	A sample row, a schema, a failing payload
Error output	Paste the actual stack trace, not “it crashed”

Pulling the right files into the window is the everyday version of this. Pulling in too much works against you; recall The context window.

Persistent instructions: the standing context

Some context is true every time: your stack, conventions, what to never do. Repeating it in every chat is wasted effort. Every serious tool has a file (or setting) that loads automatically at the start of a session:

Tool	Where its standing instructions live
Claude Code	CLAUDE.md in the project root
Codex	AGENTS.md in the project root
Cursor	.cursor/rules
GitHub Copilot	.github/copilot-instructions.md
ChatGPT / Claude (chat)	Custom Instructions and per-project instructions

Keep these short and load-bearing: the commands to build and test, the conventions that matter, the traps to avoid. A bloated instructions file costs context on every single turn, so prune it like code.

Tip

A good CLAUDE.md or AGENTS.md is the highest-return hour you’ll spend on a project. Write down what you find yourself re-explaining, then stop re-explaining it.

Memory

Some chat tools remember facts across separate conversations (ChatGPT’s memory, Claude’s memory features). Convenient, and a quiet risk: memory can carry a stale fact into a new task without you noticing. Treat saved memory as context you didn’t re-check, and prune it when it goes out of date. For how agents actually store and maintain memory across sessions, see How agents remember.

Caution

Persistent context is powerful precisely because it’s automatic. That’s also why a wrong line in an instructions file or a stale memory is worse than a one-off bad prompt: it’s wrong on every turn until you fix it.

Context is the steering

Hold onto the through-line. The model supplies speed and breadth; you supply direction, and you supply it entirely through context: the prompt, the files, the standing instructions, the memory. None of that changes the model’s intelligence. All of it changes where that intelligence points. That’s the whole craft.

Where you’ll see this

Every tool guide is, in the end, applied context engineering. It’s most explicit here:

Claude Code: Intermediate Writing a CLAUDE.md that steers every session.

Codex: Intermediate Using AGENTS.md to encode your project's rules.

Cursor: Intermediate Project rules and rich context in the editor.