How to teach AI your brand voice (and stop rewriting every draft)

Prompt engineering for Content Designers

Imagine you met a really smart storyteller who can help you write stories. But here’s the problem: the storyteller doesn’t know you yet.

You: “Hey, write me a story!”

Storyteller: “Once upon a time there was a princess...”

You: “No no no! I want a story about dinosaurs!”

Storyteller: “Once upon a time there was a dinosaur princess...”

You: “ARGH! No princesses! Just dinosaurs doing dinosaur things!”

This happens 10 times. You get frustrated. The storyteller gets confused.

The solution: Instead of just saying “write me a story,” you need to teach the storyteller how you want stories. Give them a recipe card.

The 5 things on your recipe card

1. Context = “Here’s what’s happening”

“We’re writing a bedtime story for my little brother. He’s 4. He loves dinosaurs. He’s scared of the dark.”

Now the storyteller knows: make it gentle, not scary, dinosaurs are the heroes.

2. Instructions = “Here’s exactly what to do”

“Make it 5 sentences long. The dinosaur should solve a problem. End with the dinosaur going to sleep. No scary parts.”

Clear rules = Storyteller knows what to do.

3. Examples = “Here’s what good looks like”

“Good story: ‘Little T-Rex was afraid of the dark. His mom gave him a glowing rock. Now he feels brave. He can sleep anywhere. Goodnight, T-Rex.’

Bad story: ‘The dinosaur ate everything and roared loudly. THE END.’ (Too loud for bedtime!)”

Now the storyteller can copy what you like.

4. Rules = “Don’t do these things”

“Don’t use big words. Don’t make the dinosaur eat anyone. Don’t make loud sound effects. Use periods, not exclamation marks.”

Specific don’ts = Storyteller stays on track.

5. Checking = “Before you’re done, check your work”

“Is it 5 sentences? Is it gentle? Does the dinosaur go to sleep? If you answered NO to any of these, write it again.”

Storyteller learns to fix mistakes before showing you.

Why this works

Before recipe card:

• You: “Write story!”

• Robot: writes random thing

• You: “Wrong!”

• Repeat 10 times 😤

After recipe card:

• You: give robot the recipe card once

• Robot: reads all 5 things

• Robot: writes exactly what you want

• You: “Perfect!” 🎉

• You use the same recipe card every time you need a bedtime story

The magic trick

Once you make a good recipe card, you can use it forever.

Every time you need a bedtime story or on-brand UX copy, just give the storyteller (ChatGPT, Claude, or any other AI) your recipe card and tell it: “This time, make it about a triceratops” or “This time, make it about a pterodactyl.”

The AI remembers your rules. You just change the component & context.

Congratulations! You just learned prompt engineering!

Now let’s talk about how this works for real content design work.

---

---

Why content designers need prompt engineering

Most people think prompt engineering is for developers. It’s not.

Developers use it to:

• Extract structured data

• Build AI features

• Automate technical tasks

Content designers use it to:

• Generate on-brand copy at scale

• Test different phrasings quickly

• Create content variations for A/B testing

• Draft microcopy across multiple states

• Maintain voice consistency across large products

AI isn’t replacing you. It’s multiplying your output. But only if you can direct it precisely.

Without prompt engineering:

• You iterate 10+ times to get usable copy

• Each generation feels random

• You spend more time editing than writing from scratch

• Brand voice is inconsistent

With prompt engineering:

• First draft is 80% there

• Consistent voice across all outputs

• You iterate on strategy, not syntax

• AI becomes a reliable content partner

But…Prompt engineering is dead. Models are so smart now they don’t need complex instructions.

That’s only half right. Yes, AI is better at guessing intent. But it still can’t read your mind about brand voice. Prompt engineering for content isn’t about tricking the AI—it’s about constraint management. You’re not coaxing better logic from the model. You’re defining the boundaries it must work within.

The prompt architecture stack

Think of prompts like content strategy—they have layers that build on each other, similar to how we approach any design system.

┌─────────────────────────────────────┐
│ LAYER 5: VALIDATION                 │ ← Critic loop (checks & rewrites)
├─────────────────────────────────────┤
│ LAYER 4: CONSTRAINTS                │ ← Syntax rules > adjectives
├─────────────────────────────────────┤
│ LAYER 3: EXAMPLES                   │ ← 3-5 pairs max
├─────────────────────────────────────┤
│ LAYER 1.5: STRUCTURE                │ ← Content skeleton (long-form only)
├─────────────────────────────────────┤
│ LAYER 2: INSTRUCTIONS               │ ← Do this, not that
├─────────────────────────────────────┤
│ LAYER 1: CONTEXT                    │ ← Who, what, why
└─────────────────────────────────────┘
        ↑                    ↓
        └─── feedback loop ──┘

The layered structure combines established prompt engineering principles with content design system thinking.

Most people only use Layer 2 (instructions). That’s why their outputs are generic.

Good prompt engineers use all layers—and understand that validation loops back to instructions.

Note on Layer 1.5: For microcopy (error messages, CTAs, tooltips), skip this layer. For long-form content (help articles, onboarding flows), define the skeleton before defining voice.

Layer 1: Context (who, what, why)

Give AI the background it needs to make informed decisions.

What to include:

• Product type and audience (general)

• User state and journey stage (specific to this scenario)

• Business goals

• Technical constraints

Example:

❌ Weak context:

Write an error message

✓ Strong context:

You’re writing for a personal finance app used by millennials managing their first budget. User tried to delete a recurring expense but it’s linked to active budgets.

Context helps AI make decisions you’d make—like knowing whether to be reassuring (finance) vs. playful (gaming).

• General product context (”fintech app for millennials”) stays constant.

• Specific scenario context (”user tried to delete expense”) changes every time.

Layer 1.5: Structure (long-form content only)

For anything longer than microcopy, define the skeleton before the voice.

When to use this layer:

• Help centre articles

• Onboarding flows

• Email sequences

• Documentation

When to skip this layer:

• Error messages

• CTAs

• Tooltips

• Button labels

What to include:

• Content hierarchy (H1, H2, H3)

• Section sequence

• Required components (intro, examples, conclusion)

• Approximate length per section

Example:

Structure this help article as:

- H1: Title (question format)
- Intro: 2-3 sentences explaining the concept
- H2: How it works (3-4 bullet points)
- H2: Common scenarios (2 examples with before/after)
- H2: Troubleshooting (3 FAQs)
- Total length: 400-600 words

Without structure, long-form AI content becomes meandering. The AI needs a skeleton before it can apply voice.

If you paste 3 full help articles as examples in Layer 3, you’ll hit context limits or confuse the AI with stylistic variance. Structure first, then examples.

Layer 2: Instructions (do this, not that)

Tell AI exactly what you want and what to avoid.

What to include:

• Specific action to take

• Clear dos and don’ts

• Structural requirements

• Length constraints

Example:

❌ Vague instructions:

Write it clearly

✓ Specific instructions:

Write an error message that:
- Explains what went wrong in one sentence
- Explains why in one sentence
- Provides 2 specific actions as bullet points
- Is under 50 words total
- Does NOT use idioms or jargon
- Does NOT apologize (just explain and help)

AI doesn’t know what ‘clear’ means to you. Be explicit.

Layer 3: Examples (few-shot demonstrations)

Show AI what good looks like by providing examples.

What to include:

• 3-5 pairs maximum (more causes recency bias)

• Examples that demonstrate voice and structure

• Both good and bad examples (what not to do)

The recency bias trap: Too many examples cause AI to ignore earlier instructions and just mimic the most recent example. Limit to 3-5 distinct pairs.

Example:

❌ No examples:

Write in our brand voice

✓ With examples (limited to 3):

Here are examples of our voice:
Good:
- This recurring expense is linked to 3 budgets. Remove it from those budgets first, or archive it instead.
- Your budget needs at least one income source to calculate spending limits. Add your income to continue.
- Cannot complete transfer. Your daily limit resets at midnight EST.

Bad (don’t do this):
- Oops! Looks like something went wrong!
- Error: Cannot process request.

Layer 4: Constraints (syntax rules over adjectives)

Define the boundaries AI must work within—using concrete syntax, not subjective feelings.

The adjective trap: AI interprets “confident” as a statistical probability of tokens, not an emotional state. “Not cocky” is impossible to quantify.

What to include:

• Syntactic rules (sentence structure, voice, punctuation)

• Specific word choices to use/avoid

• Formatting rules

• Concrete measurables

Example:

❌ Subjective adjectives:

Be professional and friendly. Sound confident but not cocky. Be helpful but not hand-holding.

✓ Concrete syntax rules:

Sentence structure:
- Maximum 2 clauses per sentence
- Start with imperative verbs (”Remove”, “Add”, “Archive”)
- Use active voice only (”We couldn’t process” not “The request could not be processed”)
Punctuation:
- Use periods, not exclamation marks
- No emojis
- Use contractions (”can’t” not “cannot”) for friendly tone
Word choices:
- Use: ‘linked to’ not ‘associated with’
- Use: ‘archive’ not ‘hide’
- Avoid: ‘unable to’, ‘unfortunately’, ‘sorry’, ‘just’, ‘simply’
Formatting:
- Sentence case only
- Bullet points for actions
- Numbers for steps

Syntax is measurable. Adjectives are interpretable.

“Friendly” can mean “uses contractions + exclamation marks” or “uses first-person pronouns + questions.” Be explicit.

Translation guide for common adjectives:

┌───────────────────────────────────────────────────────────────────────────┐
│  VAGUE ADJECTIVE  |                    CONCRETE SYNTAX                    │
├───────────────────────────────────────────────────────────────────────────┤
│ Be concise        │ Maximum 2 clauses per sentence                        │
├───────────────────────────────────────────────────────────────────────────┤
│ Be confident      │ Start with imperative verbs. No hedging words like    │
│                   │ ‘might’, ‘possibly’, ‘perhaps’                        │
├───────────────────────────────────────────────────────────────────────────┤
│ Be friendly       │ Use contractions. Use ‘we’ & ‘you’. No passive voice  │
├───────────────────────────────────────────────────────────────────────────┤
│ Be professional   │ No contractions. Use full sentences. Periods only,    │
│                   │ no exclamation marks                                  │
├───────────────────────────────────────────────────────────────────────────┤
│ Be helpful        │ Include 2-3 specific next steps with action verbs     │
└───────────────────────────────────────────────────────────────────────────┘

Layer 5: Validation (the critic loop)

Tell AI how to evaluate its own output—and force it to rewrite if it fails.

The yes-man trap: LLMs hallucinate validation. If an AI generates a bad draft, it often lies on the checklist to match the draft rather than fixing the draft.

What to include:

• Quality checklist

• Explicit instruction to critique before finalizing

• Requirement to rewrite if validation fails

Example:

❌ Weak validation (AI will lie):

Check if it’s under 50 words. Show your answers.

✓ Strong validation (forces honest critique):

Before showing me the final copy, critique your draft using these questions:

1. Is it under 50 words? (Count every word. Show the count.) 
2. Does it use any idioms? (List any idioms found. Idioms include: ‘just’, ‘simply’, ‘try’, phrasal verbs like ‘reach out’) 
3. Does it explain both what and why? 
4. Are the next steps actionable? (Can a user do them without clarification?)
5. Would this translate literally to another language without confusion?

If ANY answer reveals a problem, REWRITE the copy to fix it. Show me: 
- Your critique (with specific issues found) 
- The revised copy 
- Confirmation that all checks now pass

Why this matters: Forcing AI to critique step-by-step (Chain-of-Thought reasoning) before finalizing prevents hallucinated validation. The AI must identify specific issues and fix them.

Pro tip: Separate the drafter from the validator. First prompt generates copy. Second prompt critiques it against your guidelines. This prevents the yes-man effect.

---

A note on data security

Before we go further, let’s talk about what you should never paste into AI tools.

AI is a tool, not a vault. When you use ChatGPT, Claude, or similar tools (especially free versions), treat them like a contractor you just met in a coffee shop. Give them the context they need to do the job, but don’t give them your login credentials.

Never paste:

• Real user names, emails, or account numbers (PII)

• Unreleased confidential feature details (unless you’re on an enterprise plan with proper safeguards)

• Trade secrets or proprietary business logic

• Actual customer data or support tickets with identifiable information

In enterprise fintech (like the examples I’ve used), pasting proprietary error scenarios or user context into public AI tools can be a fireable offense.

The enterprise vs. consumer distinction:

• API/Enterprise plans (ChatGPT Team/Enterprise, Claude for Work): Often have zero-retention policies and contractual privacy protections

• Consumer plans (ChatGPT Free/Plus, Claude free): Your chats may be used for training. Assume a human reviewer might read them.

The fix: Anonymize everything. Use placeholder names. Generalize user scenarios. If you’re working on unreleased features, check your company’s AI policy first.

Even anonymized data patterns can be risky in free models. Example: “User tried to transfer money between accounts” reveals you have a transfer feature. If that’s unannounced, you’ve leaked information.

Safe approach:

• Instead of: “User John Smith tried to transfer $5,000 to his savings account ending in 4521”

• Use: “User tried to transfer money to a linked account”

If you’re on a free tier, assume a human reviewer might read your chat.

Your prompts can still be detailed and effective without exposing sensitive information.

---

Real example: Building a complete prompt

Let’s build a prompt for generating error messages using all layers (skipping 1.5 since this is microcopy).

The complete prompt:

CONTEXT:
You’re writing error messages for a personal finance app used by millennials (ages 25-35) managing their budget for the first time. The user tried to delete a recurring expense that’s currently linked to 3 active budgets. Deleting it would break those budgets.

INSTRUCTIONS:
Write an error message that:
1. Explains what the user tried to do
2. Explains why it can’t be done
3. Provides 2 specific next steps as separate bullets
4. Keep it under 50 words total
5. Use sentence case
6. Do NOT apologize
7. Do NOT use idioms or casual phrases like ‘oops’, ‘uh oh’

Format the 2 action options as bullet points.

EXAMPLES OF OUR VOICE (3 PAIRS):
Good examples:
- ‘This recurring expense is linked to 3 budgets. Remove it from those budgets first, or archive it instead.’
- ‘Your budget needs at least one income source to calculate spending limits. Add your income to continue.’
- ‘Cannot complete transfer. Your daily limit resets at midnight EST.’

Bad examples (don’t write like this):
- ‘Oops! Looks like something went wrong!’
- ‘We’re unable to process your request at this time.’

CONSTRAINTS (SYNTAX RULES):
Sentence structure:
- Maximum 2 clauses per sentence
- Start with imperative verbs for action items
- Use active voice only

Punctuation:
- Periods only (no exclamation marks)
- Use contractions for friendly tone

Word choices:
- Use: ‘linked to’ not ‘associated with’
- Use: ‘remove’ not ‘delete’ when talking about connections
- Avoid: ‘unable to’, ‘unfortunately’, ‘sorry’, ‘just’, ‘simply’, ‘try’

Formatting:
- Sentence case only
- Bullet points for actions
- No bold or italics

VALIDATION (CRITIC LOOP):
Before showing me the final copy, critique your draft:

1. Word count: Count every word. Is it under 50?
2. Idiom check: Does it use ‘just’, ‘simply’, ‘try’, or phrasal verbs? List any found.
3. Explanation: Does it explain both what and why?
4. Actionability: Can a user complete the next steps without clarification?
5. Translation safety: Would this work literally translated to Spanish?

If ANY check fails, REWRITE the copy to fix it. Show me:
- Your critique (specific issues found)
- The revised copy
- Confirmation all checks pass

Result from this prompt:

AI’s critique:

1. Word count: 31 words ✓

2. Idiom check: None found ✓

3. Explanation: Explains “cannot delete” (what) and “linked to 3 budgets” (why) ✓

4. Actionability: Both actions are specific and completable ✓

5. Translation safety: Direct translation works (no idioms or cultural phrases) ✓

All checks pass.

Final error message:

Cannot delete this expense—it’s linked to 3 budgets.
To proceed: 
• Remove it from those budgets first 
• Archive it to keep your budgets working

Why this works:

• Explains what happened (can’t delete)

• Explains why (linked to 3 budgets)

• Gives 2 clear options in bullets (as requested)

• 31 words (well under 50)

• Uses syntax rules (active voice, imperative verbs, contractions)

• No apologies, no idioms

• Formatted exactly as specified

First try. No iteration needed.

---

Pro tip: System prompts vs. user prompts

Tired of pasting Layers 1, 3, and 4 every time you need copy?

Modern AI tools separate persistent context (system prompt) from specific tasks (user prompt).

In ChatGPT: Use ‘Custom Instructions’ in settings or create a project to store your brand voice, constraints, and examples.

In Claude: Create a Project and add your voice guidelines, examples, and constraints to project knowledge.

What this means for your workflow:

Store once (in system prompt):

• Layer 1: General product context (what your product is, who it’s for)

• Layer 3: Voice examples

• Layer 4: Brand constraints (syntax rules)

Write every time (in user prompt):

• Layer 1: Specific scenario context (what the user just did, current emotional state)

• Layer 2: Task instructions

• Layer 5: Validation for this task

Example breakdown:

Stored in system prompt:

• “You’re writing for a personal finance app used by millennials managing their budget”

• [Your 3 best error message examples]

• [Your syntax rules: active voice, contractions, imperative verbs, max 2 clauses per sentence]

Written fresh each time:

• “User tried to delete a recurring expense linked to 3 budgets”

• “Write an error message that explains what and why, provides 2 actions...”

• “Critique your draft: check word count, idioms, actionability. Rewrite if needed.”

Critical distinction: User emotional state must go in the user prompt. If you lock “user is calm” into the system prompt, you can’t write effective error messages for angry users.

Result: You only type the specific scenario and instructions for each new error message, CTA, or piece of copy. The AI already knows your brand voice and general product context.

This transforms prompt engineering from a chore into a scalable system.

---

Common prompt engineering patterns

Pattern 1: The if-then prompt (applying conditional logic)

Use conditional logic in your prompts for different scenarios.

IF user is new (< 1 week):
- Add more context and explanation
- Include ‘Learn more’ links
- Use complete sentences

ELSE IF user is returning:
- Be brief
- Focus on the specific issue
- Skip basic explanations

ELSE IF user is power user:
- Be extremely brief
- Assume knowledge
- Just tell them what to fix

Example prompt:

Based on user state, adjust the error message: 
- New users: Include what this feature does + why it matters 
- Returning users: Focus on the specific error only 
- Power users: Just the error + solution, no context

Pattern 2: The variation generator

Generate multiple options at once for A/B testing.

Generate 3 variations of this CTA:
1. Benefit-focused (emphasize what user gains)
2. Action-focused (emphasize what happens next)
3. Urgency-focused (emphasize time/scarcity if relevant)

Keep all under 3 words.

Pattern 3: The consistency checker

Use AI to review existing copy for voice consistency.

Review these 5 error messages and identify which ones break our syntax rules:

Syntax rules:
- Max 2 clauses per sentence
- Active voice only
- No apologies
- Start actions with imperative verbs

Error messages:
1. [Your message here]
2. [Your message here]
...

For each, tell me: Does it follow our syntax? If not, what specifically breaks the rule?

This prompt helps you scale content review without hiring more people by forcing AI to cite specific rule violations, not just give vague feedback.

Pattern 4: The microcopy suite

Generate all related microcopy states at once to ensure all states use the same voice and terminology.

For the ‘Export data’ feature, generate copy for:
1. Button label
2. Hover tooltip
3. Loading state
4. Success message
5. Error message (if file too large)
6. Error message (if no data to export)

Use our syntax rules (active voice, max 2 clauses, contractions).
Keep voice consistent across all 6.

Pattern 5: The developer handoff (JSON output)

Position yourself as highly technical by generating structured copy.

Write error messages for these 5 states and output as a JSON object that developers can use directly.

Format:
{
  “error_code”: “EXPENSE_LINKED”,
  “user_message”: “Cannot delete...”,
  “actions”: [“Remove from budgets”, “Archive expense”],
  “severity”: “warning”
}

Now, developers can copy-paste your output directly into code. You become indispensable because you’re delivering implementation-ready content, not just words in a doc.

Pro tip: This is especially powerful for design systems. Generate entire microcopy libraries in JSON format that can be imported directly into component libraries.

The BIG question: When to use AI vs. when to write yourself

Use AI for:

• First drafts you’ll refine

• Generating variations for testing

• Scaling content across similar patterns

• Documenting existing voice (analyzing your copy)

• Repetitive microcopy (button labels, form fields)

Write yourself for:

• Strategic messaging (value props, positioning)

• Brand-defining moments (onboarding, first use)

• High-stakes copy (legal, security, payments)

• Creative concepts (empty states with personality)

• Anything that defines your brand voice

AI amplifies your voice. It doesn’t create it.

If you can’t explain your voice clearly enough to teach AI, you probably don’t have a clear voice yet. Define it first. Then use AI to scale it.

The AI content workflow

Here’s how to integrate AI into your content process:

Step 1: Define your voice (once)

• Document your syntax rules (not adjectives)

• Collect 10-15 examples of your best copy

• Note what you never say

Step 2: Build prompt templates (once per content type)

• Error messages template

• CTA template

• Empty state template

• Confirmation template

Step 3: Set up system prompts

• Store general product context, examples, and syntax rules in ChatGPT Custom Instructions or Claude Projects

• Now you only type specific scenario and validation each time

Step 4: Generate drafts (every time)

• Use your template

• Add specific scenario context

• Include critic loop validation

• Generate 2-3 variations if testing

Step 5: Review and refine

• Check against your syntax rules

• Verify technical accuracy

• Test with real users

• Iterate

Step 6: Document learnings

• What worked? Add to examples

• What didn’t? Tighten syntax rules

• Update templates

The result: Your prompts get better over time. Your first drafts get closer to final. Your voice stays consistent.

Quality control checklist

Before using AI-generated content, always check:

• Voice consistency:

  • Follows our syntax rules (not subjective tone)

  • Matches examples I provided

  • No off-brand phrases

• Accuracy:

  • Technically correct

  • Actionable next steps

  • No made-up features or capabilities

• Clarity:

  • Would a new user understand this?

  • No jargon or idioms

  • Translates well to other languages

• Effectiveness:

  • Achieves the goal (reduce errors, drive action, etc.)

  • Appropriate for user state

  • Works on mobile and desktop

• Security:

  • No sensitive information included

  • No PII or proprietary details leaked

  • Safe for public AI tools

• Never publish AI content without human review. AI is your first draft, not your final draft.

Building your prompt library

Don’t let good prompts disappear into Slack threads. Build a library your whole team can use.

Simple structure:

Create a shared Notion page or spreadsheet with these columns:

• Content type - Error message

• Trigger/use case - Linked data

• The prompt - [Full prompt]

• Example output - “Cannot delete...”

• Last updated - Nov 2025

This helps every content designer on your team generate on-brand copy without starting from scratch. You’re not just improving your own workflow—you’re scaling your voice across the entire team.

Start small:

• Pick one content type (error messages, CTAs, etc.)

• Build one good prompt template

• Use it 10 times, refine it

• Then expand to other content types

Get better over time:

• Collect examples of what works (limit to 3-5 per category)

• Document syntax rules that AI violates

• Tighten constraints

• Update templates

Share with your team:

• Document your prompts

• Create a prompt library

• Train others to use them

• Build on each other’s learnings

The goal isn’t to replace writers with AI. It’s to make every writer 10x more productive while maintaining quality.

What’s next

We’ll build on what you learned about prompts to tackle something even more complex: intent mapping. Understanding what users really mean when they say something to a chatbot or voice interface.

See you in January. Happy new year!

— Mansi
Your UX Writing Bud

---

Found this useful? Here’s how to go deeper:

Share your prompts - Built a great prompt template? DM me on Substack. I’ll feature the best ones (with credit).

Share with your team - Forward this to other content designers exploring AI. Build your prompt library together.

Tell me what worked - Used this framework to generate better AI content? Reply with your results.

Support this work - If this changed how you use AI, buy me a coffee/book.

---

UX Writing Bud delivers frameworks and systems for content designers every alternate Friday. Free, always.