A year ago, if you told me prompt engineering was going to be dead within twelve months, I'd have called you delusional. The craft required careful calibration—instruction harnesses, meticulously crafted system prompts, elaborate AGENTS.md files that grew like kudzu with every new capability request. That world is gone now. According to a developer writing on blog.exe.dev, coding agents have gotten so dramatically better at following instructions and exercising judgment that most of what we called "prompt engineering" has become obsolete. The bitter lesson has finally come for the harnesses.

The Bitter Lesson Comes for Harnesses

The old playbook made sense when LLMs were finicky about rules. You needed to be surgical—precise language, careful constraints, elaborate frameworks just to get consistent output. Those days are over. Modern agents don't need hand-holding anymore; if you tell them exactly what to do, they'll do exactly that. The problem is that the real world doesn't come with exact specifications. In messy production environments, it's extraordinarily difficult to define a good set of rules in advance. The solution isn't better prompting—it's delegation. Agents are now capable enough at on-the-fly judgment that micromanaging them actually makes things worse.

Three Lines to Rule Them All

The author's personal CLAUDE.md file tells the story: it contains exactly three lines. No elaborate persona descriptions, no comprehensive behavioral guidelines, no 2000-word manifestos about how Claude should approach its work. Just a hard rule (never git push), an operational preference (run goimports after Go edits), and a meta-instruction about prompting other agents. That's it. The rest is trust. "Goals are durable, orders are brittle," the author writes—a principle that cuts through years of prompt engineering cargo culting in one sentence.

When Agents Talk to Agents

Here's where things get genuinely interesting. Modern AI workflows aren't just human-to-agent anymore; they're agent-to-agent all day long. Subagents help write skills for other subagents, which invoke further subagents, which write scripts that run more agents. Every handoff risks context collapse—a game of LLM telephone where fidelity erodes with each layer. The author's Shelley coding agent takes a different approach: an orchestrator mode that gives every subagent access to a SQLite database containing the complete history of all conversations. Subagents refer back to the user's original input as their primary source, bypassing the cascading context loss problem entirely.

Where Claude Still Falls Short

The author notes one frustrating exception: when prompting other agents, Claude still defaults to prescriptive orders rather than conveying intent and nuance. "Claude doesn't understand yet that we don't live in 2025," they write. The drill sergeant mode—barks commands without the underlying purpose—continues to plague multi-agent workflows. Until models internalize this shift from command-and-control to trust-and-delegate, we'll keep losing fidelity in agent chains.

Key Takeaways

  • Elaborate system prompts and AGENTS.md files are now mostly counterproductive noise
  • Modern agents respond better to goals than prescriptive instructions—trust beats micromanagement
  • The real bottleneck isn't prompting technique anymore; it's preventing context collapse in multi-agent systems
  • Architectures that preserve fidelity across agent chains (like SQLite-backed orchestrators) matter more than prompt optimization

The Bottom Line

Prompt engineering as a discipline is experiencing planned obsolescence—and good riddance. The energy we spent crafting elaborate instructions would be better invested in building robust agent architectures that don't require babysitting. The future isn't better prompts; it's better delegation.