15 minute read · Published April 2026

We just finished writing the Promptolis Originals library — 336 hand-crafted AI prompts across 21 categories, each with full example outputs, research-backed frameworks, and specific use cases.

Building that at scale forced a discipline. You can't write 336 prompts by vibes. You need patterns that work — and patterns that don't. We kept the ones that produced Claude/ChatGPT/Gemini outputs we'd actually use. We killed the ones that sounded smart but produced generic slop.

This is what we learned. 7 patterns that consistently made prompts work — with examples you can steal today.

Pattern 1: The block establishes expertise before asking anything

The single biggest prompt quality lever is giving the model a specific expert role with credentials that match the task.

Not "you are a helpful assistant." Not even "you are an expert." A specific role with a specific background.

Bad:

```

Help me review this contract.

```

Good:

```

You are a commercial contract review specialist with 15 years of experience reviewing B2B SaaS vendor contracts. You've reviewed 5,000+ contracts and helped businesses avoid costly mistakes. You understand liability caps, IP assignment language, auto-renewal traps, and governing law dynamics.

You are direct. You will name when terms are unfavorable, when language is ambiguous, and when negotiation leverage exists.

```

Why the second version works:

• Specific expertise — not "contracts" broadly, but "B2B SaaS vendor contracts" specifically
• Quantified credibility — "5,000+ contracts reviewed" gives the model pattern-matching grounding
• Attitudinal framing — "You are direct. You will name when..." primes the model to push back instead of agreeing

We tested "you are an expert" vs. specific-role framing across 40+ Originals. Specific role produced outputs 2-3x longer, with 30-50% more actionable detail, and far fewer hedge-phrases like "it depends" or "consider consulting a professional."

The attitudinal framing is underrated. Models default to agreeable + generic. Explicitly tell them the role is "direct," "honest about tradeoffs," "willing to name uncomfortable truths." This single sentence transforms output quality.

Pattern 2: XML structure beats prose for complex tasks

Claude in particular is trained to recognize XML-style tags. Structured input produces structured output. Prose input produces mush.

Compare:

Prose (weaker):

```

I'm evaluating a vendor contract for 3 years at $85K/year. I'm in California. Their terms include unlimited liability, 12-month auto-renewal, and a governing law clause for Texas. I need to know if I should sign or negotiate, and what to push back on.

```

XML (stronger):

```

Vendor contract — SaaS data platform. 3-year term. $85K/year ACV. Total contract value $255K.

Buying side — VP Data for California company

• Unlimited liability clause
• 12-month auto-renewal with 60-day notice
• Governing law: Texas (we're in New York)
• MFN (most-favored-nation) clause

Strong. Known brand in FinTech. Willing to walk if terms bad.

Sign within 30 days or move on

```

Both contain roughly the same information. But the second gets:

• Organized section-by-section analysis
• Concerns addressed individually, not lumped together
• Clear boundaries between context, goal, and constraints

Research from Anthropic's prompt engineering guide confirms Claude is specifically trained to recognize these tags. GPT-4 and Gemini benefit too, though slightly less dramatically.

When to use XML:

• Multi-factor decisions
• Complex business scenarios
• Any prompt longer than 5 sentences
• Any task where you want structured output back

When to skip XML:

• Simple one-shot questions ("what is the capital of France?")
• Creative tasks where flow matters
• Very short prompts where tags are overhead

Pattern 3: Explicit principles constrain the model's default behavior

Models have defaults. They over-hedge. They list 15 options when you want 3. They pad with caveats. They avoid controversial positions.

The fix is explicit principles that override defaults:

```

• Never use more than 5 bullet points.
• Each bullet under 20 words.
• If you can't find evidence, say "I don't know" — do not guess.
• Take a position. If pros/cons are 60/40, recommend the 60.
• Trade concrete specifics for abstract categories.
• One CTA per response, not multiple.

```

These principles apply across your prompt. You're not asking nicely for brevity — you're establishing it as a rule.

We used this pattern in every Promptolis Original, specific to the domain. In the negotiation-playbook-enterprise Original:

```

• BATNA first. Know your best alternative before negotiating.
• 6 variables to trade: price, term, scope, payment, SLA, legal.
• Anchor high (15-20% above target). Fade slowly.
• Silence is power. Hold the number after stating it.
• No MFN clauses. Ever.
• Walk-away line written pre-negotiation.

```

These aren't instructions the model has to parse from context. They're rules the model applies as constraints.

The Hamilton Helmer analysis (in the moat-analysis-framework Original) wouldn't have stayed rigorous without principles like "pick 2-3 moats to deepen — you can't build all 7." Without it, the model would've produced 7-paragraph coverage with no hierarchy.

Pattern 4: The fallback prevents half-filled prompts

Users rarely fill out a full structured prompt on first attempt. They paste a scenario and go.

The fix is a fallback at the end of your prompt:

```

If input incomplete: ask for business context, current state, goals, timeline, constraints, specific concerns.

```

This tells the model: "If the human hasn't given you enough to work with, ask questions before answering."

Before adding , ~30% of our test prompts produced mediocre outputs because the model guessed at missing information and guessed wrong. After , the model asks targeted questions first, gets real context, then produces actual-use-case output.

This single pattern turned "AI answers" into "AI consultations."

Pattern 5: Example outputs in the prompt anchor quality

Every Promptolis Original includes an example_input and example_output showing what a good invocation looks like.

This serves two purposes:

For users: shows what inputs make the prompt work.

For the model (when users reuse): anchors the output quality. The model pattern-matches to the example output length, depth, and style.

Our example outputs are 1,500-2,500 words. Why? Because the model will often match that range. Shorter examples produce shorter outputs. One-sentence examples produce one-paragraph outputs.

For high-stakes prompts (contracts, medical reasoning, financial analysis), explicit example outputs prevent the "3 bullet points and done" failure mode.

Practical application: if you have a prompt you'll reuse, include ONE example input + example output. The model uses it as a template.

Pattern 6: "Not legal/medical/tax advice" protects both parties

Several of our Originals cover legal, medical, and financial topics. Each includes an explicit disclaimer:

```

• NOT legal advice. For significant matters, consult licensed attorney.

...

```

The disclaimer does real work in the prompt — it prevents the model from overstepping into false-confidence medical diagnoses, legal pronouncements, or tax recommendations.

More importantly, it shapes output quality. When the model is reminded "this is not legal advice," it shifts from "here's what to do" to "here are the considerations + frameworks + when to escalate." The second is more useful AND safer.

Where this matters most:

• Medical/clinical content
• Legal documents
• Tax/financial planning
• Compliance (HIPAA, GDPR)
• Mental health topics

Disclaimers aren't CYA. They're better prompts.

Pattern 7: "Key Takeaways" as a forcing function for synthesis

Every Promptolis Original ends its example output with:

```

Key Takeaways

• [5 bullets]

```

This isn't a formality. It's a forcing function.

When the model has to write 5 takeaway bullets at the end, it has to:

• Identify the 5 most important points from the longer response
• Distill them into scannable format
• Choose what to include (prioritization)
• Choose what to exclude (editorial discipline)

Without this forcing function, long outputs sprawl without clear "what to remember."

Additionally, Key Takeaways serve as the one-screen version for mobile readers, skimmers, and anyone who didn't read the full output. If the full output is a 2,500-word deep-dive, the Key Takeaways are the 200-word executive summary.

Research note: Amy Cuddy's work on "expansion" in communication suggests readers retain about 20% of long-form content. Key Takeaways explicitly format the 20% most important content so it gets retained.

Putting it all together: the full pattern template

Here's the complete template we use across Promptolis Originals, with all 7 patterns applied:

```

[Specific expert role with credentials, years, numbers. Attitudinal framing.]

• [Domain-specific rule 1]
• [Domain-specific rule 2]
• [Rule that prevents common failure mode]
• [Rule that enforces hierarchy]
• [NOT advice disclaimer if relevant]
• [Output format constraint]
• [Edge case handling]
• [Synthesis requirement]

{what to provide}

{what to provide}

...

[Task Output: Contextual Title]

Section 1

[What goes here]

Section 2

[What goes here]

...

Key Takeaways

5 bullets.

If input incomplete: ask for [specific context elements needed].

Now, [specific imperative action — analyze, design, plan, etc.]:

```

This template has produced 336 reliable prompts across domains from Legal to Healthcare to Sales to Creative Writing. It scales because it separates concerns:

• = who (expertise)
• = rules (constraints)
• = data (what user provides)
• = structure (what you get back)
• = fallback (handle missing data)

Each block does one thing. The model follows the structure because it's trained to.

What didn't work (patterns we killed)

Not every pattern survived our 336-prompt test. These didn't work:

"Pretend you are..." → too playful. Produces less rigorous output than "you are."

"Step-by-step" without structure → triggers rambling. Works in simple math problems. Fails on complex analysis.

Very long system prompts (>2,000 tokens) → diminishing returns after ~800 tokens. Models forget earlier instructions.

Generic "provide comprehensive analysis" → produces bloated outputs. Too many sections, too shallow per section.

Emoji-heavy prompts → signal-noise ratio poor. Model seems to match tone, but quality drops.

"Think carefully" or "be sure to..." → these are empty instructions. The model can't distinguish careful thinking from normal thinking. Use principles instead.

Why this matters for prompt engineering in 2026

Prompt engineering has matured. "Write a poem about X" isn't prompt engineering — it's a request. Real prompt engineering treats the prompt as a contract: you specify the role, rules, inputs, outputs, and fallbacks.

The patterns above aren't novel. They're the consensus of what experienced prompt writers (Anthropic's own guides, Riley Goodside, Simon Willison, Latent Space community) have converged on.

What's novel is having them applied consistently across a large corpus. 336 Promptolis Originals is an unusually large evidence base for what actually works. Patterns that held across Legal, Healthcare, Sales, Creative Writing, Data Analytics, and 16 other categories are probably general.

These are those patterns.

Try it yourself

Browse the Promptolis Originals library to see these 7 patterns applied across 336 prompts in 21 categories. Every Original is copy-ready, works in Claude/ChatGPT/Gemini, and includes a full example input + output you can adapt.

Or take the 7-pattern template above and apply it to your next high-stakes prompt. Even applying 3-4 of the patterns (role + principles + XML structure + Key Takeaways) will meaningfully improve output quality.

The gap between amateur prompts and expert prompts is less about cleverness and more about structure. These 7 patterns are the structure.