IntermediateLesson 14 of 306 min read

Roles, Styles and Custom Instructions

Learn the layers of personalisation, how to write specific roles and instructions, how to teach a custom style by example, and how to find conflicts between layers with a real checker.

In this lesson you will

  • Name the layers of personalisation
  • Write specific roles and short instructions
  • Create a style from examples
  • Detect and fix conflicts

About 22 minutes

Three sets of rules that disagree

Tom has set up Claude carefully. In his account preferences he wrote ‘keep answers short and use bullet points’. In his newsletter project he wrote ‘give detailed, long articles for parents’. Today he picked a ‘formal’ writing style from a menu. Now his replies are a strange mixture: long, formal and bulleted, and sometimes not what any of his rules asked for. Tom did nothing wrong in any single place. But three layers of instructions are pulling in different directions. This lesson explains the layers, how to write instructions that work, and how to find conflicts before they confuse you.

The layers of personalisation

Anthropic’s help pages describe several ways to personalise Claude, and they do different jobs:

  • Profile preferences are account-wide. They tell Claude things that apply to everything you do with it, such as your background and the way you like answers.
  • Project instructions apply only to chats inside one project. They give the context and rules for that piece of work.
  • Styles change how Claude communicates: tone, structure and length. There are preset styles, and you can create custom ones by giving Claude samples of writing you like.
  • Your message sits on top of all of these and is the most specific instruction of all.

Availability varies by plan and over time, so check what your version offers. The useful way to think about them is as a stack: general, then specific, then stylistic, then your actual request. Each layer should do its own job and avoid contradicting the others.

Roles and personas

A common instruction is to give Claude a role: ‘You are a careful editor’, ‘You are a patient maths tutor for a twelve-year-old’, ‘You are a sceptical reviewer’. A good role does three things. It sets the point of view, so the replies come from a stance. It sets the standards, such as ‘do not praise, find problems’. And it often sets the audience. But a role is not a licence to invent. If you say ‘You are an expert doctor’, Claude does not become one. For anything with health, law or money consequences, the role changes the style of the answer, not the reliability of the facts.

You are a sceptical editor for a village library newsletter. For each draft I paste, list the three biggest problems first. Do not praise. Do not rewrite unless I ask. If a fact looks unsupported, say so.

A conflict detector

The program below reads Tom’s three layers as small sets of rules, each a setting and a value. It looks for any setting that is given two different values, reports the conflicts, and then merges the layers using an explicit order. That order is our own rule for the demonstration: later layers win. In real life Claude does not necessarily resolve conflicts in the same way, and results can be unpredictable, which is why you remove conflicts instead of relying on a winner.

layers = {
    "profile": {"length": "short", "tone": "friendly", "format": "bullets"},
    "project": {"length": "long", "tone": "friendly", "audience": "parents"},
    "style":   {"tone": "formal", "format": "bullets"},
}
ORDER = ["profile", "style", "project"]      # OUR rule: later layers win

conflicts = {}
for key in {k for rules in layers.values() for k in rules}:
    values = {name: rules[key] for name, rules in layers.items() if key in rules}
    if len(set(values.values())) > 1:
        conflicts[key] = values

print("conflicts found:", len(conflicts))
for key in sorted(conflicts):
    pairs = ", ".join(f"{n}={v}" for n, v in conflicts[key].items())
    print(f"  {key}: {pairs}")

merged = {}
for name in ORDER:
    merged.update(layers[name])
print()
print("merged result:")
for k in sorted(merged):
    print(f"  {k}: {merged[k]}")
total = sum(len(" ".join(f"{k} {v}" for k, v in r.items()).split()) for r in layers.values())
print("words of rules:", total)
conflicts found: 2
  length: profile=short, project=long
  tone: profile=friendly, project=friendly, style=formal

merged result:
  audience: parents
  format: bullets
  length: long
  tone: friendly
words of rules: 16

The program finds 2 conflicts. The first is length: the profile says short and the project says long. The second is tone: the project says friendly and the style says formal. Look at the formatting rule, bullets: the profile and the style agree, so there is no conflict there. The merged result under our ordering is a friendly, long, bulleted reply for parents, which is probably not what Tom wants for every project. The count at the end says the whole rule set is only 16 words, so it is easy to read and fix. In practice, the answer is to decide, for each setting, which layer should own it. Tom would keep ‘short and bulleted’ in the profile as his default, move ‘long and detailed’ into the project and say so explicitly, ‘in this project, ignore the short-answer default’, and choose a style that matches.

Writing instructions that work

  • Be specific. ‘You help me with my novel’ is vague. ‘You are a hard-nosed editor: critique structure and pacing and suggest cuts’ gives something to follow.
  • Say what to do, not only what to avoid. ‘Use plain words’ is clearer than ‘do not be fancy’.
  • Keep it short. A few lines you maintain beat a page you forget. Long, tangled instructions are more likely to clash.
  • Give each layer one job. Who you are in the profile, what this work needs in the project, how it should sound in the style.
  • Test it. Ask the same question with and without the instruction, and see what changed.
  • Review it. Old instructions go stale. Read them every few months.

Creating a custom style

A style works best when you teach it by example. You give it a few samples of writing in the voice you want, or describe the voice in a short note, and then you save it. Anthropic describes custom styles as made from sample content and instructions that you can edit as your needs change. Choose samples that you like and that are typical, not unusual. Then try the style on a short task, and adjust. Remember that a style changes how Claude writes, not what it knows.

Common mistake: one giant instruction

Stuffing every preference into one place. A profile that tries to be a project brief, a style guide and a list of facts about you becomes long and contradictory. Use each layer for its own purpose.

Instructions are stored text

Do not put private details in instructions that you do not want stored, and remember that instructions are visible to you and editable. Review them if more than one person uses your account.

Write down your profile, one project and one style as short lists of rules. Look for any setting that appears twice with different values. Fix each conflict, and then test with a real task.

Practice for this lesson

Check what you learned

Five quick questions. Pick an answer and you will see straight away whether it is right and why.

Which layer applies only to chats inside one piece of work?

  1. Profile preferences
  2. A message
  3. Project instructions
  4. A style only

Project instructions apply to chats in that project, while profile preferences apply account-wide.

What does a style change?

  1. What Claude knows
  2. Your password
  3. The plan
  4. How Claude communicates

Styles shape tone, structure and length, not knowledge.

Why remove conflicts between layers?

  1. Conflicts make Claude faster
  2. Results can be unpredictable when rules disagree
  3. Conflicts are required
  4. It saves tokens

Contradictory rules leave Claude to choose, and the outcome may surprise you.

Does giving Claude the role of an expert doctor make its medical facts reliable?

  1. Yes, fully
  2. Only on weekdays
  3. No, it changes style, not reliability
  4. Only for dates

A role sets point of view and style, but facts still need checking.

Which instruction is better?

  1. You are a sceptical editor: list three problems and do not rewrite
  2. Help me
  3. Be good
  4. Do your best

Specific roles with standards and limits give Claude something concrete to follow.

Summary

  • Profile preferences, project instructions, styles and your message form a stack.
  • Give each layer one job and remove contradictions.
  • A role sets the stance and standards, not the reliability of facts.
  • Keep instructions short, specific and reviewed.

Next lesson

Lesson 15 covers research with web search and sources.

Questions

What is the difference between a style and instructions?

Instructions give context and rules. Styles shape how Claude writes, such as tone, structure and length. Anthropic describes them as working together.

Do these features cost extra?

Availability and limits depend on your plan and change over time, so check Anthropic's current help pages.

How do I know which rule Claude followed?

You may not. Test by asking the same thing with and without a rule, and remove conflicts so there is nothing to guess.

Progress is saved in this browser.