For a while, "prompt engineering" was treated like the whole skill. Phrase the instruction well enough, add a few magic words, and the model would do the right thing. That mindset made sense when the unit of interaction was a single message. It breaks down completely once the thing you're working with is an agent that reads a codebase, calls tools, and acts over many steps.
The prompt was never the bottleneck
Ask an agent to "fix the bug in the checkout flow" and the instruction itself is barely the hard part. The hard part is everything that has to happen before the model can act on it sensibly:
- Which files are actually relevant, out of thousands.
- Whether the agent has the right surrounding context — types, call sites, recent changes — or just the one file you happened to paste in.
- Whether stale information (an old comment, a deprecated function still in scope) is quietly competing with the correct, current state of the code.
- How much of the context window is being spent on noise versus signal.
None of that is a wording problem. It's a retrieval and curation problem, and it determines the ceiling on what the agent can do far more than the phrasing of the request.
Context is a budget, not a free resource
A large context window doesn't make this go away — it just raises the size of the mistake you can make before it becomes obvious. Dumping an entire repository into context because the window technically fits it usually produces worse results than handing over a tightly chosen subset of files, because irrelevant code competes for the model's attention with the part that actually matters.
Treating context as a limited, curated resource — closer to how you'd think about cache contents than about an inbox — tends to produce more reliable agent behavior than treating it as "more is better."
What this looks like in practice
The teams getting consistent results from coding agents aren't writing more elaborate prompts. They're building the unglamorous machinery around the prompt: tools that retrieve the right files, conventions that keep documentation close to the code it describes, and feedback loops that let the agent verify its own changes (running tests, type-checking) instead of just asserting they're correct.
The prompt is still the part you see. It's rarely the part that decides whether the agent succeeds.
