Advanced Claude Code Techniques: Master Pro-Level Patterns

1. Context Engineering: The Meta-Skill

Context is everything in Claude Code. The quality of your output is directly proportional to the quality of your context. This section teaches you to engineer context like a pro.

Understanding the Context Window

Claude Code has a 200K token context window. Think of it as RAM for your AI assistant:

What Consumes Context?

Not all actions are equal. Here's the real cost breakdown:

Interactive Context Visualizer

Use this interactive tool to visualize how different activities consume your 200K token context window:

Context Depletion Symptoms

Learn to recognize when context is running low:

The Compact Command Deep Dive

When you run /compact, Claude:

1. →Summarizes the conversation so far
2. →Preserves essential info (project structure, current task, recent decisions)
3. →Discards verbose details (old diffs, lengthy outputs, resolved discussions)
4. →Frees typically 40-60% of context

2. Session vs. Persistent Memory

Claude Code has two distinct memory systems. Understanding the difference is crucial:

The CLAUDE.md Power Pattern

CLAUDE.md is your persistent project memory. Claude reads it automatically on every launch.

# CLAUDE.md

## Project: E-Commerce Platform
Tech stack: Next.js 14, TypeScript, Prisma, PostgreSQL

## Decisions Made
- JWT auth (not sessions) for horizontal scaling
- Server Components by default, Client only when needed
- All API routes return Result<T, AppError> pattern

## Coding Standards
- No `any` types - use `unknown` with type guards
- All functions must have JSDoc comments
- Tests required for all business logic

## Current Sprint Focus
- User authentication system (70% complete)
- Next: Implement refresh token rotation

Build Your Perfect CLAUDE.md

Use this interactive editor to create a customized CLAUDE.md for your project. Choose from templates and customize to your needs:

Session Handoff Pattern

When ending a session, create a handoff document to maintain continuity:

# Session Handoff - 2025-01-15 18:00

## Accomplished
- Implemented JWT access token generation
- Added /auth/login endpoint
- Created User model with Prisma

## Current State
- Login works for valid credentials
- Refresh tokens: NOT YET IMPLEMENTED
- Tests: 80% coverage on auth module

## Next Session
1. Implement refresh token generation
2. Add token rotation on refresh
3. Write integration tests for full flow

## Key Files
- src/auth/tokens.ts (main logic)
- src/routes/auth.ts (endpoints)
- prisma/schema.prisma (User model)

3. XML-Structured Prompts

For complex requests, XML tags provide semantic organization that helps Claude distinguish between instructions, context, and constraints.

Basic Structure

<instruction>
  Your main task description here
</instruction>

<context>
  Background information, project details
</context>

<constraints>
  - Limitation 1
  - Requirement 2
</constraints>

<output>
  Expected format or structure
</output>

When to Use XML Tags

Real-World Example

Here's a production-quality prompt for security review:

<instruction>
Review this authentication middleware for security vulnerabilities
</instruction>

<context>
Financial application handling sensitive user data.
Must follow OWASP Top 10 and PCI DSS compliance.
</context>

<code>
async function authenticate(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ error: 'No token' });
  
  const decoded = jwt.verify(token, process.env.JWT_SECRET);
  req.user = decoded;
  next();
}
</code>

<constraints>
- Point out security risks with severity ratings
- Consider timing attacks and token leakage
- Suggest PCI DSS compliant alternatives
</constraints>

<output>
1. Security issues found (Critical/High/Medium/Low)
2. Specific code fixes with examples
3. Additional hardening recommendations
</output>

4. Semantic Anchors

Semantic anchors are precise technical terms that activate specific patterns in Claude's training data. Vague terms produce generic code; precise anchors produce expert-level implementations.

The Precision Difference

How to Apply Semantic Anchors

Add them to your CLAUDE.md:

# Architecture Principles

Follow these patterns explicitly:
- **Architecture**: Hexagonal Architecture (Ports & Adapters)
- **Error handling**: Railway Oriented Programming - return Result<T, E>
- **Testing**: TDD London School - mock collaborators, test behaviors
- **Documentation**: ADR (Architecture Decision Records) for choices

Or use them inline:

Refactor the user service following Domain-Driven Design (Evans).
Apply Repository pattern for persistence and ensure 
Screaming Architecture where package structure reveals intent.

5. Plan Mode & OpusPlan

Plan Mode is Claude Code's "look but don't touch" mode—essential for safe exploration and strategic thinking.

Entering Plan Mode

/plan

Or simply ask Claude:

Let's plan this feature before implementing

What Plan Mode Allows vs. Prevents

OpusPlan Mode: Best of Both Worlds

OpusPlan uses Opus for planning (superior reasoning) and Sonnet for implementation (cost-efficient).

/model opusplan

The Workflow:

6. Rev the Engine

For critical decisions, run multiple rounds of planning before executing.

The Pattern

Standard workflow: think → plan → execute

Rev the Engine: think → plan → think harder → refine → think hardest → finalize → execute

When to Use

• →Critical architectural decisions (irreversible, high-impact)
• →Complex migrations affecting 10+ files
• →Unfamiliar domains where first instincts are often wrong

Three-Round Example

## Round 1: Initial Analysis
User: /plan
User: Analyze the current auth system. What are the key components,
      dependencies, and risks of migrating to OAuth2?
Claude: [Initial analysis]

## Round 2: Deep Challenge
User: Now challenge your own analysis:
      - What assumptions did you make?
      - What failure modes did you miss?
      - What would a senior security engineer flag?
Claude: [Deeper analysis with self-correction]

## Round 3: Final Plan
User: Based on both rounds, write the definitive migration plan.
      Include rollback strategy and risk mitigation.
Claude: [Refined plan incorporating both rounds]

## Execute
User: /execute
User: Implement the plan from round 3.

7. Cost Optimization

Claude Code uses API credits. Understanding costs helps optimize without sacrificing productivity.

Pricing Reality Check

Typical session costs:

• →Quick task (5-10 min): $0.05-$0.10
• →Feature work (1-2 hours): $0.20-$0.50
• →Deep refactor (half day): $1.00-$2.00

The Expensive Operations

Cost Optimization Strategies

Track Your Costs

Check current session cost anytime:

/status

Output:

Session Status
───────────────────────────────────────────────
  Context:  45% used (90K / 200K tokens)
  Cost:     $0.23 this session
  Duration: 1h 23m
───────────────────────────────────────────────

8. Prompting as Provocation

The Claude Code team internally treats prompts as challenges to a peer, not instructions to an assistant. This subtle shift produces higher-quality outputs.

Three Provocation Patterns

9. Fresh Context Pattern

For long autonomous runs, consider the Fresh Context Pattern (also called the Ralph Loop).

The Problem: Context Rot

Research shows LLM performance degrades with accumulated context:

• →20-30% performance gap between focused and polluted prompts
• →Degradation starts around 16K tokens
• →Failed attempts and error traces dilute attention

The Solution

Instead of managing context within a session, restart with a fresh session per task:

# The Ralph Loop
while :; do cat TASK.md PROGRESS.md | claude -p ; done

State persists via:

• →TASK.md — Current task definition
• →PROGRESS.md — Learnings, completed work, blockers
• →Git commits — Each iteration commits atomically

When to Use Fresh Context

10. Advanced Workflows Summary

The Expert's Decision Tree

Is this a simple, reversible change?
├── YES → Just execute (no planning overhead)
└── NO → How impactful is this decision?
    ├── Medium → Plan Mode + Execute
    ├── High → OpusPlan (Opus thinks, Sonnet implements)
    └── Critical → Rev the Engine (3 rounds) + OpusPlan

Quick Reference

What's Next?

You now have the advanced techniques that separate power users from beginners. Practice these patterns and they'll become second nature.

Continue to Module 1 for hands-on exercises applying these techniques to real projects.

This article is part of the Claude Code Ultimate Guide series. Continue your journey with Module 1: Core Techniques for deeper practice.