Launch Claude Code from the project root

Claude Code uses the current directory as its starting point. Launching from the root gives it the full picture: file structure, package.json, configs.

# Correct
cd ~/projects/my-app && claude

# Wrong — Claude only sees part of the project
cd ~/projects/my-app/src/components && claude

Run /init first

This command analyzes the project and creates CLAUDE.md — an instruction file with build commands, tests, and key directories. Run it when first using Claude Code in a new project.

CLAUDE.md — a hierarchical system

Works on three levels:

Keep CLAUDE.md concise — under 300 lines

Every line means tokens on every request. A bloated file increases cost, dilutes instructions, and slows down responses.

Rule: if an instruction does not improve output quality, remove it.

Structure: What + Domain + Validation

Three sections of an effective CLAUDE.md:

• What — what the project does, stack, architecture
• Domain — business logic, terminology, patterns
• Validation — build, test, lint commands for self-verification

The Validation section is the most important. It gives Claude a self-correction loop.

Hotkeys

Screenshots as context

Claude Code accepts images: drag and drop a screenshot into the terminal or specify the file path. Add text explanations to improve diagnostic accuracy.

/clear — your main command

Switching to a new task? Reset the context. Fresh context always works better than a bloated one.

Rule: one task — one context. Switched tasks? Clear the context.

/context — token audit

Shows context window distribution: system prompt, MCP servers, CLAUDE.md, history. If an MCP server consumes 30% of the window, reconsider whether you need it.

Key commands

Auto-compaction works automatically — trust the built-in context optimization mechanism.

Git — your safety net

Commit before major changes. If Claude goes off track, a single git checkout . brings everything back. Small, frequent commits are best practice.

Critical Rules section

At the top of CLAUDE.md, put absolute rules using NEVER and ALWAYS:

## Critical Rules
- NEVER modify files in /config/production/
- ALWAYS run tests before committing
- NEVER use `any` type in TypeScript
- ALWAYS include error handling in API routes

Ask Claude to update CLAUDE.md

Instead of editing manually, give Claude the task. This is compound engineering: every session improves future sessions.

Workflow triggers

Map commands to scripts in CLAUDE.md:

## Workflows
- "build the project" → npm run build
- "run tests" → npm test -- --coverage
- "deploy" → ./scripts/deploy.sh --staging

Git + security

Commit CLAUDE.md — it is part of the project, not a personal setting. Version control, team collaboration, knowledge accumulation.

--dangerously-skip-permissions — only for disposable containers and CI/CD. Never on your work machine.

Plan Mode First — always

The most important workflow tip:

1. Switch to Plan Mode (Shift+Tab twice)
2. Describe the task and discuss the approach
3. Iterate on the plan until it is clear
4. Switch to Normal Mode and implement

When the context is clear, implementation often succeeds on the first try.

Fresh context > bloated context

Second brain and lazy loading

Before ending a session, ask Claude to write down all important decisions in CLAUDE.md. This way knowledge is not lost.

Lazy loading: do not load all files in advance. Specify the entry point, and Claude will determine what it needs to read on its own.

Verification commands — self-correction loop

The most important tip according to the author. Add to CLAUDE.md:

## Verification
- Build: npm run build
- Test: npm test
- Lint: npm run lint
- Type check: npx tsc --noEmit

After ANY code change, run build + test to verify.

Claude will automatically verify and fix its own code.

Opus for complex tasks + thinking blocks

Use /model opus for complex refactors and architectural decisions. Read thinking blocks — phrases like "I'm not sure..." indicate Claude's uncertainty.

Four composable primitives

All Claude Code extensibility is built on four blocks:

Skills, Commands, and MCPs

Skills are Markdown files in .claude/skills/ with instructions for frequent operations.

Commands are now merged with Skills. Do not create them manually — ask Claude.

MCPs connect Claude to GitHub, databases, monitoring. Ask Claude to install the MCP you need.

Subagents and instruction quality

Subagents are independent agents with a separate context window for parallel tasks.

Do not overload Claude with instructions: 5 key rules are better than 50 minor ones. Claude already knows best practices.

Parallel work

Running multiple Claude Code instances simultaneously is the most powerful technique:

• iTerm: Cmd+D — split, Cmd+[/] — navigation
• Git worktrees: separate working trees for each instance
• Notifications: sound alerts when tasks complete

# Create separate working trees
git worktree add ../app-feature-a feature-a
git worktree add ../app-feature-b feature-b

/chrome — browser automation

Claude Code can control the browser: navigation, clicks, form filling, DOM inspection, screenshots. Use cases: UI testing, scraping, automation.

Hooks — action interception

Scripts that run before (PreToolUse) or after (PostToolUse) Claude's actions:

• Auto-format: Prettier after every file
• Blocking: prohibit rm -rf, DROP TABLE, force-push
• Logging: record actions for audit

Plugin ecosystem

A growing ecosystem: thousands of MCP servers on GitHub, curated lists, community skills. Use composable primitives through extensions.

Context is King

The main principle. Five layers of context:

1. CLAUDE.md — static (rules, instructions)
2. Prompt — dynamic (current task)
3. Files — code (project state)
4. MCP — external (APIs, data)
5. History — historical (previous decisions)

Claude needs exactly what it needs. And nothing more.