The worst prompt I ever wrote was technically perfect. Clear structure, specific requirements, well-defined constraints. The AI produced exactly what I asked for. Clean code, sensible architecture, good naming conventions.
It solved the wrong problem.
Not because the AI failed. Because I hadn't done the work of translating the real problem into something the model could usefully act on. I'd gone straight from requirement to prompt and skipped the bit in the middle where the actual thinking happens.
That was an expensive afternoon. Not in tokens. In time spent building the right solution to the wrong question.
Prompting is Not the Skill
There's a whole cottage industry around "prompt engineering" now. Courses, certifications, LinkedIn influencers with frameworks and acronyms. Some of it is useful in the same way knowing how to Google well was useful. A minor efficiency gain dressed up as a discipline.
The actual skill isn't crafting the perfect prompt. It's knowing what the model needs to know. Which details matter, which ones will send it off course, what level of abstraction to work at, and which constraints need to be explicit because the model won't infer them.
That's context. And assembling it well is an engineering skill, not a prompting one.
Translation is the Job
Every project starts with a gap. On one side, a business problem: messy, human, full of assumptions and unstated constraints. On the other side, a model that's extraordinarily capable but knows nothing about your situation until you tell it.
The job is translation. Bridging that gap. Taking the mess of a real problem and shaping it into something an AI can work with effectively.
This is something developers have always done. Long before AI, the core skill was translating between what the business needs and what the code needs to do. The medium has changed. The skill hasn't.
What does that translation actually look like? It's knowing to specify the data structure you're working with, not just the feature you want. It's mentioning the legacy system this new API has to talk to, because without that constraint you'll get something technically correct and practically useless. It's thinking about the URL format you want, the authentication pattern you're already committed to, the deployment target that rules out half the suggestions the model might make.
It's also knowing what not to include. Too little context and the model guesses. Confidently, plausibly, wrong. Too much and it drowns, loses focus, starts optimising for details that don't matter. The balance is: enough information to solve today's problem, taking into account the constraints you're dealing with, while knowing enough to handle tomorrow.
Getting that balance right isn't a prompting trick. It's the product of years spent building systems, maintaining them, and learning (usually the hard way) which decisions compound and which ones wash out.
Why This Matters More Now
Before AI, misunderstanding the problem meant a slower, more painful build. But the friction of writing code by hand gave you time to think. You'd often catch mistakes mid-development simply because the process was slow enough to notice something felt off.
AI removes that friction. You can go from half-understood requirement to fully built wrong solution in an afternoon. The gap between "I think I know what's needed" and "here's the finished code" has compressed so much there's barely time to notice you're heading the wrong way.
Speed without direction is just expensive chaos.
The investment now is upfront. In understanding the problem deeply enough to give the model what it needs. Not everything. Not a brain dump. The right things, at the right level, so it solves the problem you actually face and doesn't create new ones for next month.
TL;DR
AI is an extraordinary builder. Fast, tireless, increasingly capable. But it builds what you tell it to build, and the quality of the output is bounded entirely by the quality of the input.
Context is the new code. Writing it well, knowing what to include, what to leave out, and at what level of detail, is where engineering experience meets AI capability. It's the same translation developers have always done, just pointed at a new and spectacularly powerful tool.