Prompting and Task Execution · Lesson 1 of 5

1.1 — System Prompts and Giving Claude a Role

Use the system prompt to set Claude's role, constraints, and output expectations instead of relying on vague instructions.

A system prompt is the instruction you set once, before the conversation starts, that shapes how Claude behaves for every message that follows. In claude.ai this is the "system prompt" or "custom instructions" field on a Project; in the Console it's a dedicated field separate from the conversation itself. It's the right place to put a role, a set of constraints, and an output format — things that should hold for the whole conversation, not just one message.

The most common mistake is writing vague instructions: "be helpful," "use good judgement," "write professionally." These sound reasonable but give Claude no concrete decision boundary. Different readers interpret "professional" differently, and so will Claude, inconsistently, across runs — which is exactly the failure the exam tests: a team notices tone drifting message to message and reaches for the wrong fix.

Explicit Criteria Beat Vague Instructions

Compare two system prompts for a customer-email assistant:

Vague: "Write professional, on-brand customer emails."

Explicit: "You are a customer service specialist for Acme Outdoors. Use a warm, plain-spoken tone. Never use exclamation points. Always acknowledge the customer's specific issue by name before offering a solution."

The second version gives Claude an actual role ("customer service specialist for Acme Outdoors") and concrete rules it can apply consistently. When output feels inconsistent or generically toneless, the fix is usually adding role and constraints to the system prompt — not writing a longer paragraph of vague praise for good writing, and not lowering a sampling setting like temperature, which affects wording randomness, not the underlying persona.

What Belongs in the System Prompt vs. the Message

A useful test: would this instruction apply to every message in the conversation, or just this one? Role, tone, brand voice, formatting rules, and things Claude should never do belong in the system prompt — they're constant. The actual customer complaint, the specific document to summarize, the one-off request all belong in the message itself. Teams sometimes paste the entire task into the system prompt field out of habit; that works, but it means every new task requires editing the system prompt again instead of just sending a new message against a stable, reusable role.

Key Concept

A short, specific role statement ("you are X, writing for Y") is often the single highest-leverage sentence you can add to a prompt with inconsistent tone. It gives Claude a consistent lens to filter every later instruction through.

Common Exam Distractor

Watch for answers that add more prose description of the desired tone ("make it warmer, more empathetic, more on-brand") without ever stating a role or concrete rule. More adjectives are not more precision — a role plus explicit rules is. Also watch for answers reaching for a model or sampling setting (temperature, model choice) to fix what is really a missing-role problem.

Exam traps

Choosing 'add more descriptive language about tone' as the fix for inconsistent output

Prose description without a concrete role or rule still leaves Claude to guess at a subjective standard. A short role statement and explicit constraints are more reliable.
Treating the system prompt as just another place to paste the user's question

The system prompt should hold what stays constant across the whole conversation — role, tone, constraints, format. Per-turn requests belong in the actual message.
Reaching for a model or sampling-setting change (e.g. temperature) to fix inconsistent tone

Temperature affects word-choice randomness, not the underlying persona or rule set — it doesn't address the actual cause of tone drift.

Practice question

A team's Claude-generated support replies read as generic and inconsistent in tone from one reply to the next, even though the prompt already says 'write in a warm, professional tone.' What is the most effective lightweight fix?

A Expand the instruction with several more adjectives describing the desired tone in more detail
More adjectives describing an already-vague standard don't give Claude a concrete decision rule; the inconsistency will likely persist.
B Add a system prompt sentence giving Claude a specific role, e.g. 'You are a senior support specialist for [Brand], writing directly to a frustrated customer' Correct
A concrete role anchors every later instruction to a consistent persona and perspective, which is a reliable, low-effort fix for generic or inconsistent tone.
C Lower the temperature setting to make responses more deterministic
Temperature affects randomness in wording, not the underlying tone or persona consistency, and isn't the tool for this problem.
D Ask the user to specify the tone manually in every single message
This pushes a system-level consistency problem onto the user's shoulders on every turn instead of fixing it once at the prompt level.

Build exercise: Give a Claude Project a Consistent Role

Beginner · 20 minutes

You'll practice:

Recognise vague vs. explicit system prompt instructions
Write a role statement that anchors tone and perspective
Observe the effect of a role statement on output consistency

In claude.ai, create a new Project and open its custom instructions / system prompt field. Write a vague instruction like 'write professional customer emails' and send the same customer complaint scenario as a message three times in three separate conversations within the Project.

Establishing a baseline shows the inconsistency problem the exam tests: vague instructions produce different tone and structure across runs.

You should see: Three replies with noticeably different openings, tone, and level of formality, even though the underlying instruction never changed.
Hints
1. ```
Use the exact same complaint message each time so tone is the only variable.
```
2. ```
Look specifically at the greeting and sign-off — these tend to vary the most under a vague instruction.
```
3. ```
Try: 'My order arrived damaged and I want a refund.' as the test message in all three runs.
```
Rewrite the custom instructions to include an explicit role ('You are a senior support specialist for [Brand]') plus two concrete rules (e.g. 'always acknowledge the specific issue by name' and 'never use exclamation points'), then repeat the same three-run test.

This demonstrates the fix: an explicit role plus concrete rules produces consistent tone, which is the correct exam answer pattern for this class of problem.

You should see: Three replies that open and close similarly, all consistently acknowledging the damaged order and avoiding exclamation points.
Hints
1. ```
Keep the role statement to one sentence — it doesn't need to be long to be effective.
```
2. ```
Make at least one rule something you can visually check for (like punctuation), so consistency is easy to verify.
```
3. ```
Compare the three new replies side by side against the three vague-instruction replies from the first step.
```
Add one genuinely task-specific detail (today's actual order number and complaint) directly in a message rather than editing the system prompt again, and confirm the role/rules still apply automatically.

This checks that you've correctly separated what's constant (role, tone, rules) from what varies per task (the specific complaint) — the core distinction the exam tests.

You should see: A reply that applies the same consistent role and rules from the system prompt while responding to the new, specific complaint you just sent.
Hints
1. ```
You should not need to touch the Project's custom instructions at all for this step.
```
2. ```
If the tone reverts to generic, double check the role/rules are still saved in the Project's instructions field.
```
3. ```
This is the pattern you'll reuse for every new customer complaint going forward — one stable role, many one-off messages.
```

Sources

Reused/adapted from CCAR-F lesson 4-1-system-prompts
Anthropic docs — System Prompts