Prompt Engineering for Agentic Coding

Why a Chat Prompt Fails a Forty-Turn Run

Underspecification is survivable in chat. You leave something out, the model guesses, you correct it on the next line, and the cost is fifteen seconds. That correction loop does far more work than most people credit it for.

Take the loop away and the numbers move. Laban and colleagues at Microsoft Research and Salesforce Research ran over 200,000 simulated conversations in which a fully specified instruction was instead revealed piece by piece across turns. Performance fell by an average of 39% across six generation tasks, and the decomposition matters: only a small share was lost capability, the bulk was unreliability. Models commit to an assumption early, build a full solution on it, then keep leaning on it. Their phrasing is that when a model takes a wrong turn, it gets lost and does not recover.

An agent run is that experiment with nobody in the room. The wrong turn happens at turn three and thirty-seven tool calls get built on top of it. Prompt quality in agentic work is closer to a load-bearing wall than a nice-to-have.

The prompt outlives its conversation. Long runs cross context windows. Anthropic’s prompting documentation tells you to say so in the instruction: warn the model that its context will be compacted, tell it to save progress and state before the window refreshes, and tell it not to wrap up early because it senses the budget running out. That guidance has no analogue in chat, because chat never gets that far. Write it, or the model quietly starts closing down at the worst possible moment.

The prompt is inherited. A sub-agent receives the slice you wrote, not the conversation you had. Anything that lived in an earlier message, a pasted screenshot or a verbal clarification is simply absent. If a constraint matters to the worker, it has to be in the worker’s instruction.

Nobody says stop. OpenAI’s GPT-5 prompting guide is direct about this: state the stop conditions of the agentic task, mark which actions are safe and which are not, and define when, if ever, it is acceptable to hand back to the user. Without that you get one of two failure shapes. Either the agent halts on the first ambiguity and waits for a human who is asleep, or it keeps going long past the point where it should have asked.

So the rule is: write for turn 40, not turn 1. Every constraint that still matters at the end belongs in the instruction, not in a follow-up you intend to type. Anything too large to carry in the instruction goes to disk, and the instruction says where. That handoff is where this rung ends and context engineering begins.

A Prompt Is a Spec, Not a Wish

Here is a real shape of task from our own work. A JSON dataset of ASIC error codes needs a severity field on every record. The chat-shaped version of that instruction is one line.

Add a severity field to the error codes data.

Handed to a capable agent with write access, that line has a lot of plausible readings. Add the field to the schema, or the records, or both. Reformat the file while you are in there. Helpfully invent severities where the answer is not obvious. Write a migration script because that seems tidier. Every one of those is defensible, none is what was wanted, and you find out when you read the diff.

The spec-shaped version lives in a file, has a name, and is versioned with the data it operates on.

Nothing in that file is decoration. The count constraint exists because agents lose records when they rewrite files. The format constraint exists because a reformat buries a three-line change in a three-thousand-line diff and destroys your ability to review it. The unknown value exists so that the honest answer is available. Without it, the only way to satisfy the objective is to invent data, and a well-behaved model will invent data rather than fail an instruction you gave it.

The line about not special-casing records comes from documented behaviour, not a hunch. Anthropic’s prompting guidance warns that models can focus too heavily on making tests pass at the expense of a general solution, and recommends stating outright that tests verify correctness rather than define it, with permission to report that a test is wrong instead of working around it. Acceptance criteria therefore come in pairs: the check, and the ban on gaming the check.

The last third of the file is what separates a prompt from a wish. A wish says what you want. A spec says how the machine will know it succeeded, what it hands back, and what it does when reality does not match the assumption.

Is It Actually a Prompt Problem?

When a run goes wrong the reflex is to rewrite the prompt. Often the prompt was fine and something around it was broken, so you end up with a worse prompt and the same bug. Symptoms sort more cleanly than expected.

The cheapest diagnostic is a fresh session. Re-run the identical instruction with clean context and the relevant files handed over deliberately. If it now succeeds, the instruction was never the problem and you were watching context rot. If it fails the same way in a clean room, the instruction is the problem. That one test settles most arguments, and it is the same isolation principle RALPH loops exploit deliberately by restarting every iteration from scratch.

Three Ways a Prompt Rots

Contradiction. OpenAI’s guide singles this out as a real failure mode, not a style issue. Conflicting directives burn reasoning while the model tries to reconcile rules that cannot both hold, and the fix is an explicit hierarchy, not softer wording. Contradictions accumulate quietly: every incident adds a line, nobody removes one, and eventually rule four forbids what rule eleven requires.

Wrong altitude. Anthropic describes a Goldilocks zone between hardcoded brittle logic that tries to script exact agentic behaviour and vague high-level guidance that gives no concrete signal. Specific enough to guide, flexible enough to work as heuristics. In practice, constrain outcomes and boundaries rather than keystrokes. Say which files are off limits, not which order to open them in.

Bloat. Long is not thorough. The published advice points one way: the minimal set of information that fully outlines your expected behaviour, kept informative yet tight. Cutting a prompt is a legitimate fix, and a section that has never changed an outcome is costing window for nothing. Move reference material out of the instruction and let the agent fetch it on demand, which is the whole argument of context engineering.

Almost none of this is ours. The vocabulary and most of the technique come from people who published their work: Anthropic’s prompting documentation and Claude Code, OpenAI’s Codex and its GPT-5 prompting guide, the AGENTS.md contributors now organised under the Linux Foundation, GitHub’s Spec Kit team, the promptfoo maintainers, the researchers who measured multi-turn degradation instead of asserting it, and a large open-source agent community running these experiments in public across open-weight and closed models alike. We build in that lineage and would rather say so.