Prompt engineering became a job title in 2023, then a meme by 2025. The truth is somewhere in between. Most prompts are fine without ceremony. Some specific patterns reliably produce noticeably better outputs.

After two years of daily LLM use, these are the five frameworks I actually reach for. Skip the rest.

1. The “Role + Task + Context + Constraints” pattern (RTCC)

The simplest framework that works. Structure your prompt as:

1. Role: What expert should the AI play?
2. Task: What exactly do you want done?
3. Context: What background does it need?
4. Constraints: What’s off-limits or required?

Bad prompt:

“Write me a product description for my new candle.”

RTCC prompt:

“You are a copywriter for premium home goods. Write a 100-word product description for my new candle: a single-wick soy candle with bergamot and cedar. Target customer is design-conscious 30-something professionals. Avoid clichés like ‘cozy’ and ‘luxurious.’ Don’t mention price or shipping.”

The second produces something usable on the first try. The first produces a generic blob.

When to use: any time you’d write a 1-sentence prompt and feel disappointed by the output.

2. The “Show, Don’t Tell” pattern

Instead of describing what you want abstractly, paste an example of similar good work. Then ask for more like that.

Bad prompt:

“Write a punchy intro for my blog post about productivity.”

Show-don’t-tell prompt:

“Here’s the intro from one of my favorite posts I’ve written:

‘You don’t have a productivity problem. You have a “this thing matters less than I’ve been pretending” problem. Fixing it is uncomfortable but free.’

Now write a similar-voice intro for a new post about [topic].”

The example anchors voice, length, structure, and energy. The AI matches it.

When to use: writing where voice matters more than information.

3. The “Strawman + Critique” pattern

Get the AI to argue against itself. Massive quality jump on reasoning tasks.

Step 1: Ask for the answer. Step 2: Ask “What’s the strongest argument against this conclusion?” Step 3: Ask “Given that critique, refine your answer.”

Why it works: the second pass forces the model to identify its own weaknesses before defending them. The third pass produces a more honest, balanced answer than the first.

When to use: anything where being right matters more than being fast. Strategy decisions, business analysis, technical architecture, contract review.

4. The “Constraint Stack” for code

When asking AI to write code, layer constraints in order:

1. Functional constraint: What should the code do?
2. Stylistic constraint: What language and style?
3. Dependency constraint: What libraries are OK / banned?
4. Edge case constraint: What inputs should it handle gracefully?
5. Testing constraint: Should it include tests?

Bad prompt:

“Write a function that fetches users from an API.”

Constraint-stack prompt:

“Write a TypeScript function that fetches users from this API: GET /api/users. Use native fetch, no external libraries. Handle rate limiting (429 status) with exponential backoff up to 3 retries. Return null on permanent failures. Include a Jest test that mocks fetch and verifies the retry behavior.”

The second produces production-grade code. The first produces a 5-line snippet you’ll have to extend three times.

When to use: any coding task where the AI’s first attempt usually misses something.

5. The “Iterative Refinement” loop

For tasks the AI can’t get right in one pass:

1. Get the first attempt.
2. Tell it the specific thing wrong (not “make it better” — be precise).
3. Get the next attempt.
4. Repeat until done.

The key word is specific. “Make it more engaging” produces noise. “Cut the second paragraph and make the third one one sentence” produces a fix.

Tactical phrasings that work:

• “Keep everything except [specific part]; change [specific part] to [specific direction].”
• “What you wrote is too [adjective]. Make it [opposite adjective].”
• “The previous version was 80% there. Fix only this: [issue].”

When to use: any creative or analytical task. Always. Single-pass output is almost never as good as 3-iteration output.

What I’ve stopped using

These were trendy in 2023-2024 and add little value now:

• “Take a deep breath” / “Think step-by-step”: Modern models do this by default. The prompt doesn’t change behavior.
• Persona overload: “You are a world-renowned Nobel laureate expert in X with 50 years of experience” — adds nothing past “You are an expert in X.”
• Long preamble: 200-word setup before the actual question. Wastes tokens; modern models don’t need ceremony.
• Magic words like “important” or “critical”: Used to work in early GPT-3. Now ignored or actively detrimental.

How to practice

Don’t memorize these five frameworks. Practice them on real work, one at a time:

• Week 1: Use RTCC on every prompt you send. Notice when it helps.
• Week 2: Try Show-Don’t-Tell for writing tasks.
• Week 3: Use Strawman + Critique on one important decision.
• Week 4: Constraint-stack your code prompts.
• Always: Iterative refinement.

After a month, these become reflexes. You’ll write better prompts without thinking.

The framework I rely on most

Iterative refinement (#5). Nothing else comes close in impact. The single biggest mistake I see other people make with AI is accepting the first output as final. The best output is almost always 3-5 turns into the conversation, not turn one.

The corollary: don’t be efficient with your AI conversations. Be patient.

---

Disclosure: AIQuill earns commissions when you sign up for some tools through links on this site. We never accept payment for placement. See our Affiliate Disclosure for details.