Master Claude Code
from Scratch

A coding assistant is a tool that sits between you and a language model (like Claude), helping you write, fix, and manage code. It can read your files, run your tests, and make changes — all from a single conversation.

The Core Workflow

Claude Code is Anthropic's official coding assistant built on the Claude language model. You interact with it through the terminal, and it can read files, write code, run commands, and connect to external services.

Why Claude Code?

This is the most important concept to internalize. Language models can only process text. They cannot open a file, run a command, or check a website on their own. Tool use is the mechanism that bridges this gap.

Step-by-Step Breakdown

// 1. You ask:
"What's in my package.json?"

// 2. Claude Code adds instructions to the request:
"If you need to read a file, respond with: READ_FILE: <filename>"

// 3. The language model responds:
READ_FILE: package.json

// 4. Claude Code (assistant layer) actually reads the file

// 5. File contents are sent back to the language model

// 6. Claude reads the content and gives you a real answer

Example 1 — Performance Optimization

Claude analyzed the Chalk JavaScript library (~430M weekly downloads) and achieved a 3.9× throughput improvement:

Example 2 — PII Security Detection

Example 3 — Data Analysis

Point Claude at a CSV of customer data. It opens a Jupyter notebook, writes and runs cells iteratively, identifies churn patterns, and produces charts — all in one conversation.

Claude works best when it understands your project. Too little context gives wrong answers. Too much irrelevant context makes it slower and less accurate. The goal is just enough.

The /init Command

/init

Scans your entire codebase, understands the architecture, and creates a Claude.md file. This file is automatically included in every future request.

Three Types of Claude.md

Example Claude.md

## Project: E-commerce Platform
- Database schema → /db/schema.sql (always reference for DB questions)
- We use PostgreSQL, not MySQL
- Auth handled by /src/auth/middleware.ts
- Never modify files in /vendor/

The @ Symbol — Pinpoint Context

@src/auth/middleware.ts — why is the login token expiring early?

Mention files directly instead of letting Claude search. It's like handing a new employee the exact page they need instead of saying "the answer is somewhere in the wiki."

The # Symbol — Memory Mode

# Always use async/await instead of .then() chains

Immediately updates your Claude.md so Claude remembers this in all future interactions.

Pasting Screenshots — Ctrl+V

Screenshot a broken UI element, paste it, and say "fix the alignment here." No need to describe what you see in words.

Plan Mode — For Breadth

Activate with Shift + Tab (twice). Claude will research all relevant files, build a detailed plan, and only then start making changes. Ideal for multi-file features and refactoring.

Thinking Mode — For Depth

Include phrases like "Ultra think" in your message. Gives Claude an extended reasoning budget for complex logic and subtle bugs.

Ultra think — why does our payment processing occasionally fail
for orders placed exactly at midnight?

When to Use Each Mode

Git Integration

Claude Code can stage files, create commits, and write descriptive commit messages automatically. Just say "commit the changes you just made."

Long conversations accumulate noise that can confuse Claude. These tools keep you focused:

Custom commands let you create your own slash commands to automate repetitive tasks.

How to Create One

Example — /audit Command

Audit all npm dependencies in package.json for known vulnerabilities.
For each vulnerable package:
1. List the package name and current version
2. Describe the vulnerability
3. Suggest the safest upgrade path

Commands with Arguments

Generate comprehensive unit tests for the file at: $arguments

Include tests for:
- Happy path
- Edge cases
- Error handling

/test src/components/Button.tsx

MCP (Model Context Protocol) servers are external tools you plug into Claude Code to give it new capabilities. Think of them as "apps" Claude can use — browsers, databases, design tools, and more.

Installing an MCP Server

# Install the Playwright browser automation server
claude mcp add playwright npx @playwright/mcp

Auto-Approving MCP Tools

{
  "allow": ["MCP__playwright"]
}

Real World — Automated UI Refinement

Claude Code can run directly inside GitHub Actions, triggered by pull requests and issues.

Setup

/install-github-app

This auto-creates two GitHub Actions in your repo:

Hooks are custom scripts that run automatically before or after Claude uses a tool. They let you enforce rules, run checks, and provide automated feedback.

The Two Hook Types

How a Hook Decision Works

Configuration

{
  "hooks": {
    "preToolUse": [
      {
        "matcher": "read|grep",
        "command": "node /absolute/path/to/hooks/read_hook.js"
      }
    ]
  }
}

Hook Script Example

const chunks = [];

process.stdin.on('data', chunk => chunks.push(chunk));
process.stdin.on('end', () => {
  const data = JSON.parse(Buffer.concat(chunks).toString());
  const filePath = data.tool_input?.path || '';

  if (filePath.includes('.env')) {
    console.error('Blocked: .env files are off-limits for security');
    process.exit(2); // Block the tool call
  }

  process.exit(0); // Allow the tool call
});

The Absolute Path Problem

Claude Code recommends absolute paths in hook commands for security (prevents path interception attacks). But absolute paths are machine-specific, making it hard to share settings with your team.

The Solution — Template + Setup Script

Create a settings.example.json template with a $PWD placeholder:

{
  "hooks": {
    "preToolUse": [{
      "matcher": "read|grep",
      "command": "node $PWD/hooks/read_hook.js"
    }]
  }
}

A scripts/init-claude.js setup script replaces $PWD with each developer's actual project path when they run:

npm run setup   # installs deps + generates settings.local.json

Hook 1 — TypeScript Type Checker

The problem: Claude edits a function's signature but forgets to update all call sites, leaving type errors scattered in the codebase.

The solution: A post-tool-use hook that runs tsc --no-emit after every file edit:

const { execSync } = require('child_process');

try {
  execSync('tsc --no-emit', { stdio: 'pipe' });
  process.exit(0);
} catch (error) {
  // Feed type errors back to Claude as feedback
  console.error('TypeScript errors:\n' + error.stdout.toString());
  process.exit(0); // post-hook can't block, but Claude reads the feedback
}

Hook 2 — Duplicate Code Prevention

The problem: In complex multi-step tasks, Claude creates new queries/functions instead of reusing existing ones.

The solution: A post-tool hook launches a second Claude instance via the SDK to check for duplicates when a watched directory is edited.

The Claude Code SDK lets you use Claude Code programmatically — in your own scripts, CI pipelines, and hooks — rather than just through the terminal.

Available for CLI, TypeScript / JavaScript, and Python.

Default Permissions

Basic Usage

import { query } from '@anthropic-ai/claude-code';

const result = await query({
  prompt: 'Refactor getUserById to be async',
  options: {
    allowTools: ['read', 'edit', 'grep'] // explicitly enable write
  }
});

// The final message is Claude's last response
const response = result.messages[result.messages.length - 1];

Best Suited For