The Setup That Saves You Tokens

Before we set anything up, let's understand the problem we're solving. People waste tokens in a few predictable ways, and each one has a specific fix.

Repeating yourself. Every new conversation, you re-explain who you are, what you're working on, what tone you want. Five messages of setup before you get to actual work. We fixed part of this with CLAUDE.md in Module 3. This module takes it further.

Vague instructions that trigger back-and-forth. "Help me with this document" → Claude asks what kind of help → you clarify → Claude asks about format → you clarify again. Four messages when one clear message would have done it. Module 2's patterns help here, but a well-configured CLAUDE.md also reduces this by giving Claude enough context to make better first guesses.

Starting new conversations for the same task. Every new conversation, Claude re-reads your CLAUDE.md and any project context from scratch. That's tokens spent on setup before a single useful thing happens. Continuing an existing conversation is almost always cheaper.

Not knowing what to ignore. Claude Code has dozens of settings, features, and configuration options. Many people spend tokens experimenting with things they don't need, configuring things that don't help, or asking Claude to explain features they'll never use. This module tells you exactly what matters.

The setup we're about to install addresses all four.

In Module 3, we created a basic CLAUDE.md. Now we're going to replace it with something more considered. This version has been tested across different use cases and refined to be as token-efficient as possible — it gives Claude the context it needs without loading unnecessary instructions.

Let's walk through it section by section, so you understand what each part does and can adjust it for yourself.

The full file

# About Me
[One to two lines about your role, what you do, and your primary use case for Claude Code.]

# How I Work
- Be concise. Explain what you're doing in 1-2 sentences, then do it. Don't over-narrate.
- When I ask for changes to a file, show me what you plan to change before making the change.
- If something is ambiguous, ask me one clear question rather than guessing.
- If a task has multiple reasonable approaches, briefly tell me the options and let me pick.

# Preferences
- British English spelling (organise, colour, analyse)
- Currency: ₹ (INR), not $
- Date format: DD-MM-YYYY
- Keep file names lowercase with hyphens (like-this.md, not Like This.md)

# What I Don't Want
- Don't add unnecessary comments to code or files
- Don't create README files or documentation unless I specifically ask
- Don't add features, improvements, or "nice to haves" beyond what I asked for
- Don't summarise what you just did at the end of every response — I can see the changes

Why each section exists

About Me — This is the single highest-impact line in the entire file. It shapes Claude's tone, vocabulary, assumptions, and suggestions. Without it, Claude defaults to generic. With it, every response is already tailored.

How I Work — These four instructions prevent the most common token-wasting patterns. "Be concise" stops Claude from writing three paragraphs when one sentence would do. "Show me the plan" prevents unwanted changes. "Ask one question" stops multi-question volleys. "Tell me the options" prevents Claude from picking an approach you'd have rejected.

Preferences — Small things that add up. Without these, you spend tokens correcting "color" to "colour" or reformatting dates. Set them once, never think about them again.

What I Don't Want — This section is underrated. Claude has a natural tendency to be helpful in ways you didn't ask for — adding documentation, refactoring nearby code, suggesting improvements. These are well-intentioned but they cost tokens and slow things down. Being explicit about what you don't want is just as important as saying what you do want.

Customising it

The template above is a starting point. Here's how to make it yours:

1. Write your "About Me" honestly. Not what sounds impressive — what's accurate. "I'm a second-year commerce student using Claude to help with assignments and study notes" is more useful than "I'm a student" and infinitely more useful than nothing.

2. Add domain-specific instructions if you have them. If you always work with a particular format, framework, or set of conventions, put them here. "All my blog posts follow this structure: hook, story, insight, takeaway." Now Claude knows.

3. Keep it short. Your CLAUDE.md is loaded into every conversation. A 200-word CLAUDE.md uses fewer tokens than a 2,000-word one, and it's usually just as effective. Include what changes Claude's behaviour. Leave out what doesn't.

Token cost of this setup

This CLAUDE.md is approximately 200-250 tokens. That means every conversation you start has a "startup cost" of about 250 tokens for Claude to read your preferences. In exchange, you save easily 500-1,000 tokens per conversation by not repeating yourself, not correcting defaults, and not going through clarification rounds.

The math works out within the first conversation.

Skills are pre-written instruction sets that activate when Claude encounters specific tasks. In Module 3, we said you could ignore them. Now let's install a few that genuinely earn their keep.

We're recommending five. Each one was chosen because it either saves meaningful tokens, prevents common mistakes, or both.

How to install a skill

Skills are files that live in your ~/.claude/commands/ folder. To install one, you create a file there. We'll give you the exact content for each.

Create the folder first (if it doesn't exist):

mkdir -p ~/.claude/commands

Then create each skill file. You can use any text editor, or ask Claude Code itself to create them:

Create a file at ~/.claude/commands/[skill-name].md with the following content: [content]

Skill 1: Clean Commit Messages

File: ~/.claude/commands/commit.md

What it does: When you ask Claude to create a git commit, this skill ensures the commit message is clean, concise, and follows a consistent format. Without it, Claude tends to write overly long commit messages or include unnecessary detail.

Why it matters for tokens: A good commit message takes one message to create. A bad one takes a correction round or two. This skill eliminates the corrections.

Who needs it: Anyone using Claude Code with git (version control). If you don't use git, skip this one.

Skill 2: Concise Responses

File: ~/.claude/commands/concise.md

What it does: Reinforces concise output when Claude starts being verbose. Sometimes, despite your CLAUDE.md preferences, Claude drifts into explanation mode. This skill gives you a quick way to bring it back.

Why it matters for tokens: Verbose responses cost tokens to generate. A response that's twice as long costs roughly twice the tokens. This skill keeps things tight.

Who needs it: Everyone. This is the single most useful skill for token efficiency.

Skill 3: File Organisation

File: ~/.claude/commands/organise.md

What it does: Gives Claude a consistent approach to organising files — always propose a plan first, wait for approval, then execute. Prevents Claude from enthusiastically reorganising your folders in a way you didn't want.

Why it matters for tokens: One round of "plan → approve → execute" costs fewer tokens than "execute → undo → re-execute differently."

Who needs it: Anyone who uses Claude Code to manage documents and files.

Skill 4: Review & Edit

File: ~/.claude/commands/review.md

What it does: Structures how Claude reviews documents. Instead of giving vague feedback ("the introduction could be stronger"), this skill pushes Claude to identify specific issues and propose specific fixes.

Why it matters for tokens: Specific feedback in one pass costs fewer tokens than vague feedback followed by "can you be more specific?" follow-ups.

Who needs it: Anyone who uses Claude to review or edit writing.

Skill 5: Summarise

File: ~/.claude/commands/summarise.md

What it does: Gives Claude a framework for summarising documents — key points first, supporting detail second, consistent structure. Without it, Claude sometimes produces summaries that are nearly as long as the original.

Why it matters for tokens: A summary that's actually concise uses fewer tokens than one that rambles. And you don't spend additional tokens asking for it to be shorter.

Who needs it: Anyone who uses Claude to summarise documents, articles, or meeting notes.

This matters. Half of "token-efficient" is knowing what to include. The other half is knowing what to exclude.

We didn't include custom agents. Agents are powerful but add complexity. They consume additional tokens to spawn and manage. For most people, direct Claude Code usage handles everything they need. If you grow into needing agents, you'll know — and you can add them then.

We didn't include hooks. Hooks automate things that happen before or after Claude Code actions. Useful for power users, unnecessary overhead for everyone else. They add to your startup token cost and introduce complexity that can break in confusing ways.

We didn't include MCP servers. These let Claude connect to external services — databases, APIs, specialised tools. If you're reading this guide, you almost certainly don't need them yet.

We kept the CLAUDE.md under 250 words. Many power users have CLAUDE.md files that are 1,000-2,000 words long. Each extra word costs tokens on every conversation. Our approach: include only what changes Claude's behaviour. If an instruction doesn't noticeably improve the output, it's costing tokens for nothing.

The setup we've installed is minimal by design. Everything here earns its keep. Nothing is included because it "might be useful someday."

Let's check that everything is working. Open Claude Code and try this:

Read my CLAUDE.md and confirm what preferences you see. Then list what skills are available.

Claude should read back your preferences from the CLAUDE.md and list the skills you installed. If something's missing, it'll be obvious from the response.

Now try a real task that exercises the setup:

Find the most recent document in this folder. Summarise it in 3 bullet points, then suggest one specific improvement to the writing.

You should notice: Claude's response is concise (your CLAUDE.md preferences), the summary is structured (the summarise skill), and the writing feedback is specific, not vague (the review skill). Everything working together.

If something doesn't feel right — Claude is still being verbose, or it's not following a preference — adjust your CLAUDE.md. Small tweaks, not rewrites. Add one instruction, test it, see if it sticks.

You now have two ways to work with Claude. Here's a simple framework for choosing.

Use Claude.ai when:

• You're on your phone
• You want a quick conversation — ask something, get an answer, move on
• You're brainstorming and want a back-and-forth discussion
• You need image analysis (uploading photos, screenshots, diagrams)
• You're sharing a conversation with someone else
• You don't need Claude to touch any files

Use Claude Code when:

• You want Claude to work with files on your computer — reading, editing, organising, searching
• You're doing a task that involves multiple files at once
• You want your preferences (CLAUDE.md) and skills loaded automatically
• You need Claude to actually do something, not just suggest something
• You're working on a project over multiple sessions and want consistent context

Use both when:

• You're on the go and start a conversation on Claude.ai, then continue the deeper work in Claude Code when you're at your computer
• You use Claude.ai for quick ideation and Claude Code for execution

There's no wrong answer here. Some days you'll live in Claude.ai. Some days you'll live in Claude Code. Some days you'll use both in the same hour. The point is you now have options, and you know what each one is good at.

Everything so far has been general. Let's make it specific. Here's how different types of work map onto what you've learned.

If you're a student

Your highest-value setup:

• A Project in Claude.ai for each course or subject
• Upload your syllabus, key readings, or lecture notes as project context
• Use the Explainer pattern (Module 2) heavily — "Explain this concept, I understand [related concept] but I'm stuck on [this part]"
• Use Claude Code to search through and summarise your notes before exams

CLAUDE.md addition:

I'm a [year] [subject] student. Explain concepts clearly but don't oversimplify — I want to actually understand, not just memorise. When I ask about exam topics, focus on what's likely to be tested and common mistakes students make.

If you're a freelancer or consultant

Your highest-value setup:

• A Project per client in Claude.ai — client brief, brand guidelines, past deliverables as context
• Use the Brief pattern for first drafts of proposals, emails, deliverables
• Use Claude Code to manage and organise project files, search through past work for reusable material
• Use the Transformer pattern to adapt one deliverable for different clients or formats

CLAUDE.md addition:

I'm a freelance [your field]. My clients are typically [type of client]. When I ask for help with client deliverables, match the tone to professional but approachable unless I specify otherwise. Always use ₹ for pricing and Indian business context.

If you work in a corporate job

Your highest-value setup:

• Projects for ongoing work streams — "Q2 Marketing Plan," "Monthly Reports," "Team Management"
• Use the Reviewer pattern on your own work before sharing it with your manager
• Use Claude Code to search through documents, prepare meeting summaries, compile data from multiple files
• Use the Brainstormer pattern when you're stuck on a problem and need fresh approaches

CLAUDE.md addition:

I work as [role] at [type of company]. My stakeholders are [who reads your work]. Internal communication style is [formal/casual/mixed]. When helping with presentations or reports, keep them structured with clear takeaways — my leadership team skims, they don't read in detail.

If you run a small business

Your highest-value setup:

• Claude.ai for daily tasks — drafting customer emails, writing social media posts, thinking through business decisions
• Claude Code for organising business documents, searching through records, maintaining files
• Use the Brief pattern for marketing copy, the Reviewer pattern for customer-facing communication, the Brainstormer for strategy

CLAUDE.md addition:

I run a [type of business] in [location]. My customers are [who they are]. Tone for customer-facing content: [warm/professional/casual]. I'm usually the only person doing this work, so keep things practical and actionable — I don't have a team to delegate to.

Ready-to-use prompts for things people do every day. Copy, adapt, use. Each one gets a good result in one shot.

Quick email draft

Write a [tone: professional/casual/friendly] email to [who] about [what]. Keep it under [number] lines. Key point I need to make: [the point]. End with [specific call to action].

Document summary

Summarise this in [number] bullet points. Focus on [what matters — decisions, action items, key findings]. Skip [what to ignore — background, methodology, introductions].

Meeting preparation

I have a meeting about [topic] with [who]. Help me prepare:
1. Three questions I should ask
2. Key points I should raise
3. Potential pushback I might face and how to respond
Context: [any relevant background]

Learning a new concept

Explain [concept] to me. I understand [related thing I know] but I'm stuck on [specific confusion]. Use a concrete example. After explaining, give me one question to test whether I actually understood it.

Reviewing my own writing

Review this for [clarity/tone/grammar/persuasiveness]. Be direct — tell me what's weak and suggest specific replacement text, don't just describe the problem. The audience is [who will read it].

Making a decision

I'm deciding between [option A] and [option B]. Here's the context: [situation]. For each option, give me: the main benefit, the main risk, and what would need to be true for it to be the right choice. Then tell me which one you'd lean toward and why.

These aren't magic prompts. They're well-structured requests that give Claude enough context to respond well on the first try. That's the whole "secret" to prompting — there is no secret. Just clarity.

Honest section. Claude isn't always the right tool, and using it can sometimes feel productive without actually being productive. Here's how to tell the difference.

Claude is helping when:

• You finish a task faster than you would have alone
• The output needs light editing, not a rewrite
• You understand the result well enough to explain it to someone else
• You're using Claude to handle the tedious parts so you can focus on the parts that need your judgement

Claude might be wasting your time when:

• You're spending more time crafting the prompt than the task itself would take
• You're going back and forth for more than 3-4 rounds on the same thing
• You're using Claude's output without understanding or checking it
• You're asking Claude for things you already know the answer to, out of habit

The honest check: after a week of regular use, ask yourself — am I actually getting more done, or am I just interacting with an AI and feeling like I'm getting more done? The answer might surprise you in both directions.

If you find certain tasks where Claude consistently doesn't help, stop using it for those tasks. That's fine. Claude doesn't need to be useful for everything. It needs to be useful enough for enough things to justify its place in your workflow.

Three resources. Not thirty.

1. Anthropic's official documentation docs.anthropic.com — For when you want to go deeper on a specific feature. The official docs are comprehensive and well-maintained. They can feel dense, but now that you have the mental models from this guide, they'll make a lot more sense.

2. Claude's built-in help Type /help in Claude Code or ask Claude itself: "What can you do?" or "How does [feature] work?" Claude is genuinely good at explaining its own capabilities. Treat it as self-documenting.

3. The update log for this guide When Claude or Claude Code changes in ways that affect anything in this guide, we update the guide and note what changed. Check back occasionally — not anxiously, just when you think of it.

That's it. Three places to look. Everything else — the YouTube videos, the Twitter threads, the "100 Claude hacks" posts — is optional. Most of it is repackaged versions of what you already know from this guide. Some of it is useful. A lot of it is noise. You now have the foundation to tell the difference.

Let's take stock. You now have:

• A clear understanding of what Claude is, how it compares to alternatives, and what it costs
• Confident daily use of Claude.ai with five prompting patterns that cover 90% of tasks
• Claude Code installed and running on your computer
• A lean, token-efficient setup with a tested CLAUDE.md and five useful skills
• A framework for knowing when to use which tool
• Guidance tailored to your specific type of work

That's a solid foundation. Most people who use Claude never get here — they either stop at the web app or get lost in the noise. You didn't.

This setup works well. You could stop here and get genuine value from Claude for months.

But there's something you'll notice after a week or two.

You'll start a new session. You'll ask Claude to help with the same project you worked on yesterday. And Claude will have no memory of it. It won't know the decisions you made, the preferences it learned, the feedback you gave it. You'll re-explain your context. Again. And then again the next day.

That's the gap in this setup. The CLAUDE.md tells Claude who you are, but it can't remember what you've done together. It doesn't learn from yesterday. Every session starts fresh, and every fresh start costs you tokens and patience.

The next six modules close that gap. They pick up right where this one ends and build the layers that make Claude feel like it's been working with you for months:

• A comprehensive CLAUDE.md that shapes every conversation (Module 5)
• Skills and commands that give Claude specialised capabilities (Module 6)
• Hooks that automate the boring stuff — backups, safety checks, code validation — without costing a single token (Module 7)
• A memory system that carries context, decisions, and corrections across sessions (Module 8)
• A team of 20 specialist agents Claude can call on when a task needs real depth (Module 9)
• Workflows that chain skills and agents together into multi-step processes (Module 10)

And there's a one-shot setup prompt that installs the entire system. You paste it into Claude Code, answer a few questions, and everything is configured and personalised. You'll find it on the Setup Prompt page.

Keep reading. Same voice, same pace, same honesty.