Prompt Engineering Patterns Every Developer Should Know 🎯

The Dirty Secret About Prompt Engineering 🤫

Most "prompt engineering guides" are garbage. They tell you to "be specific" and "provide context." No kidding, Sherlock. That's like telling a chef to "use ingredients."

I've written thousands of prompts over the past year working with Claude, ChatGPT, and Gemini daily. Here are the actual patterns that consistently produce better results — not theory, but battle-tested techniques.

🏗️ Pattern 1: The Role + Constraint Sandwich

Don't just say "help me write code." Frame it.

❌ Bad Prompt

✅ Great Prompt

Why It Works

| Element | What It Does |

|---------|-------------|

| Role ("senior TypeScript dev") | Sets the expertise level and language |

| Context ("Next.js 16 app") | AI knows the ecosystem |

| Requirements (bullet list) | Clear, checkable criteria |

| Anti-requirements ("does NOT use") | Prevents unwanted patterns |

💡 **The sandwich:** Role on top, requirements in the middle, constraints at the bottom. Works every single time.

🔄 Pattern 2: The Iterative Refinement Loop

Don't try to get a perfect response in one shot. Use a 3-step loop:

Real Example

Each iteration builds on the last. The AI keeps full context. You end up with something 10x better than any single prompt could produce.

📋 Pattern 3: The Example-Driven Pattern (Few-Shot)

Show the AI what you want. Don't describe it — demonstrate it.

❌ Describing

✅ Demonstrating

The Power Table

| Technique | Accuracy | When To Use |

|-----------|----------|-------------|

| Zero-shot (just ask) | ~60% | Simple, obvious tasks |

| One-shot (1 example) | ~80% | When format matters |

| Few-shot (2-3 examples) | ~95% | Complex transformations |

| Many-shot (5+) | ~98% | Mission-critical formatting |

Three examples is the sweet spot. More than 5 usually has diminishing returns.

🎭 Pattern 4: The Persona Stack

Layer multiple personas for complex tasks.

The AI gives you three distinct viewpoints in one response. It's like having three senior devs review your code simultaneously. For free. 🔥

🧩 Pattern 5: The Chain of Thought Trigger

Some magic phrases that unlock better reasoning:

| Trigger Phrase | What It Does |

|---------------|-------------|

| "Think step by step" | Forces sequential reasoning |

| "Before answering, consider the trade-offs" | Prevents rushing to a conclusion |

| "What are the edge cases?" | Activates defensive thinking |

| "Explain your reasoning" | Shows the work, easier to spot errors |

| "What would break this?" | Adversarial thinking mode |

| "What would a principal engineer change?" | Elevates quality bar |

My Favorite Combo

This consistently produces the most thorough code reviews I've ever seen from AI.

📐 Pattern 6: The Output Format Lock

Tell the AI EXACTLY how you want the output.

When you lock the format, the AI fills in the blanks instead of free-forming. The quality goes way up because structure forces completeness.

🚫 Pattern 7: The Anti-Pattern List

Tell the AI what NOT to do. This is surprisingly powerful.

🔥 **Why it works:** AI models love to "help" by adding stuff. Error handling, comments, abstractions, type assertions — all the things a junior dev adds "just in case." The anti-pattern list keeps the output focused.

🏭 Pattern 8: The Context Dump

For complex tasks, front-load ALL the context before asking.

Context Priority Order

| Priority | What to Include | Why |

|----------|----------------|-----|

| 🔴 High | Error messages, stack traces | The actual problem |

| 🔴 High | Relevant code files | What AI needs to see |

| 🟡 Medium | Tech stack + versions | Prevents wrong-version answers |

| 🟡 Medium | Project patterns/conventions | Keeps output consistent |

| 🟢 Low | File tree structure | Helps with import paths |

| 🟢 Low | Business requirements | For feature work |

⚡ Pattern 9: The Diff Request

Instead of asking for a full file, ask for just the change.

❌ Generates 200 lines (180 unchanged)

✅ Generates just the fix

This saves tokens, saves time, and makes it way easier to review the change.

🎪 Pattern 10: The Rubber Duck Escalation

Start simple, escalate only if needed.

Don't start at Level 3. The AI's initial response to Level 1 often reveals things you didn't consider. Let the conversation guide the complexity.

📊 My Prompt Pattern Usage (Real Numbers)

| Pattern | Daily Usage | Impact Level |

|---------|------------|-------------|

| Role + Constraint Sandwich | ~15 times | 🔥🔥🔥 |

| Iterative Refinement | ~10 times | 🔥🔥🔥 |

| Output Format Lock | ~8 times | 🔥🔥 |

| Anti-Pattern List | ~6 times | 🔥🔥🔥 |

| Context Dump | ~5 times | 🔥🔥🔥 |

| Few-Shot Examples | ~4 times | 🔥🔥 |

| Chain of Thought | ~3 times | 🔥🔥 |

| Diff Request | ~3 times | 🔥 |

🎬 TL;DR — The Cheat Sheet

1. **Role + Constraints** — Frame who the AI is and what it can't do
2. **Iterate in 3 steps** — Don't aim for perfection in one shot
3. **Show, don't tell** — Give examples of desired output
4. **Stack personas** — Get multiple expert viewpoints at once
5. **Trigger thinking** — "Think step by step" and "What would break this?"
6. **Lock the format** — Structure forces completeness
7. **Anti-patterns** — Tell AI what NOT to do
8. **Context dump** — Front-load everything before asking
9. **Ask for diffs** — Not full files
10. **Escalate gradually** — Start simple, go deep only if needed

The difference between a mediocre developer using AI and a great developer using AI? Not the AI — the prompts. Master these patterns and watch your productivity skyrocket. 🚀