Claude Code
Bible

One Analogy Explains Everything

Asking ChatGPT for code is like searching for a recipe. Once you get the recipe, you have to buy the ingredients yourself, cook it, and even do the dishes.

Claude Code is different. It's like hiring a chef. You say, "Make pasta for dinner tonight," and the chef opens the fridge, figures out what ingredients are available, cooks, and sets the table. All I have to do is give feedback like "It's delicious, but a bit salty."

Core Differences — 4 Key Points

Category	ChatGPT / Claude.ai Web	Claude Code CLI
File Access	Paste only	Read, write, and execute directly
Memory	Resets when conversation ends	Permanent memory via CLAUDE.md
Behavior	Generate answers	Plan → Execute → Verify
Extension	None	Direct control of DB, GitHub via MCP

The decisive difference is direct access to the file system. Claude Code directly opens folders on your computer, reads files, modifies them, and executes terminal commands. It's not just that an AI works like a developer—an AI actually works like a developer.

What is an Agent?

Lately, the term "AI agent" is used a lot. Simply put, here's what it means.

Claude Code is a coding agent. When you say "Add unit tests to this API," it reads the code, writes tests, runs them to verify they pass, and automatically repeats the process to fix any failures.

What It Can Do vs. What It Cannot

Prerequisites (5 minutes)

Installation (1 minute)

npm install -g @anthropic-ai/claude-code

Login (2 minutes)

claude

When you run it for the first time, a browser window opens. Log in with your Anthropic account and click the "Allow" button—that's it. Your token is saved on your computer.

First Conversation (2 minutes)

cd my-project-folder
claude

That's all there is to it. Claude Code automatically reads the current folder and enters conversation mode.

Understand this folder structure and explain what kind of project this is.

Claude actually opens the files and explains them. It's magical the first time you see it.

5 Essential Commands to Memorize

Command	Purpose
/clear	Reset conversation context (before starting a new task)
/help	Show all available commands
/context	Check current context window usage
Ctrl+C	Stop Claude's response immediately
Shift+Enter	Line break (Enter sends the message)

"Why do I get weird results when I tell Claude Code to code right away? It's like telling a chef to 'cook' without saying what you want."

Why Order Matters

Mistake #1 when first using Claude Code: telling it to "fix bugs" right away. Then Claude patches the code without even examining it, guessing. It fails. Fix it again. It gets worse.

The 4-Step Golden Workflow

Real Prompts — Copy and Paste

Step 1: Explore Prompt

Understand how [file name or feature] works.
Read related files and explain the current structure.
Don't touch code yet, just analyze.

Step 2: Verify Plan Prompt

How would you implement [desired changes]?
Tell me the plan first — which files to change and how.
I'll start the code modifications when I approve.

Step 3: Implementation Prompt

OK, proceed. Start with [file name].

200000 Check after each file modification to ensure it runs smoothly.

/plan mode — More safely

For complex tasks, I use the /plan mode. In this mode, Claude cannot modify files. I can only make plans.

/plan
# Now Claude can only read, cannot modify
# When I say "okay, let's start," switch to normal mode

"Using Claude Code without CLAUDE.md is like hiring an employee but not explaining the company. I have to explain everything from scratch every time."

What is CLAUDE.md

CLAUDE.md is the first file Claude Code looks for when starting. The content written here is automatically read in every session. Once I write it, I never need to explain again.

CLAUDE.md Golden Template

# Project Name — Claude Behavior Guidelines

## Project Overview
- **Purpose**: [One-line description]
- **Stack**: Python 3.11 / FastAPI / PostgreSQL
- **Port**: 8766 (local), Render deployment

## Core Folder Structure
- `api_server/` — Backend
- `frontend/` — React SPA
- `MASTER.env` — Environment variables (never commit!)

## Coding Rules
- Clear function names over comments
- If there's try/except, always log
- Check existing tests pass before new features

## ⛔ Prohibited Actions (Claude must read)
- Never git push --force
- Never output .env file contents
- Always ask before running rm -rf

## Frequently Used Commands
- Start server: `python local_agent_server.py`
- Test: `pytest tests/ -v`
- Security check: `python git_security_check.py`

## Past Mistakes — Never repeat
- [2026-05] Korean path subprocess encoding error
  → Solution: Always set PYTHONUTF8=1
- [2026-05] MCP 204 empty response parsing error
  → Solution: Check content length first

CLAUDE.md Deployment Strategy

What is MCP?

Model Context Protocol. Don't overthink it. One-line summary:

Installing MCP — One Command

claude mcp add supabase -- npx -y @supabase/mcp-server-supabase@latest \
  --access-token my_Supabase_token \
  --project-ref my_project_ref

claude mcp add github -- npx @modelcontextprotocol/server-github \
  --token my_GitHub_token

claude mcp list

Major MCP Server List

Server	Main Functions
Supabase	PostgreSQL queries, migrations, Edge Function deployment
GitHub	Create PRs, query issues, search code, manage branches
Playwright	Actual browser control, screenshots, scraping
Figma	Read designs, Code Connect, auto-generate mockups
Context7	Real-time latest library official documentation lookup
Linear	Issue creation, sprint management, task tracking

How to Manage with Configuration Files

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": [
        "-y",
        "@supabase/mcp-server-supabase@latest",
        "--access-token", "sbp_XXXXXXXXXX",
        "--project-ref", "XXXXXXXXXX"
      ]
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-playwright"]
    }
  }
}

What are Hooks?

When Claude modifies a file, when Claude executes a Bash command, when Claude completes a response — at these moments, I can automatically run shell commands I want. That's Hooks.

5 Hook Event Types

Event	When it runs	Use cases
PreToolUse	Right before tool execution	Block dangerous commands, log activity
PostToolUse	Right after tool execution	Run tests automatically, lint check
Notification	When notification occurs	Send to Slack/Telegram
Stop	Claude response completes	Sound alert, auto-commit
SubagentStop	Subagent completes	Trigger next step in pipeline

Setup Method

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "pytest tests/ -x -q 2>&1 | tail -8"
          }
        ]
      }
    ],
    "Stop": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "powershell -c \"[console]::beep(880, 400)\""
          }
        ]
      }
    ]
  }
}

5 Copy-Paste Recipes

① Auto-test after file modification

"command": "python -m pytest tests/ -x -q 2>&1 | tail -5"

② Sound alert when task completes (Windows)

"command": "powershell -c \"[console]::beep(800,300)\""

③ Send Telegram notification

"command": "python /tools/telegram_notify.py \"Claude task complete!\""

④ Block rm -rf (PreToolUse)

"command": "python /tools/bash_safety_check.py"

⑤ Auto git stage after file modification

"command": "git add -u"

"If Claude alone handles 26 rounds of the Shixuan AGI loop, it takes hours. When I parallelized it with multi-agent, it finished in under an hour."

Orchestrator Pattern

Claude A (orchestrator) understands the overall goal and delegates tasks by dividing them among multiple Claude B, C, D. Each sub-agent works on its own task in an isolated context. Once everything is complete, the orchestrator consolidates the results.

How to Run Parallel Tasks in Claude Code

Process these 3 things in parallel:
1. Security vulnerability review for api_server/ (Agent 1)
2. Performance optimization points analysis for frontend/ (Agent 2)
3. Coverage analysis for tests/ (Agent 3)

Analyze each independently, and once done, create a comprehensive report.

Agent SDK — Build Teams in Code

With Anthropic Agent SDK, I can build multi-agent systems in code. This is the core of JANDA Shixuan AGI.

import anthropic

client = anthropic.Anthropic()

# Sequential pipeline: pass diagnosis results to the next agent
def run_pipeline(task: str):
    # Agent 1: Code review (Haiku — fast and cheap)
    review = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=1024,
        system="Code review expert. Find only bugs and security vulnerabilities.",
        messages=[{"role": "user", "content": task}]
    )

    # Agent 2: Receive review results and write improvement plan (Sonnet)
    solution = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2048,
        system="Improvement plan expert. Provide specific code.",
        messages=[
            {"role": "user", "content": task},
            {"role": "assistant", "content": review.content[0].text},
            {"role": "user", "content": "Based on the above review, write improved code"}
        ]
    )
    return solution.content[0].text

# ── To actually run independent tasks in parallel, use asyncio ──
import asyncio, anthropic

async def run_parallel(tasks: list[str]):
    client = anthropic.AsyncAnthropic()
    async def call(t):
        r = await client.messages.create(
            model="claude-haiku-4-5-20251001", max_tokens=512,
            messages=[{"role": "user", "content": t}]
        )
        return r.content[0].text
    return await asyncio.gather(*[call(t) for t in tasks])

SDK Installation

pip install anthropic python-dotenv

Basic Message Sending

import anthropic
import os
from dotenv import load_dotenv

load_dotenv("MASTER.env")

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

response = client.messages.create(
    model="claude-sonnet-4-6",     # default model
    max_tokens=1024,
    system="Answer only in Korean.",
    messages=[
        {"role": "user", "content": "Create 3 blog titles for today. Return as JSON array."}
    ]
)

print(response.content[0].text)

Model Selection — When to Use What

Model	When to Use	Cost
claude-haiku-4-5-20251001	Classification, scoring, short responses, fast processing	Cheapest
claude-sonnet-4-6	General development, analysis, long responses (default)	Mid-range
claude-opus-4-7	Strategic decisions, complex reasoning	Most expensive

Streaming Response

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Write a long report"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Tool Use — Give Claude Functions

tools = [{
    "name": "search_naver_local",
    "description": "Search business info using Naver Local Search API",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Search term (e.g., Gangnam study cafe)"}
        },
        "required": ["query"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=512,
    tools=tools,
    messages=[{"role": "user", "content": "Find Pilates businesses in Gangnam"}]
)

# When Claude returns a tool_use block, execute the actual function
for block in response.content:
    if block.type == "tool_use":
        result = search_naver_local(block.input["query"])
        # Pass result back to Claude to have it summarize

"I was spending 3 million won per month on outsourced development. After adopting Claude Code, API costs are 50,000 won per month. Output volume is 3x."

What We Built

Sihwang AGI — Self-Coding in Action

Sihwang AGI starts on its own every night at 00:30, improves its code automatically, and finishes at 07:00. I don't have to do anything.

CLAUDE.md Made It All Possible

## Sihwang AGI File Safety Rules (v3.3 — 2026-05-14)

| Rule | Details |
|------|---------|
| confidence < 55 | Skip — Retry with reduced scope (1 attempt) |
| Cooldown Threshold | 1 hour from last attempt (prevent loops) |
| Import Validation | Reflect only after subprocess execution |
| Overnight Modifications | Via code_patcher only, no direct edits |
| Target Success Rate | 100% — All valid attempts must have patched=True

These rules live in CLAUDE.md and are injected into Claude every session. They're the safety protocols I follow when AI modifies AI code.

Core Lessons — Looking Back After 6 Months

If you've read this book, you're already prepared. Now it's just a matter of actually doing it. Your first project is the fastest way to close the gap between knowing and doing.

3 Projects to Start Right Now

Reading about something and actually using it are completely different. When you're reading, it all seems to make sense. The moment you open the terminal, your mind goes blank. The fastest way to bridge that gap is with one small project. Do them in order, one at a time.

Claude Code Ecosystem — The Future

---

Services I built directly with Claude Code

Claude Code Bible 2026 — Author Kim Hwa-hyun · Co-author Road
AI Hunter Channel · ceo@stayjanda.com
Collaboration and suggestions · ceo@stayjanda.com

🐛 Bug Fix Patterns

I'm getting this error. Find the cause and fix it.
Explain the cause before touching the code.

[Paste entire error message]

File: [filename]

[Function name] is giving me [symptom].
Input: [example input]
Expected output: [what I expect]
Actual output: [what I'm getting]

Read the code and find the cause. Tell me your hypothesis before fixing.

[Feature name] sometimes breaks. Not always, but [frequency/condition].
The logs show:
[Log content]

Check if it's a race condition or timing issue.
Read all related code and find suspicious points.

🔨 New Feature Patterns

Read the current [module name] code.
I want to add [feature description].
Where and how should I attach it to the existing structure so it feels natural?
Plan only—no code changes until I say OK.

Add [endpoint path] endpoint to FastAPI.
- Method: [GET/POST/PUT]
- Input: [parameter description]
- Output: [return value description]
- Auth: [yes/no]

Read the existing router file [filename] and match that style.

Write a query to fetch [condition] data from [table name].
Current DB connection method is in [filename].
Match the style of existing query functions.

♻️ Refactoring Patterns

[Function name] in [filename] is too long.
Read it and suggest how to break it up.
Must keep existing functionality identical before and after.

[FilenameA] and [FilenameB] have similar code.
Read both and find parts that can be extracted into a shared function.
Minimize changes.

Read [filename]. Don't change functionality.
Just rename variables and function names to be clearer.
Show me the rename list first, and I'll confirm before applying.

✅ Test Writing Patterns

Write pytest tests for [function name] in [filename].
- 3 normal cases
- 2 edge cases (None input, empty values, etc.)
- 1 exception case

Read the existing test file [tests/filename] and match that style.

Read [filename] entirely.
Pick the 3 most important functions in this file.
Write at least 2 test cases for each.
Write tests first, then run them to confirm they pass.

🔍 Code Understanding Patterns

I don't understand how the [feature name] part of this project works.
Read through [related folder/file name]
and explain the data flow to me in order. Don't touch the code.

I don't understand what this part does in [file name] lines [line number]~[line number].
Explain the reasoning behind why it was written this way.
Make it understandable even for non-developers.

Where will changes to [file name/function name] have an impact?
Find the files that import or call this file.
After I understand the scope of impact, I'll make the modifications.

🚀 Performance Optimization Patterns

[Function name] in [file name] is slow. It takes an average of [time]ms.
Read the code and find the bottleneck.
Focus on indexing, N+1 queries, and unnecessary loops.

[Function name] in [file name] runs sequentially, which is slow.
Check if we can switch it to async/parallel processing.
Read the current code and suggest improvements using asyncio or ThreadPoolExecutor.

📝 Documentation Patterns

Read through this entire project.
Write a GitHub README.md for me.
- Project description (1~2 lines)
- Installation method
- Usage (with examples)
- Environment variable list
Make it readable for non-developers.

Read [file name].
Find public functions without docstrings
and add docstrings in Args/Returns/Raises format.
Don't touch the function logic.

🔐 Security Patterns

Read [file name].
Check for vulnerabilities from these 4 perspectives:
SQL injection, XSS, authentication bypass, sensitive data exposure.
If you find any, tell me the severity level (high/medium/low) and how to fix it.

Find any hardcoded API keys or passwords in this project.
Create a list of things that can be replaced with os.getenv().
Don't output the actual values.

🤝 Collaboration Patterns

Here's the result of git diff [branch name]..HEAD:
[diff content]

Write a GitHub PR description for these changes.
- Summary (what changed and why)
- Testing method
- Cautions
Use markdown format.

Here's the result of git diff --staged:
[diff content]

Write a commit message in Conventional Commits format.
Choose the appropriate type from feat/fix/refactor/docs.

🐍 Python-Specific Patterns

Read [file name].
Add type hints to functions without them using Python's typing module.
Don't change the function behavior, only the types.

[Function name] in [file name] has insufficient error handling.
Analyze what exceptions could occur
and add try/except + logging. Silent fails are prohibited.

⚡ Automation Patterns

I do [task description] manually every day.
Create a Python script to automate this.
- Input: [data source]
- Processing: [logic]
- Output: [result]
Read keys from MASTER.env.

I want [script path] to run automatically every day at [time].
Tell me how to set it up in Windows Task Scheduler or Linux cron.
How do I get a Telegram notification if it fails?

🔧 Debugging Patterns

Here's a log. Find what's wrong with it.
[log content]

Focus on timestamp patterns, error patterns, and unusual values.

When I run [command], I get this:
[execution result]

It works locally but not on the server.
Find the cause of the environment difference. Focus on OS, Python version, and package version differences.

📊 Data Patterns

This is the JSON structure:
[JSON sample]

Write code that extracts only [desired data] and converts it to [output format].

The data I receive from [file name] is sometimes malformed.
Add code that validates it matches [expected schema].
If malformed data comes in, log it and skip it.

---

⌨️ Complete Slash Command List

Commands you can enter anytime during a Claude Code conversation. This one table is all you need.

Command	When to Use	Description
/help	When starting out	View complete list of available commands
/clear	Before starting new task	Completely reset conversation context (resets cost & quality)
/compact	When conversation gets long	Compress conversation into summary. Saves tokens while maintaining flow
/context	Check context	Check current remaining context window usage
/model	When switching models	Switch between Opus / Sonnet / Haiku
/config	Check settings	Display current settings status
/cost	Check cost	Check current session token usage and cost
/quit · /exit	Exit	Exit Claude Code

"You don't need to repeat the mistakes I made. I already paid enough for them."

Mistake #1 — Asking to "Fix it" without exploration

Mistake #2 — Starting new task without /clear

Mistake #3 — Throwing a huge task at once

Mistake #4 — Committing .env file to git

.env
*.env
MASTER.env
.env.local
.env.production
secrets.json
*_credentials.json
token*.pickle

Mistake #5 — Starting development without CLAUDE.md

Mistake #6 — "Build it well" without success criteria

Mistake #7 — Not recording failures

Mistake #8 — Deploying without validation

Mistake #9 — Token waste

Mistake #11 — Leaving Claude stuck in a loop

Mistake #12 — Not knowing your context window is exhausted and continuing anyway

Mistake #10 — Believing everything Claude says 100%

💰 Part A — Practical cost savings guide

Claude Code with claude.ai Pro plan ($20/month) has no separate CLI costs. However, if you build a bot that calls the API directly, token costs accumulate. Here's how to manage it.

Cost by model & appropriate use cases

Model	Relative Cost	When to Use	When NOT to Use
Haiku 4.5	★☆☆ Cheap	Scoring, classification, short responses, repetitive loops	Long code generation, complex reasoning
Sonnet 4.6	★★☆ Medium	General development, analysis, code generation (default)	Simple classification, short summaries
Opus 4.7	★★★ Expensive	Strategic decisions, architecture design	Everyday coding tasks

Cutting Costs Through Context Management

import anthropic

client = anthropic.Anthropic()

# ✅ Scoring: Haiku + token limit
def score_lead(item: dict) -> int:
    resp = client.messages.create(
        model="claude-haiku-4-5-20251001",  # cheap model
        max_tokens=50,                        # just return a number
        system="Return only a number. 0–100.",
        messages=[{"role": "user", "content": f"This vendor's subscription likelihood: {item}"}]
    )
    return int(resp.content[0].text.strip())

# ✅ Code generation: Sonnet + reasonable tokens
def generate_code(spec: str) -> str:
    resp = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2048,          # be generous for code generation
        messages=[{"role": "user", "content": spec}]
    )
    return resp.content[0].text

---

🖥️ Part B — VS Code Integration Complete Guide

Using Claude Code alongside VS Code is much faster than the terminal alone.

Installation & Getting Started

What You Can Only Do in VS Code

Recommended VS Code Settings

{
  "editor.formatOnSave": true,
  "terminal.integrated.defaultProfile.windows": "PowerShell",
  "files.autoSave": "afterDelay",
  "files.autoSaveDelay": 1000,
  "git.autofetch": true,
  "editor.minimap.enabled": false  // Use screen space more efficiently
}

---

🌿 Part C — Claude Code + Git in Practice

How to Let Claude Code Handle Git Operations

I'll start developing the new feature [feature name].
Create a feature/[feature name] branch using git checkout -b.
After development is complete, write commit messages in Conventional Commits format.

Check what I've changed so far with git diff
and commit them divided into meaningful units.
Use feat/fix/refactor for each commit message as appropriate.

Automatic Security Check → Commit Integration

#!/bin/bash
# Automatically check for .env file inclusion before commit
if git diff --cached --name-only | grep -E "\.env$|MASTER\.env|secrets\."; then
  echo "❌ Security files are staged. Please exclude them with git reset HEAD ."
  exit 1
fi
echo "✅ Security check passed"

GitHub Actions + Claude (Advanced)

name: AI Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Claude Code Review
        run: |
          # Send PR diff to Claude API to auto-generate review comments
          # Combination of anthropic SDK + GitHub API
          python scripts/ai_review.py

---

🔒 Part D — Security Practice Guide

The more I use Claude Code, the higher the probability of security mistakes. Being careful about .env is basic, but I need to take care of these too.

Scan this entire project for me.
Find any hardcoded API keys, passwords, or tokens.
Don't output actual values—just tell me the file names and line numbers.

---

👥 Part E — Team Collaboration Guide

Using Claude Code alone is different from using it in a team. When I share CLAUDE.md, the entire team can work with the same context.

# Team Project CLAUDE.md

## Coding Principles
- Python functions: snake_case
- API responses: always declare types with TypedDict
- Errors: must log before raising

## Do Not Touch
- db/migrations/ — DBA only
- auth/jwt.py — modify after security team approval

## PR Rules
Commit messages: choose from feat/fix/refactor/docs
PR scope: 1 feature, 5 file changes or fewer

## Environment Variables
All keys referenced in .env.example. Actual values issued via team Notion.

---

🪟 Part F — Windows-Specific Tips

Most Claude Code tutorials are Mac/Linux-focused. When working on Windows, you hit unexpected blockers. If you're a domestic user, you absolutely need to know these.

# Prevent Korean text corruption
$OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8

# Check Node.js version (v18+ required)
node --version

# Run Claude Code
claude

* text=auto
*.py text eol=lf
*.js text eol=lf
*.json text eol=lf