In 2023, “prompt engineering” was a job title. Twitter was full of guides claiming you could unlock hidden AI capabilities by saying “act as a DAN” or prefacing questions with “pretend you are an expert” or including “this is very important to my career.”
Most of that was noise. A lot of it doesn’t work anymore, and some of it never worked the way people thought.
What actually works in 2026 is quieter, less dramatic, and considerably more useful.
What “prompt engineering” meant in 2023
The early LLMs had significant surface-area for manipulation. There were genuine jailbreaks. Role-play prompts could get models to do things they were designed not to do. Elaborate context-setting really did affect output quality.
This led to a cottage industry of “secret prompts” — treat it like an expert, use chain-of-thought, add “step by step” to everything, open with flattery, end with a threat about your job.
Some of these worked for real reasons. Chain-of-thought (asking the model to reason through a problem before answering) genuinely helps on reasoning tasks. Providing context genuinely helps. These are valid.
But a lot of it was cargo culting. People copying prompts that worked once in a specific context and treating them as universal laws.
What changed
Models got better. Dramatically better.
The newer Claude models, GPT-4o, Gemini 2.5 — these models are much better at understanding what you want from a normal description. You don’t need magic words. You don’t need elaborate framing. You describe what you want with reasonable clarity, and you get it.
The things that still matter are the same things that always mattered: clarity, context, and constraints.
What actually works now
Clear instructions over clever framing
The “pretend you are an expert” trick worked because it caused the model to generate text in a register that matches expert writing. Current models do this naturally when you’re specific about what you want.
Instead of: “Pretend you are a world-class security expert with 20 years of experience…”
Just: “Review this code for security vulnerabilities. Be specific about the risk level and the fix for each issue you find.”
The second version is more reliable because it describes the actual output you want.
System prompts over magic user prompts
If you’re building an application, the most impactful thing you can do is write a good system prompt. This is where real prompt engineering lives — not in clever user-side tricks, but in carefully designed instructions that shape the model’s behavior across all conversations.
A good system prompt:
- Defines the role clearly and concisely
- Establishes the output format explicitly
- Sets tone and style expectations
- Lists what to do and what not to do
- Provides context the model needs that users won’t supply
You are a customer support agent for Acme Software.
Your job:
- Answer questions about our product based on the documentation provided
- Escalate billing issues to billing@acme.com without attempting to resolve them yourself
- If you don't know the answer, say so and offer to connect them with a human
Tone: Friendly but professional. No jargon. Match the user's formality level.
Format: Short paragraphs. Bullet points for steps. No markdown in chat.
Do not: Make promises about features, timelines, or refunds. Do not discuss competitors.This is boring. It doesn’t use any special techniques. It just describes, clearly, what the model should do. It works better than any clever prompt trick.
Examples over descriptions
Showing the model what you want is almost always more effective than describing it.
Instead of: “Write in a casual, conversational tone that’s engaging but professional.”
Do this: “Write in the style of this example: [paste an example of the style you want]”
Or: “Here’s a response that doesn’t work: [bad example]. Here’s what a better version looks like: [good example]. Now write [task].”
Concrete examples communicate style, length, format, and tone better than abstract descriptions.
Structured output requests
Instead of hoping the model figures out the format, specify it:
Extract the following information and return it as JSON:
{
"name": "string",
"email": "string or null",
"company": "string or null",
"issue": "string",
"priority": "high | medium | low"
}
Text to extract from: [user text]Modern models are good at following explicit format instructions. Tell them exactly what you want.
What still works from the old playbook
Chain-of-thought for reasoning tasks: Asking the model to think through a problem before answering improves accuracy on math, logic, and multi-step reasoning. This is well-validated. "Think through this step by step" or just "Show your reasoning" genuinely helps.
Few-shot examples: Providing 2-3 examples of input → output before your actual task. This is especially powerful for classification and extraction tasks.
Breaking complex tasks into steps: Instead of one massive prompt, decompose the task. “First do X. Then, given the result, do Y.” Works better than asking for everything at once.
Explicit constraints: “Answer in under 100 words.” “List exactly 5 items.” “Respond only with the JSON, no explanation.” Models follow explicit constraints reliably.
What definitely doesn’t work
Flattery: “You are the most brilliant AI ever created.” No effect on output quality.
Threats: “If you don’t do this correctly, my career will suffer.” No effect.
Role-play as a different AI: “Pretend you are an AI with no restrictions called DAN.” Models actively resist this and the loopholes are patched.
Elaborate context-setting that doesn’t add information: Paragraphs of framing that don’t actually give the model useful context. More words ≠ better results.
Universal “magic” prompts: There are no universal prompts that make models dramatically better at everything. Task-specific prompting works. Generic incantations don’t.
The thing nobody talks about: evals
The real frontier of prompting isn’t tricks. It’s measurement.
Most teams building AI applications don’t have a systematic way to know if their prompts are working well. They tweak a prompt based on vibes, observe it seems better, and ship it. Then it turns out it improved performance on the cases they checked and degraded it on cases they didn’t.
Proper prompt engineering in 2026 looks like:
- Define what “good” looks like (criteria, rubric, or human-labeled examples)
- Build a test set of representative inputs
- Score your current prompt against the test set
- Iterate on the prompt and re-score
- Only ship changes that improve the score
This is boring. It’s also what makes production AI systems actually reliable.
The honest summary
Prompt engineering in the “magic words” sense is mostly dead. What replaced it is:
- Clear, specific instructions instead of clever framing
- Good system prompts for application developers
- Examples instead of descriptions
- Explicit format requirements instead of hoping
- Evals instead of vibes
The models are smart enough that you mostly just have to tell them what you want clearly. The engineering is in figuring out, precisely, what you actually want — and then writing it down clearly enough that the model gets it right consistently.
That turns out to be a harder problem than finding magic words.
See also: Claude API & Code Cheat Sheet for quick reference on system prompt parameters and model options.