Prompt Engineering Did Not Die — It Moved Down the Stack
The job title faded; the substrate skill did not. What survived from prompt engineering: authority hierarchies with evals behind them, prompts as interface contracts, and knowing which guarantees belong to the harness instead.
Prompt engineering is the only layer of the agent stack that has already lived a full hype cycle: 2023 job title, 2024 punchline, and by 2026 — quietly — a substrate skill inside every layer above it. Loops carry prompts in their do step. Graph nodes are prompts with wiring. The harness assembles prompts from context. The craft did not die; it stopped being the top of the stack.
What survived: prompts as specifications
The prompt work that aged well looks less like incantation and more like specification. The strongest public example is the authority-hierarchy approach: a published spec that orders instruction sources — platform above system above developer above user — defines what happens on conflict, and, crucially, ships evaluations that test whether the model actually honors the ordering. The other durable branch is principle-driven constraints, peer-reviewed and trained-in rather than pasted into every request. Both share a property most 2023-era prompting lacked: they are testable documents, not vibes.
That is the practical bar for prompts inside an agent system. A prompt worth keeping states a role, an input-output contract, and its precedence — and has at least one eval that fails when a model stops honoring it. Version it, freeze it between changes, and let optimization happen the way the current systems do it: search over prompts while control flow stays frozen, never both at once.
What did not survive: MUST as a mechanism
The failure mode that killed prompt-engineering-as-guarantee is now well documented from opposite directions. Teams building incident-response agents found harness gates outperforming MUST-style instructions so consistently they wrote it as a principle: structural enforcement beats instructions. I rebuilt my own on-call agent, Recall, around exactly this: the rule "never cite an incident that does not exist" lives in the write path, which checks every ID against the database before accepting a diagnosis. The prompt still asks for grounded answers — but the property holds even on the day the model ignores it.
The division of labor, stated plainly: prompts shape behavior; structure guarantees it. Anything you would be embarrassed to explain as "the model usually complies" belongs one layer down, in the harness. What remains in the prompt is everything worth shaping: role, taste, format, edge-case judgment — the parts no gate can express.
Prompting a reasoning model is a different job
The spec-like turn is now official guidance, not just observation. The current Model Spec orders authority explicitly — root, system, developer, user, guideline — and the runtime conflict rule extends through tools: system over developer over user over tool output, with lower layers honored only when they do not collide with higher ones. The vendor guidance that ships alongside it is the part most teams still skip: version prompts in code, pair every change with evals, and include eval cases where the user or a tool tries to override higher-priority instructions — the prompt-injection test, promoted from security afterthought to standard practice.
Meanwhile the models changed under the craft. On reasoning models the old chain-of-thought choreography is counterproductive: the working 2026 heuristic is a clear brief plus a thinking budget — do not hand-hold the reasoning — then sample several completions at nonzero temperature and take the majority. Less puppeteering of the middle, more specification of the ends. Which is the same lesson as the rest of the stack, arriving from the opposite direction.
The stack, bottom to top
That closes the tour: prompts specify a single step, loops make a step self-correcting against an external check, graphs wire loops over typed shared state, and the harness owns whatever must stay true regardless of all of them. Each layer assumes the one below did its job — which is why the unglamorous bottom layers, the prompt eval and the loop check, end up carrying systems that look like they run on magic from the outside.