Claude Styles and Personalities: Customizing AI Behavior

What Are Styles, Anyway?

Styles are basically instructions baked into your Claude.ai profile that persist across conversations. When you fire up a new chat, your style goes with you. It's not a system prompt that you have to paste into every conversation. It's not a rigid rule set. It's more like setting up your personal communication preferences once and then having Claude respect them automatically.

Claude.ai ships with four built-in styles: Normal, Formal, Concise, and Explanatory. These are solid starting points, but the real power comes from custom styles, where you teach Claude to sound exactly like you need.

Here's what you need to know: styles affect tone, response length, explanation depth, formatting, and personality. They're the difference between Claude writing like a Wikipedia editor and Claude writing like your knowledgeable friend who actually knows how to explain things.

The Four Built-In Styles

Let's walk through what each preset style does so you understand the spectrum we're working with.

Normal Style

This is Claude's factory default. It's balanced, professional, and adaptable. Normal mode assumes you want clarity and accuracy without unnecessary fluff. Responses are conversational but structured. Examples stay relevant. Explanations are thorough but not overwhelming.

Use Normal when you're doing one-off conversations and don't have a strong preference about how Claude should sound.

Formal Style

Formal tightens everything up. Sentences are more structured. Vocabulary gets elevated. Claude drops casual language ("I know, right?" is out) and leans into professional phrasing. Explanations are still clear, but they're presented with more gravitas.

Want Claude to sound like they're writing a report or academic paper? Formal is your style. It's also great when you're working on professional content and need Claude to match that tone.

Concise Style

Concise is about getting to the point. Claude cuts filler. Explanations are shorter. Code examples are smaller. Lists replace paragraphs. You get answers in the fewest words possible while still being complete.

This is your friend when you're in a hurry, when you need quick facts, or when you're working with APIs and token limits matter.

Explanatory Style

Explanatory does the opposite of Concise. Claude goes deeper. Background context gets included. Multiple angles get explored. Examples multiply. Code gets annotated with comments explaining what each part does.

Use this when you're learning something new and need the hidden layer, the "why this works" stuff that separates beginners from experienced practitioners.

Creating a Custom Style from Writing Samples

Here's where it gets interesting. If the four built-in styles don't fit, you can create custom ones. Claude.ai has two ways to do this: upload writing samples or describe your desired style. Let's start with samples.

The idea is simple: show Claude examples of how you want to sound, and it learns the pattern.

Step 1: Gather your samples. Grab 3-5 pieces of writing that represent your target voice. These could be:

• Blog posts you've written
• Emails you're proud of
• Internal documentation
• Articles from publications you like
• Your own notes or analysis

The samples should be substantial (at least a few paragraphs each) and consistent in voice. If you grab one very formal piece and one very casual piece, Claude gets confused about what you're actually asking for.

Step 2: Go to Claude.ai Settings. Head to your profile and look for Styles. You'll see the four built-in styles listed. There's an option to create a new style.

Step 3: Upload your samples. Claude.ai lets you paste text directly or upload files. Paste your sample writing into the input field. You can add multiple samples.

Step 4: Name your style. Give it something memorable that describes the voice. "Technical but friendly" works better than "Style 1."

Step 5: Test it. Start a new conversation and select your custom style. Ask Claude to write something in that style, then compare it to your samples. Does it match the tone? The length? The explanation depth?

The first version might be 80% there. That's fine. You can refine it. Go back to settings, edit the style, add more samples if needed, or provide clarification about what's working and what isn't.

Creating a Custom Style from Descriptions

If you don't have writing samples, you can describe your desired style directly. This is more challenging because you have to be specific about what you want.

Instead of showing Claude examples, you tell Claude exactly what personality traits and behaviors you're looking for.

What to include in your description:

• Tone: formal, conversational, witty, authoritative, friendly, technical
• Length preference: brief answers, detailed responses, medium depth
• Explanation style: visual analogies, technical depth, step-by-step walkthroughs
• Formatting: numbered lists, prose paragraphs, code-heavy, minimal code
• Audience level: beginner-friendly, intermediate, expert-level
• Personality quirks: casual interjections, humor style, confidence level

Here's an example description:

Write like a knowledgeable peer who's done this work before. Use conversational language with occasional casual interjections. Include technical depth without being academic. Keep paragraphs short. Use code examples liberally. Explain the "why" behind the "how." Address the reader as "you." Be enthusiastic but not overselling. Warn about gotchas before they become problems.

That's the kind of specificity that works. It gives Claude clear direction about personality, tone, audience, and approach.

Step 1: Write your description. Be as specific as you can. Vague descriptions ("write better") don't work. Detailed descriptions ("conversational with technical depth, include code examples, keep paragraphs to 2-3 sentences") do.

Step 2: Create the style in Claude.ai Settings. Paste your description and name the style.

Step 3: Test and refine. Use the style in a conversation. If Claude overshoots or undershoots, edit the description and try again. You're calibrating through iteration.

The difference between a great custom style and a mediocre one is usually one or two rounds of refinement.

Styles vs System Prompts vs Skills: When to Use What

Here's where beginners get confused. Claude has multiple ways to customize behavior: styles, system prompts, and skills. They overlap, but they're not the same thing.

Styles are permanent profile-level customization. They apply to every conversation. They're lightweight and focused on voice/tone/format. They're great for "I always want Claude to sound like this."

System prompts are per-conversation customization. You paste them into the system field (or first message) for a specific conversation. They're powerful for specific tasks or contexts. The downside is you have to include them every time. The advantage is they can be very detailed and task-specific.

Skills (available in Claude Code) are reusable instruction sets that live in your codebase and can be invoked with slash commands. They're for automating specific workflows or defining specialized behavior for particular tasks.

Use them like this:

• Use Styles when you have a preferred communication voice that applies across all your conversations. "I like technical but friendly explanations" -> style.
• Use System Prompts when you're doing a specific task in a specific conversation that needs custom instructions. "Analyze this financial data using these criteria" -> system prompt for that conversation.
• Use Skills when you're building repeatable workflows in Claude Code. "Every time I ask for a code review, run these checks" -> skill.

Can you combine them? Absolutely. A custom style gives you baseline personality. A system prompt adds task-specific context. A skill automates a repeatable workflow. They stack.

Claude Code and the /output-style Command

If you're using Claude Code (Claude's official CLI), there's a command specifically for controlling output style: /output-style.

This command lets you specify exactly how you want Claude to format responses without loading a full custom style. It's handy for one-off requirements or when you're automating scripts that need specific output formats.

/output-style concise "Write output in bullet points, maximum 5 items per section"

After this command, Claude's responses follow that style for the remainder of the CLI session.

You can stack it with other customizations. Set your profile style to "Explanatory" for detailed explanations, then use /output-style in a specific script to force concise output for that script's needs.

The /output-style command is useful when you're:

• Building automation that needs strict formatting
• Testing how Claude sounds in different styles
• Working on projects that require multiple different output formats
• Writing scripts that pipe Claude's output to other tools

The key advantage here is that /output-style is immediate and session-scoped. You don't have to create a persistent style if you just need different output for this one thing.

Project Instructions: The Persistent Context Layer

Here's something that trips up a lot of people: styles control voice and tone. But what if you need Claude to remember context across conversations? What if you're working on a specific project and you want Claude to maintain consistency about facts, rules, or domain-specific knowledge?

That's what project instructions are for. These are settings in Claude Code that persist across conversations and give Claude standing knowledge about your project.

Project instructions are different from styles. They're not about personality. They're about context. You might use them to:

• Define custom terminology for your project
• Establish rules or constraints Claude should follow
• Provide background information that applies to all conversations
• Set domain-specific knowledge that Claude should reference

For example, if you're writing a novel, your project instructions might include:

• Character names and relationships
• World-building details (magic systems, geography)
• Timeline of events
• Established plot points

Claude then remembers these across conversations. You don't have to re-explain your world every time you chat.

Styles + Project Instructions is a powerful combination. Your style controls how Claude sounds. Your project instructions control what Claude knows and remembers about your specific work.

Combining Styles with System Prompts for Layered Control

Want maximum control? Combine a custom style with a system prompt.

Here's how layering works:

Layer 1 (Foundation): Your custom style sets the baseline voice. "Conversational, technical, brief."

Layer 2 (Context): Your system prompt adds task-specific instructions. "You are a code reviewer. Check for performance, security, and clarity. Flag issues with specific line numbers."

Layer 3 (Details): Project instructions provide standing knowledge. "This project uses TypeScript with React. Our error handling pattern is custom."

When all three layers are present, Claude operates within clear boundaries. The style ensures consistent voice. The system prompt directs behavior. The project instructions provide context. You get personality + instructions + memory.

The gotcha: don't be redundant. If your style already says "be conversational," don't repeat it in your system prompt. Each layer should add new information.

Maintaining Consistency Across Sessions

Here's a practical problem: you set up a perfect style, then you forget about it. Next month, you're wondering why Claude sounds different. (It doesn't. You just forgot what you configured.)

To avoid this:

Document your styles. Write down what each custom style is for. What voice does it represent? When do you use it? Keep this in a note or your project README.

Test periodically. Every few weeks, start a new conversation with each of your custom styles and do a quick sanity check. Ask Claude to write about the same topic in each style. Does the voice feel right?

Refine slowly. Resist the urge to overhaul your style every week. Give a style at least 10-15 conversations before you decide it needs changes. You need enough data to know if the style actually works.

Layer your customizations. Remember: styles provide voice, system prompts provide context, project instructions provide memory. Use all three layers if you need perfect consistency across sessions.

Version your project instructions. If you're using Claude Code, your project instructions live in a file. Version that file. Track changes. Know what Claude knows at any given point.

The secret to consistency isn't perfection. It's intentionality. You have to be deliberate about how Claude should sound and what Claude should know, then set it up once and trust it.

Practical Examples: Styles in Action

Let's ground this with real scenarios.

Scenario 1: Technical Writing You're writing documentation. You want Claude to sound knowledgeable but accessible. No unnecessary jargon. Code examples must be practical. Explanations should anticipate common mistakes.

Solution: Create a custom style from technical blog posts you admire. Upload 4-5 articles that match your target voice. Include one code example in your description: "Include inline code comments that explain what each part does."

Scenario 2: Customer Communication You're drafting customer emails. You want warm but professional. Brief enough to respect their time. Action-oriented. No corporate speak.

Solution: Create a custom style from your best customer emails. Upload 3-4 samples that hit the right tone. Add to your description: "Conversational but professional. Focus on benefit to the customer. Keep sentences short. End with clear action step."

Scenario 3: Code Review Comments You're using Claude to review code. You want specific, actionable feedback. Flag issues with code snippets. Suggest fixes without being condescending.

Solution: Use a system prompt with your default or Formal style. Your style handles tone. Your system prompt handles the specific instructions about code review format.

Scenario 4: Research and Learning You're diving into a new technical topic. You want Claude to go deep. Explain mechanisms, not just surface information. Include multiple examples. Link concepts together.

Solution: Use the Explanatory built-in style as-is, or create a custom style based on technical deep-dives you respect. Your description: "Go beyond surface-level explanations. Include background context. Explain the 'why' behind the 'how.' Use multiple examples from different domains."

Each scenario uses styles differently because each has different needs. That's the whole point. Customize based on your actual use case, not on some generic "best practice."

The Real Value: Consistency Without Friction

Here's what people miss about styles: the real value isn't that Claude sounds good. It's that Claude sounds good automatically.

You set it up once. Then every conversation after that, Claude already knows how you like to work. No pasting system prompts. No explaining your preferences again. Your personality is baked in.

That consistency compounds. After a dozen conversations in a custom style, Claude learns your patterns. They understand your communication preferences. Responses feel more natural because they're tailored to you specifically.

The friction drops. You spend less time correcting Claude's tone and more time working on the actual content.

Summary

Styles let you customize how Claude sounds without rewriting system prompts for every conversation. The four built-in styles (Normal, Formal, Concise, Explanatory) cover most needs. Custom styles, built from either writing samples or detailed descriptions, let you dial in specific personality traits.

Combine styles with system prompts for layered control: style handles voice, system prompts handle task instructions, project instructions handle context memory. Use Claude Code's /output-style command when you need one-off formatting requirements.

The key to consistent, effective customization is documenting what you've set up, testing periodically, and remembering that you're building a communication preference, not a rigid rule set.

Take time to set up your styles right. Test them. Refine them. The investment pays off in every conversation after that.