I didn't learn prompting from ChatGPT.
I learned it from spending hundreds of hours making terrible AI art.
Every time an image came back wrong, my first instinct was to blame the model.
Eventually I realized something uncomfortable.
The problem usually wasn't the AI.
It was me.
I hadn't described what I actually wanted.
That's when I noticed the same pattern showing up everywhere else in software.
Every bad output starts with an underspecified input
Most people think prompting is about finding the perfect magic phrase.
It isn't.
It's specification.
The better you understand what you're asking for, the less the other side has to guess.
That applies just as much to engineers and designers as it does to AI.
The same mistake shows up everywhere
These all have the same problem:
'Improve the UI.'
'Optimize performance.'
'Make it look modern.'
'Fix the checkout.'
'Create a futuristic dashboard.'
They're requests.
They're not specifications.
Every vague instruction forces someone else—whether it's an engineer, a designer, or an AI model—to fill in the blanks.
Sometimes they guess correctly.
Usually they don't.
Design taught me to communicate differently
My background is in design.
Design school has a habit of forcing you to explain why something feels wrong.
'It looks off.' isn't useful.
'Increase the spacing to separate these groups.' is.
'The typography doesn't establish a clear hierarchy.' is.
'The animation draws attention away from the content.' is.
Specificity isn't just kinder.
It's dramatically more effective.
AI exposes every ambiguity
AI is brutally honest.
It gives you exactly what you asked for.
Not what you meant.
If you ask for 'a modern landing page,' you'll probably get rounded cards, soft gradients, and glowing blobs.
Not because the AI is unimaginative.
Because 'modern' means almost nothing.
The more precise your thinking becomes, the better your results become.
Prompting and product specs are the same skill
A good product spec answers questions before they're asked.
So does a good prompt.
Who is this for?
What problem are we solving?
What should never change?
What constraints matter?
How will we know it's successful?
The format changes.
The thinking doesn't.
The same applies to code reviews
Compare these two comments.
'Can we simplify this?'
Versus:
'This abstraction only has one consumer today. I'd inline it until a second use case appears—it'll be easier to follow and cheaper to maintain.'
The second comment isn't longer because it's smarter.
It's longer because it removes ambiguity.
That's exactly what good prompts do.
Writing became part of engineering
The more I work with AI, the more I realize that engineering is becoming a writing discipline.
Not because code is disappearing.
Because expressing intent is becoming more valuable than expressing syntax.
The engineer who can clearly describe a system, explain a tradeoff, or define a product requirement will consistently outperform someone who can only implement one.
The prompt I actually optimize
These days I rarely spend time searching for clever prompt templates.
Instead, I ask myself a different question.
'If another engineer joined this project tomorrow, would they understand exactly what I want from this feature?'
If the answer is yes, the AI usually understands too.
AI didn't invent prompting.
It simply exposed how clearly we think.
The engineers who write great specs write great prompts.
The designers who give actionable feedback write great prompts.
The product managers who remove ambiguity write great prompts.
Prompting isn't an AI skill.
It's communication.
And communication has always been one of the most valuable engineering skills.