Claude Code overview

Status: 🟩 COMPLETE (🟦 LIVING — Claude Code ships changes weekly) Last updated: 2026-06-19 Plain-English tagline: A first orientation — what Claude Code IS, how it differs from other AI tools, what installing + running it actually looks like, and where to learn more.

---

In plain English

Claude Code is Anthropic’s command-line AI coding assistant. You install it on your machine, run it from any project folder, and have a conversation with Claude that can READ your files, WRITE files, run commands, install packages, run tests, search the web, and do almost anything you’d do at the keyboard — all under your supervision.

It’s not the same as:

• The Claude API — a programmer’s interface for sending messages to a Claude model. Claude Code uses it internally; you usually don’t touch it directly.
• claude.ai (the web app) — a chat interface for general conversation. No file access; no terminal access; one-shot answers.
• GitHub Copilot / Cursor inline autocomplete — code suggestions as you type. Different shape — Claude Code is conversational + agentic.

The closest analogy: a remote senior engineer who can SEE your project, runs commands when needed, and asks before doing anything destructive. The “agent” aspect is real — Claude Code can take many steps autonomously: read 10 files, edit 3, run the test suite, see the failure, fix the bug, re-run, confirm green.

For Bible Quest-style projects, Claude Code is the primary daily AI tool. It runs everything from “scaffold a new feature” to “review my changes” to “explain this error.” Without it, the workflow would be dramatically slower.

This entry is the LIGHT introduction. For the deep dive — memory system, hooks, plugins, settings.json, slash commands, etc. — see Claude Code deep dive and the rest of Section 11.

---

Why it matters

Three concrete reasons Claude Code is foundational:

1. It collapses the gap between asking and doing. Old workflow: ask ChatGPT how to do something → copy answer → paste into your editor → try it → debug. Claude Code: ask, it does, you review. Often a 10× speedup on routine tasks.

2. It REMEMBERS. Memory files (CLAUDE.md, ~/.claude/...) persist across sessions. The playbook George built over months is loaded automatically in every future conversation. No re-explaining the project on day 50 of a project.

3. It runs commands. Unlike chat-only AIs, Claude Code can run npm install, run tests, run git push. With safety prompts. The “see for itself whether the code works” loop is closed.

The trade-off: Claude Code costs money (Anthropic’s Pro plan or usage-based API billing). For solo developers shipping consistently, the speedup is dramatically worth the spend. For users who tinker rarely, the free chatbot may be enough.

---

How Claude Code differs from claude.ai

The same Claude model underneath. The wrapper changes everything:

Aspect	claude.ai (web)	Claude Code (CLI)
Where it runs	Browser tab	Your terminal
File access	Upload one at a time	Reads any project file directly
Code execution	Sandboxed; can’t touch your machine	Runs commands on your machine (with approval)
Memory	Per-conversation (web) or specific Projects feature	Persistent files (CLAUDE.md, memory folder)
Git integration	No direct access	Full — reads diffs, creates commits, opens PRs
Multi-file edits	One file at a time	Many files at once, with atomic transactions
Cost	Free tier, Pro ($20/mo),Max($200/mo)	Same tiers; usage-based via API for power users
When to use	Quick questions, document writing, brainstorming	Building software, refactoring, debugging

For software work specifically: Claude Code wins. For quick prompts when you’re away from your editor: claude.ai wins.

---

What you can ask it to do

A non-exhaustive list of typical requests:

Coding

• “Add a contact form to the Bible Quest home page”
• “Refactor lib/auth.ts to use Supabase’s server-side helpers”
• “Convert this component from class to function component”
• “Why is this test failing?”
• “Add TypeScript types to this file”

Project navigation

• “Where is the user signup flow handled?”
• “Show me everywhere prisma.users.create is called”
• “What does the useAuth hook actually do?”

Tooling & ops

• “Set up ESLint with the recommended Next.js config”
• “Add a GitHub Action to run tests on every PR”
• “Investigate why the build failed on Vercel”

Research

• “What’s the difference between Server Actions and API routes?”
• “Find the latest stable version of Tailwind”
• “Read this Stripe API doc and explain the webhook signing”

Git & PRs

• “Commit my changes with a sensible message”
• “Create a PR for this branch”
• “Review my current diff and suggest improvements”

Most of these one-line requests trigger 5-50 internal steps (read files, search, edit, test, iterate). Claude Code handles the orchestration; you watch the work.

---

A first-run experience

Installing Claude Code, day one:

# 1. Install (npm-based)
npm install -g @anthropic-ai/claude-code
 
# 2. Run from your project folder
cd C:\Users\georg\st-marks-bible-quest
claude
 
# 3. First-time auth flow
# Claude Code opens a browser tab; you log in with Anthropic
# Returns a token; CLI is now authenticated

Then you’re in a prompt. Type a request:

> Show me what files changed in the last 5 commits

Claude reads the git log, summarizes. Next:

> Add a "Loading…" placeholder to the lessons page

It opens the relevant file, makes an edit, shows you the diff, asks before saving. You approve. Done.

Type /help to see built-in slash commands. Type Ctrl+C to interrupt; Ctrl+D to exit.

---

The two memory mechanisms

For the deep version, see Claude Code memory system. The short version:

1. CLAUDE.md files (per-project)

A file named CLAUDE.md at the root of your project is AUTO-LOADED into every conversation. It’s the “things Claude should always know about this project” file:

# Bible Quest
 
## Stack
Next.js 16 + Supabase + Vercel. Functions pinned to syd1.
 
## Conventions
- Server actions for mutations
- shadcn/ui components
- RLS on all tables
 
## Don't
- Use any client-side service role keys
- Modify migrations in past commits

Update it as the project evolves. It’s the readme for Claude.

2. Global memory files (~/.claude/)

The folder ~/.claude/projects/<project-name>/memory/ holds memory files that persist across ALL conversations in that project. George uses these heavily — the playbook, the project state, the encyclopedia coordinates, feedback loops.

~/.claude/CLAUDE.md is the GLOBAL CLAUDE.md — loaded for every project, regardless of where you run Claude Code.

These two layers combine: global rules + project rules. Both are read before every conversation. The result: Claude knows George doesn’t code, knows the playbook, knows Bible Quest specifically, knows the encyclopedia — without anyone having to say it.

---

A concrete example: a typical Bible Quest session

cd C:\Users\georg\st-marks-bible-quest
claude

George types:

> The lesson card on the home page looks cramped on mobile. Make it 
  feel more breathable, but keep the desktop layout the same.

Claude:

1. Reads app/page.tsx to find the lesson card
2. Reads the relevant component file
3. Looks at the current Tailwind classes
4. Proposes specific changes (more padding, better mobile-first stacking)
5. Shows George the diff
6. George approves
7. Claude applies the edit
8. Claude offers to run npm run dev so George can verify

George opens the browser, looks at mobile + desktop, says:

> Good. Commit and push.

Claude:

1. Stages the file
2. Drafts a commit message
3. Commits
4. Pushes
5. Watches Vercel for the deploy result

George never typed git commands, never opened the terminal manually, never wrote Tailwind classes. The whole loop took 5 minutes.

This is the daily workflow. Multiply by 10-20 such requests per session, hundreds of sessions, and the productivity gain compounds enormously.

---

What runs autonomously vs what asks first

Claude Code has a permission system. Different action types prompt at different times:

Action	Default behavior
Reading a file	Allowed silently
Searching code	Allowed silently
Running read-only commands (ls, git status, npm list)	Allowed silently or with quick prompt
Writing / editing a file	Asks before overwriting
Running side-effecting commands (npm install, git push)	Asks first
Destructive operations (rm, git reset --hard)	Asks, usually with warning
Reaching the web	Asks

In ~/.claude/settings.json, you can grant standing permissions for specific commands you trust. Example: “always allow npm test” stops the prompt for that command. “Always allow gh pr view” lets Claude check PR status without nagging.

For Bible Quest, George has allowed a sensible default set (test running, lint, build, common git read commands). Risky operations always prompt.

The user is in control. Claude Code can do a lot — but always under explicit or pre-granted approval.

---

Slash commands — built-in superpowers

Type / in Claude Code to see available commands. A few key ones:

Command	What it does
/help	Built-in help
/clear	Clear the conversation context
/code-review	Run a multi-agent cloud review on your current branch
/security-review	Security-focused review
/init	Initialize a CLAUDE.md based on the current project
/loop <interval> <task>	Run a task on a recurring schedule
/schedule	Create a one-off scheduled task
/verify	Verify a fix actually works by running the app
/run	Launch and drive this project’s app to verify changes
/fast	Toggle Fast mode (faster Claude responses)

Slash commands are essentially saved prompts with rich behavior. New ones are added regularly. See Slash commands for the deep treatment.

---

Plugins, hooks, agents

Three advanced primitives that pay off as you use Claude Code more:

• Plugins (deep dive) — packaged extensions that add skills, commands, and connectors. The “Bible Quest plugin” or “Anthropic skills” plugin.
• Hooks (deep dive) — automation triggered by events (e.g., “after every commit, run X”). Lives in settings.json.
• Subagents (deep dive) — specialized AI helpers for specific tasks. Claude Code spawns them automatically; you can also define your own.

These are NOT necessary on day one. After a few weeks of regular use, they start paying off.

---

When NOT to use Claude Code

It’s not always the right tool:

• For pure conversation (no code) — claude.ai is faster
• For very tight inner loops (typing 5 characters into a config) — manual is faster
• When you need REAL silence — your fingers know exactly what to do; don’t break flow to ask AI
• For sensitive code reviews where AI output can mislead — paired human review still wins
• When the cost matters more than the speedup — track your usage if you’re on a usage-based plan

For a serious software project: Claude Code is the daily driver. The above are edge cases.

---

Common gotchas

• CLAUDE.md is auto-loaded; other files are referenced on demand. Putting too much in CLAUDE.md bloats every conversation. Keep CLAUDE.md tight; let memories scale to specific recall.

• Slash commands need a leading / and the right name. /code-review not /codereview. Type / to see the list.

• Authentication can drift. A new Anthropic password, a new Pro plan, a logout from claude.ai can occasionally require re-authenticating Claude Code. The flow is quick.

• The model used can vary. Most users default to the latest Sonnet. Opus and Haiku are also available. The /fast command toggles a faster mode (lower latency, slightly different model behavior).

• Token usage matters on the Pro plan. A long, dense conversation can hit limits. /clear resets context; restarting Claude Code starts fresh.

• Context windows are large but not infinite. Very long sessions (hundreds of tool calls + huge files read) may compress older context. Plan around it — split big tasks into multiple sessions when natural.

• Claude Code can be wrong. Especially on niche libraries, recent changes, or unusual patterns. ALWAYS verify edits before committing; ALWAYS run the build before pushing.

• Don’t accept changes you don’t understand. If Claude makes a 100-line edit and you can’t read it, ask for an explanation before approving. “Why did you change X?” is a fair question.

• /loop and /schedule can run things later. Useful for “check the deploy every 5 minutes.” Don’t set up loops you’ll forget about — they cost tokens.

• Hooks can be intrusive. A hook that runs on every file save can slow you down or run unwanted commands. Add hooks deliberately.

• The “subagent” pattern can spawn many parallel processes. Useful, but if you’re on a usage-based plan, costs add up. Most users don’t see this directly.

• ~/.claude/settings.json precedence: project-local > user-level > defaults. A setting in the current project’s .claude/settings.json overrides your global one.

• .claude/ folders in projects are sometimes committed. A team using shared Claude Code conventions may commit project .claude/settings.json, prompts, and skills. Decide explicitly whether to commit.

• Don’t expose API keys in a Claude conversation. Claude Code can SEE files including .env.local. If a session is later shared or exported, those secrets travel. Mostly fine in solo use; be cautious if sharing recordings.

• Watch what Claude Code stages for commit. It may include files you didn’t intend. Always review git status before approving a commit.

• The “I can read your screen” claim is FALSE. Claude Code reads files on disk via the file system. It doesn’t see browser tabs, your other apps, or your screen.

• Long-running commands can hang. A dev server started by Claude (npm run dev) keeps running. Use the “background process” option or kill it with Ctrl+C when done.

• Subagent results are not always reused. A subagent’s findings come back as a single message; the main agent decides what to do. If you want the subagent’s full output preserved, ask explicitly.

• The CLI has its own permissions independent of system permissions. Even though you (the user) can rm -rf /, Claude Code’s settings can block it from running that. Permissions are a defense-in-depth layer.

• Restarting the conversation loses ephemeral context. Memories persist; the in-session understanding of what was just discussed doesn’t (unless captured in a file or commit message).

• Ctrl+C cancels the current operation; Ctrl+D (or /exit) quits. Use Ctrl+C if Claude is “off the rails”; it’s safer than letting it continue.

• The output you see is not always exactly what was sent to the model. Some formatting and notes are display-only. The actual tokens sent are the underlying message content.

• AI tool errors compound. A bad edit + a bad test + a bad commit message together cost more than the sum. Catch problems EARLY (review every diff).

• Multiple Claude Code sessions in the same project can conflict. Two terminals running Claude Code in the same folder may edit the same file concurrently. Run one at a time per project.

• Don’t paste secrets into the prompt. Anything you type is sent to Anthropic’s servers. Use env vars, not prompts, for credentials.

• Web search results may be cached or stale. If Claude says “the latest version is X” but a newer release just shipped, double-check.

• Plugins update independently of Claude Code itself. A plugin pinned to an older API version may misbehave when Claude Code updates. Update plugins regularly.

---

Where to go next

For the deep treatment:

1. Claude Code deep dive — the comprehensive walk-through
2. Memory system — how Claude remembers across sessions
3. Slash commands
4. Plugins
5. Hooks
6. settings.json

For Bible Quest-specific Claude Code conventions, the ~/.claude/CLAUDE.md and ~/.claude/projects/C--Users-georg/memory/ folders are the source of truth.

---

See also

• Claude Code deep dive 🟩 🟦 — the comprehensive view
• Memory system 🟩 🟦 — how memory works
• Slash commands 🟩 🟦
• Plugins 🟩 🟦
• Hooks 🟩 🟦
• settings.json 🟩 🟦
• Subagents 🟩 🟦
• LLM literacy reading path 🟩 — the foundations
• Claude Code mastery reading path 🟩 — the full progression
• Node.js runtime 🟩 — what Claude Code runs on
• VS Code 🟩 🟦 — a complementary tool (different shape)
• Dotfiles & config 🟩 — where ~/.claude/ lives
• Code review 🟩 🟦 — /code-review slash command
• Glossary: Claude Code, Agent, LLM

---

Sources

• Claude Code official docs — canonical reference
• Claude Code on npm — install package
• Anthropic — Claude Code announcement
• Anthropic — Pricing
• claude.ai — the web chat
• Anthropic API docs — the underlying API