What Is Claude Code

Most AI coding tools watch you type and guess what comes next. Claude Code doesn't do that. At all. It reads your codebase, makes a plan, writes code across multiple files, runs tests, and commits the result. You describe what you want. It figures out how to get there.

Keep that in your head. It changes how every tool in this course works.

Autocomplete vs. Agent

You've probably used GitHub Copilot or something like it. You start typing a function, it suggests the next few lines. That's autocomplete. Reactive. It waits for you to do something, then predicts what comes next.

Claude Code flips that entirely. You give it a goal in plain English, and it takes autonomous action to get there. It picks which files to read. It decides what changes to make. It runs commands to check its own work. You're not guiding it keystroke by keystroke. You're delegating.

Say you want to add input validation to a form. With Copilot, you'd open the file, start typing a validation function, and accept suggestions line by line. With Claude Code, you'd type something like this:

claude "Add zod validation to the contact form. Validate email format, require name to be at least 2 characters, and show inline error messages."

Claude Code reads your project structure, finds the form component, checks what libraries you already use, writes the validation schema, updates the component, and adds tests. One prompt. Multiple files changed. Zero hand-holding.

What It Can Actually Do

Claude Code isn't just a code writer. It's an agent that happens to be very good at software.

Read and understand your project. It scans files, follows imports, reads configs. When you ask it to fix a bug, it doesn't just look at the file you're in. It traces the problem across your codebase.

Write and edit files. Creates new files, modifies existing ones, handles multi-file changes in a single pass. Need a new API endpoint? Route handler, types, validation, tests. All at once.

Run commands. Shell commands, test suites, builds, package installs. If it writes code that breaks a test, it sees the failure and fixes it without you saying a word.

Git operations. Stages changes, writes commit messages, creates branches, opens PRs. You can go from "fix this bug" to "merged PR" without touching git yourself.

Search and navigate. Greps through code, finds definitions, traces call chains. Ask "where is this API called from?" and it actually looks instead of guessing.

Terminal-Native, Not IDE-Bound

Claude Code lives in your terminal. This isn't a limitation, it's the whole point. The terminal is where you already run builds, manage git, execute scripts, and deal with infrastructure. Claude Code just slots in.

Install and run it from the same place you run everything else:

cd your-project
claude

That's it. You're in an interactive session where you can give tasks, ask questions, or have it make changes.

It also works inside VS Code, JetBrains IDEs, and as a desktop app. But the terminal is the native experience. Everything else is built on top of it.

The real power of being terminal-native is composability. Unix philosophy. Pipe things into it, script it, chain it with other tools. Feed your server logs in and ask it to diagnose an error. Run it in CI to auto-fix lint errors. We'll cover all of this later.

Try It Right Now

If you already have Claude Code installed (installation is next lesson), navigate to any project on your machine and start a session:

cd ~/your-project
claude "Explain the architecture of this project in 3 bullet points"

You'll see Claude Code read through your files, figure out the structure, and give you a summary. Notice you didn't tell it which files to read. It figured that out on its own. That's the agent model.

If you don't have it installed yet, keep this mental model in mind as you move through the next few lessons.

How It Differs from IDE Copilots

IDE copilots are great at small, in-context suggestions. You're editing a file, they help you write the next chunk faster. Fewer keystrokes.

Claude Code solves a different problem entirely. Tasks that span multiple files, require reasoning about your project as a whole, involve more than just writing code. Refactoring a module. Implementing a feature from a ticket. Debugging a failing CI pipeline. Autocomplete can't touch these.

An autocomplete tool is a faster pair of hands. Claude Code is closer to a junior dev who can read your whole codebase and execute a plan. You still review the work. You still make the calls. But the grunt work is delegated.

Use both. Copilot for the small stuff while you're actively typing, Claude Code for the bigger tasks where you'd rather describe the goal and walk away.

The Short Version

• You describe goals, it takes action. Not autocomplete.
• Reads files, writes code, runs commands, manages git, searches your codebase.
• Terminal-native and composable. Pipe, script, automate.
• Use it alongside your IDE copilot. Different tools for different jobs.