Prompt Engineering Is Dead. Context Engineering Killed It.

Two years ago, “prompt engineer” was a job title. Companies posted six-figure salaries for people who knew the magic words. Say “think step by step,” sprinkle in a few examples, threaten the model politely, and watch quality jump.

That job title has mostly vanished from the listings, and not because the skill stopped mattering. It got absorbed into something bigger. The conversation in 2026 has moved to context engineering, and if you build with LLMs or work alongside AI coding agents, it may be the most important skill you aren’t practicing deliberately.

The Shift Nobody Announced

Prompt engineering optimized a single message. Context engineering optimizes everything the model sees: the system instructions, the retrieved documents, the tool definitions, the conversation history, the code the agent just read, the error output from the test it just ran. Sourcegraph defines it as the deliberate process of designing, structuring, and providing relevant information to LLMs. The sharpest one-line version I’ve seen: find the smallest set of high-signal tokens that maximizes the likelihood of the outcome you want.

The important word there is smallest. Most of us instinctively optimize in the opposite direction, and that instinct is exactly what the discipline exists to correct.

The reason this matters in 2026 and barely mattered in 2024 comes down to loops. Early LLM apps were single-shot: one prompt, one answer. Modern AI coding agents run in loops. They read files, call tools, hit errors, retry, and accumulate everything into a growing context window. Anthropic’s 2026 Agentic Coding Trends Report calls the destination “repository intelligence”: agents that grasp not just lines of code but the relationships and intent behind them. An agent like that might process hundreds of thousands of tokens across a single task. What you feed it, and just as much what you keep out of it, determines whether it ships a fix or confidently refactors the wrong module.

More Context Is Not Better Context

The intuition everyone brings to this is wrong, and I brought it too. When agents make mistakes, the reflex is to give them more: more files, more documentation, more history. But models exhibit what practitioners now call context rot. Bury the one relevant function in 80,000 tokens of adjacent noise and retrieval quality degrades, instructions from the top of the window lose their grip, and the agent starts pattern-matching against things it should have ignored.

The teams getting real results treat context like a budget, not a bucket. A few patterns have become standard practice:

• Retrieval over dumping. RAG didn’t die when context windows got huge. It changed jobs. Instead of compensating for small windows, retrieval now acts as a signal filter, pulling the five relevant chunks instead of pasting the whole wiki.
• Compaction. Long-running agents periodically summarize their own history, keeping decisions and discarding the play-by-play. The agent remembers that it chose PostgreSQL and why, not the forty tool calls it took to decide.
• Sub-agent isolation. Modern architectures use an orchestrator that delegates to specialized agents, each with its own dedicated context, then synthesizes the results. The research agent’s dead ends never pollute the implementation agent’s window.
• Structured memory. Files like CLAUDE.md or AGENTS.md in a repo have turned into infrastructure in their own right: durable, versioned context that every agent session inherits. Documentation stopped being purely for humans the day agents started reading it as configuration.

Why This Is Your Problem Too

You might be thinking this only concerns people building agent platforms. It doesn’t, and the enterprise numbers explain why. Fifty-seven percent of enterprises now run agents in production, yet quality remains the top barrier to scale. The bottleneck is not code generation. It is context governance: making sure the agent sees accurate, current, well-scoped information about your systems. The same constraint runs through the agentic shift happening in IT operations right now; an agent holding the pager is only as good as what it knows about your infrastructure.

Context governance also has a rearview mirror. The prompts and files an agent saw when it wrote a change are the explanation of that change, which is why AI code provenance is becoming an audit question in its own right.

That reframes a lot of unglamorous work. Every stale README in your repo is now a liability that actively misleads an agent. Every well-named function is free context. Every architecture decision record is a retrieval target. The habits that made codebases pleasant for human colleagues (clear naming, honest docs, small modules) turn out to be exactly what makes them legible to AI teammates. Engineers at companies like TELUS report shipping code 30% faster with agentic tools, and the differentiator between teams that see those numbers and teams that don’t is rarely the model. It is the quality of the context the model inherits.

I felt a version of this six years ago building AI-Engine, my drag-and-drop NLP tool. The models were primitive by today’s standards, but the lesson was identical: the intent classifier was only ever as good as the training utterances you fed it. Garbage in, garbage out never went away. It just moved up the stack, from training data to context windows.

The Skill That Compounds

Prompt engineering was a bag of tricks, and tricks depreciate every time a new model ships. Context engineering is closer to information architecture: deciding what a system needs to know, when it needs to know it, and how to keep that knowledge true. That skill compounds, because it is really the old skill of thinking clearly about systems, wearing a new name.

The magic words are gone. What replaced them is harder, less glamorous, and far more durable: curation. The engineers who thrive alongside AI agents in the next few years won’t be the ones who whisper to models best. They’ll be the ones who build environments where a model can’t help but succeed.