Introduction to Claude Code
What it is, what it can do, and how it differs from ChatGPT / Copilot / Cursor
📚 Series Navigation: This is the first article of the "Claude Code Beginner's Tutorial". Starting from here, we will install it, get familiar with it, and finally integrate it into your daily development workflow. The next article will be hands-on installation.
Brothers, today let's talk about Claude Code.
I guess you clicked in, mostly in this state: there are always people around talking about "how amazing Claude Code is", and you often see screenshots on X (Twitter) saying "one sentence made it refactor the project", but when you open its official website, you still don't understand after looking for a long time — how does it actually differ from the ChatGPT I use every day? And how does it differ from the Copilot with autocomplete in my editor?
To put it bluntly, having "Code" in the name easily makes people think it is just a "chat box that can write code". But once you actually use it, you will find this understanding is quite far off.
This article doesn't teach you how to install or type commands (that's for the next article). This article only does one thing: thoroughly explain "what exactly is Claude Code", giving you a complete map in your mind — knowing what it can do, what it cannot do, and in what scenarios you should use it instead of other tools. With the map, you won't get confused in every subsequent step.
After reading this article, you will get:
- One sentence to clearly explain "what Claude Code is" to others
- A "can / cannot do" checklist, knowing where its ceiling is
- A comparison table, never confusing it with ChatGPT / Copilot / Cursor again
- A judgment criterion: what tasks should be handed to it, and what tasks you shouldn't count on it for
01 What exactly is Claude Code
Let's give the conclusion first: Claude Code is Anthropic's official "command-line AI programming partner" — it can read your entire project, directly edit files, and run commands, rather than just returning a piece of code to you in a chat box.
Anthropic is the company that made the large model Claude (you can understand it as a peer competitor to OpenAI behind ChatGPT). Claude Code is a tool specifically made by this company for the scenario of "writing code".
There is a key difference here, where beginners most easily stumble:
Analogy: Consultant vs Partner sitting next to you. The web version of Claude (or ChatGPT) is like a consultant — you take screenshots or copy-paste code into the chat box, it takes a look and gives you ideas, but you still have to go back and manually edit the code yourself. Claude Code is different, it is like a real partner sitting next to you at your desk: your entire project is spread out in front of it, it can directly flip through files, make changes, and even run it once to see if it's correct after changing.
This difference results in a world of difference in actual experience.
For example, when using the web version of Claude to modify a small Python project, the process goes like this: copy the error message and paste it into the dialogue box → it tells you which file might be the problem → you switch back to the editor to find that file → copy the relevant code and paste it back → it gives suggestions for modification → you manually copy it back to the editor. Switching windows five or six times for a small bug, half an hour is gone just like that. Switch to Claude Code, for the same task, you just need one sentence "help me check the root cause of this error and fix it", it automatically goes through the relevant files, locates it, fixes it, and it's done in the time it takes to drink a sip of water.
This immediately makes you appreciate the weight of the word "Agent" — it doesn't give you suggestions, it acts on your behalf.
💡 One-sentence summary: Claude Code = an AI programming partner that can read your entire project and directly make changes, not a "chat box that can write code".
02 Where does it run: More than just a dark terminal
When mentioning "command line" or "terminal", many beginners immediately picture a dark window and are instantly deterred. Don't panic, this is a common misunderstanding.
The terminal (Terminal, which is the window on your computer where you type commands) is indeed the core and most feature-rich form of Claude Code, but it has long ceased to live only in the terminal. According to official documentation, Claude Code now has the following "identities":
| Where you use it | Form | Who/What scenario it suits |
|---|---|---|
| Terminal | The most feature-rich CLI (command-line interface) | People who want to use all capabilities, write scripts, and do automation |
| VS Code / Cursor | Editor plugin, inline diff viewing | People who normally write code in VS Code |
| JetBrains | Plugins for IntelliJ / PyCharm, etc. | Heavy Java / Python users |
| Desktop App | Standalone app, visual diff viewing, parallel multi-sessions | People who don't want to touch the command line and prefer clicking interfaces |
| Web / Mobile | Runs in browser or Claude iOS App | Temporarily starting a long task, checking progress on phone while out |
There is a particularly crucial point repeatedly emphasized by the official documentation, which I'll pull out separately and bold:
All these forms share the exact same Claude Code engine underneath. That is to say, your CLAUDE.md (project instruction file), your configurations, your connected MCP (Model Context Protocol) services — set up once in the terminal, will equally take effect when switching to VS Code or mobile. Configure once, use everywhere.
Many people use the terminal as their main tool (used to it, handiest), but when out and about, they can start a long task of "running tests + fixing failed cases" on the web version, and pull out their phone on the road to glance at the progress. This experience of "picking up where you left off anywhere" is something a web chat box cannot provide.
Friendly tip: This series defaults to starting from the terminal, because it is the most feature-rich and best explains the principles. Once you are familiar with it, switching to VS Code or the desktop App will happen naturally.
💡 One-sentence summary: Claude Code has five forms: terminal, editor plugin, desktop App, web/mobile, but they share the same underlying engine, and configurations are universal across platforms.
03 What can it do: A "Can / Cannot" checklist
This part is the most practical. Let's first look at the tasks it can do — I've sorted them according to the official documentation and picked a few types that beginners can relate to most:
- Understand your code: "What does this function do?" "Why does this part error out?" It answers based on the context of the entire project, rather than looking at a segment in isolation.
- Modify code across files: "Change all places using
vartolet" "Split this large function into three smaller ones" — it actually makes the changes, not just giving suggestions. - Fix bugs: Throw the error message at it, it follows the codebase to trace the root cause, locates it, and fixes it.
- Do the chores you've been putting off: Add tests to untested code, clear lint errors, resolve merge conflicts, upgrade dependencies, write release notes.
- Interact with Git: Stage changes, write commit messages, create branches, and open PRs (Pull Requests) all in one go.
- Connect to external tools: Through MCP (an open standard, which will be covered in a dedicated article later), read Google Drive documents, update Jira tickets, pull data from Slack.
Just talking about it isn't intuitive enough, let me give you a real command from the official documentation to feel what "commanding with one sentence" looks like:
claude "write tests for the auth module, run them, and fix any failures"Translated, it means: "Write tests for the auth module, run them all, and fix them yourself if they fail." — In one sentence, it takes care of all three steps: writing tests, running tests, and fixing failures. This is the essential difference between "agent" and "completion".
However, more important than "what it can do" is recognizing what it cannot do. This point is crucial, and I will also add my own experiences:
| ❌ What you shouldn't count on | Why |
|---|---|
| Making technical decisions for you | Choosing plan A or B, whether it's worth refactoring — judgment and trade-offs are your job |
| Guaranteeing code is 100% bug-free | It provides high-quality candidates, not absolutely correct answers, you must review them |
| Guessing business logic you didn't explain clearly | If you don't explain the requirements clearly, it can only guess blindly |
| Fully automating the project when you completely don't understand it | If you don't understand it, you can't judge if its changes are correct, which equals flying blind |
One of the easiest pitfalls to fall into is the second rule. Trusting it too much, letting it add error handling to a project in bulk, it swiftly modified a dozen files, and you committed it without looking closely. As a result, it "took the initiative" to change the logic in two places, which was only discovered after going online. Therefore, it's best to set an iron rule: at least scan the diff of every line it changes before committing.
The mental foundation for using Claude Code well is just one sentence:
Let Claude Code provide high-quality candidate solutions, not absolutely correct answers.
To put it simply in one sentence — humans set the direction, act as gatekeepers, and make judgments; AI is responsible for execution, analysis, and doing repetitive labor. This is its design philosophy: collaboration, not replacement.
💡 One-sentence summary: It can read projects, modify files, run commands, do chores, but making decisions and gatekeeping is always your job — it is a partner, not a scapegoat for a hands-off boss.
04 How does it actually differ from ChatGPT / Copilot / Cursor
This is the question asked most by beginners, let's make it clear once and for all. First, an overview table:
| Dimension | ChatGPT (Web chat) | Copilot / Cursor (In-editor) | Claude Code |
|---|---|---|---|
| Form | Web / App chat box | Plugin in the editor | Command line / Plugin / Desktop / Web all available |
| How it works | You ask, it answers | You write half, it completes the rest | You give instructions, it does the work itself |
| Can it see your project | Cannot, requires manual pasting | Can see current file / partial context | Automatically reads the entire project |
| Can it modify files | Cannot, gives suggestions for you to modify | Mainly completion, suggestions | Can directly modify, can run commands |
| Best for | Asking concepts, looking up info, writing fragmented code | Real-time speed-up while writing code | Understanding, refactoring, fixing bugs, and automation in real projects |
Then let me carve it into your brain with three plain sentences:
- ChatGPT is like a consultant — can chat about anything, but is completely blind to your project, you have to do the work yourself.
- Copilot / Cursor is like a smart keyboard — as you type code, it guesses what you want to write next, helping you type a bit faster, but you are still the main one writing.
- Claude Code is like a partner that can work independently — you explain what you want, and it takes care of flipping through files, modifying code, and running tests, you just review it when it's done.
Note: The Cursor / Copilot here refers to their most classic "in-editor auto-completion" positioning. Over the past two years, they have also been developing more "agent-like" features (like Cursor's Agent mode), and the boundaries are blurring. But as an introductory understanding, remembering the core positioning of the three sentences above is enough. (Product features iterate quickly, details are subject to their respective official updates.)
So where is Claude Code strong, and where is it weak? Based on actual testing:
Its strengths — Its ability to understand the entire project is truly strong, especially when taking over an old project you don't understand, having it "first explain the project architecture to me" is much faster than chewing on documentation for half a day; large-scale refactoring and cross-file modifications are also its home turf. Plus, you can use CLAUDE.md and Skills to "train" it to fit your habits (detailed in a later dedicated article).
Its weaknesses — It is not as "seamless" as Copilot. Copilot fills things in for you as you write, with zero operation cost; Claude Code requires you to actively speak up and give instructions, and the learning curve is slightly steeper. So they are not substitutes, they are complementary — a handy pairing is keeping Copilot completion on while writing code, and switching to Claude Code when encountering tasks that "require changing a large area".
💡 One-sentence summary: ChatGPT is a consultant, Copilot is a smart keyboard, Claude Code is a partner that can act — don't choose one over the other, assign work based on the task.
05 Hands-on: Take 30 seconds to confirm if your computer recognizes it
I said this article wouldn't teach installation, but I'll leave you with a zero-cost small action to check your environment (whether installed or not, this command can run without throwing errors or breaking things).
Open your terminal (Terminal App on Mac, PowerShell on Windows), type this line and press enter:
claude --versionTwo expected results, both are normal:
- Scenario One: A version number pops up, similar to
2.x.x (Claude Code)— congratulations, you have installed it before, and in the next article you can directly skip to "Starting to use". - Scenario Two: Error
command not found: claude(On Windows it might be'claude' is not recognized as an internal or external command) — perfectly normal too, meaning it hasn't been installed yet, which is exactly the first thing to solve in the next article.
Here's an early spoiler of the installation commands that will be used in the next article (don't rush to type them now, just get familiar with them), the official original version looks like this:
# macOS / Linux / WSL
curl -fsSL https://claude.ai/install.sh | bash
# Windows PowerShell
irm https://claude.ai/install.ps1 | iex
What this picture wants to express is: taking "whether it can automatically understand your entire project" and "whether it can directly modify files" as two axes, placing the four tools — only Claude Code stands firmly in the corner of "both understanding globally and acting directly", ChatGPT relies on manual operations for both, Copilot/Cursor understands locally and mainly relies on completion. Not seeing the picture doesn't affect anything, just remembering the three sentences from the previous section is enough.
A reminder: For domestic users, installing and logging into Claude Code usually requires "magic internet access", how exactly to do it and how to log in will be dedicated in the next article, we won't expand on it here.
💡 One-sentence summary: A single
claude --versioncan confirm if your computer recognizes it — don't panic if there's an error, that's the opening task of the next article.
06 Summary
We didn't type many lines of commands in this article, but we clarified the things that need to be understood the most:
- What it is: Anthropic's official command-line AI programming partner, capable of reading the entire project, directly modifying files, and running commands — not a "chat box that can write code".
- Where to use it: Terminal, VS Code/JetBrains plugins, desktop App, web/mobile, five forms same engine, universal configurations.
- Can / Cannot: Can read code, modify files, fix bugs, do chores, connect to external tools; but making decisions, gatekeeping, and filling in business logic are always your job.
- Differences from others: ChatGPT is a consultant, Copilot is a smart keyboard, it is a partner capable of independent work, assign work based on the task, no need to choose one over the other.
You should now be able to: Clearly explain what Claude Code is to your colleagues in one sentence, and also judge "whether this task should be handed over to it". This is the most important "sense of map" to have for getting started — all subsequent features are just adding bricks and tiles to this map.
Next article 02 "Installation and Usage": We will formally get hands-on, install it on your computer (Mac / Windows / Linux / WSL explained separately, not missing a step), run through the first login, and make the claude command truly come alive in your terminal. First, go type the claude --version above and see if you belong to "Scenario One" or "Scenario Two" — the next article will prescribe the right medicine.