Complete Guide to Claude Code: From Installation to Letting AI Build a Feature from Scratch

At 11:00 PM, only two people were left in a startup office in Neihu. A software engineer received a critical bug that had to be fixed before deployment the next morning. The bug originated in a module written by a colleague who had left three years ago—devoid of any comments or tests. The engineer typed the requirements into the terminal and walked away to grab a cup of coffee. When they returned, the screen already displayed five relevant files, pinpointed the probable cause, fixed one of the locations, and successfully ran the tests.

This isn’t an advertising scenario; it’s an everyday use case for Claude Code. But precisely because it actively modifies your codebase, using it incorrectly carries a far higher price tag than conventional AI tools. This article outlines my actual workflow, including several lessons I learned the hard way.

What It Is: An Agent, Not an Autocomplete

Let’s clarify its positioning first, as this determines how you should use it.

Most AI coding tools people are familiar with are "autocomplete" types: you type, it guesses the next line, and you press Tab to accept. GitHub Copilot started in this mode—you watch it the whole time, and it saves you typing time.

Claude Code is an "agentic" type. You give it a goal—fix this bug, add pagination to this API—and it decides which files to read, which commands to run, and how to fix failing tests. Once the entire loop is complete, you step in for code review.

The practical implication is this: your role shifts from "the typist" to "the reviewer." What gets saved isn't typing time; it's the time spent understanding unfamiliar code and trial-and-error debugging. If you lack solid code review skills, using this tool can actually be dangerous.

Where You Can Use It

The current interface is more versatile than most people realize:

• Terminal CLI: The most fully featured option. The installation command is curl -fsSL https://claude.ai/install.sh | bash
• Desktop App: Available for macOS, Linux, and Windows
• Web App: claude.ai/code, no installation required
• IDE Extensions: VS Code and JetBrains
• Mobile: iOS and Android apps
• Slack Bot: Open tasks directly from your chat
• GitHub Actions: Automate PR reviews

Personally, I primarily use the CLI and check progress on my mobile phone. The advantage of the CLI is that it lives right inside your project directory, with environmental variables, git status, and test commands ready to go.

How to Use It: Four Steps

Step 1: Install and Launch in Your Project Directory

Once installed, you must cd into your project's root directory before launching it. Many people start it in their home directory, where it cannot see the project structure and is forced to blindly guess. The first launch will require you to log in. If you have a Claude subscription, you can bind it directly; otherwise, you pay-as-you-go via API keys.

Step 2: Have It Understand the Project Before Giving Orders

The most common mistake beginners make is dumping requirements right out of the gate. A better opening line is:

Take a look at the project structure, tell me about the tech stack, how the main modules are organized, and how to run tests. Do not modify any files yet.

The phrase "Do not modify any files yet" is crucial—it is proactive by nature, and if you don't tell it to stop, it might start tinkering. Once you confirm it understands the context, you can proceed.

Step 3: Write a CLAUDE.md File—The Most Critical Step

Place a CLAUDE.md file in your project root directory containing your project rules. It reads this file every single time it boots up. The quality of this file directly dictates whether your experience is smooth or agonizing.

Here is what you should actually include:

Project Conventions

• Frontend: TypeScript + React, Backend: Node.js
• Testing: vitest, execution command npm run test
• Commit messages in Traditional Chinese, format: type: description

Important Restrictions

• Only do what I explicitly ask. Do not proactively refactor or add unsolicited abstraction layers.
• Do not add third-party packages; ask me first if needed.
• Do not touch code under src/legacy/; that is the old system slated for replacement.
• Always run npm run test after making changes. Do not claim a task is complete if tests fail.

"Only do what I explicitly ask" is, in my opinion, the single most important rule to include. If you ask it to fix a bug, it might spontaneously refactor three files, add error handling, and adjust types. None of these actions are inherently wrong on their own, but your code review will turn into a disaster, and you won't be able to distinguish between what was necessary to fix the bug and what it decided to do on its own.

Step 4: Issue Tasks and Review

The more specific your task description, the better. Poor versus good phrasing:

• ❌ "Help me optimize this code" — It has no idea what you want to optimize; it might improve performance or it might change readability.
• ✅ "This function times out when data exceeds 10,000 rows. Find the bottleneck and fix it without altering its public interface. Run tests when you're done."

The second phrasing gives it a clear goal, constraints, and acceptance criteria.

Advanced Tips

Use /clear to reset the context. If you don't clear the context when switching tasks, the previous task's context will interfere with its reasoning. One clean chat per task.

Make good use of plan mode. When facing major changes, first ask it to "provide a plan only, do not make changes." Review the plan before giving the green light—it saves much more time than rolling back after the fact.

Let it read error messages itself. There is no need to copy and paste errors; simply tell it to run the tests, and it will read the output and fix it on its own.

Quota management. The Pro plan (approx. $17–$20/month) can easily exhaust your quota within a few hours when running large-scale refactors. Heavy users will likely need to upgrade to Max 5x ($100) or Max 20x ($200). I recommend starting with Pro for a month and tracking how often you hit the ceiling before deciding.

Precautions

It will produce code that looks correct but contains actual bugs. What it writes has proper syntax, consistent styling, and looks professional, but the logic can be flawed—especially concerning edge cases and concurrency issues. You must be capable of reviewing its output; this is not optional.

Verify data privacy protocols first. Code is sent to cloud models. For finance, healthcare, and projects bound by NDAs, be sure to confirm company policies and contract terms before adoption—many teams in Taiwan adopt it first and think about compliance later, getting the sequence backward.

Do not let it touch database migrations or production deployments. Operations of this nature are irreversible, and the cost of failure far outweighs the time saved. My rule of thumb is: hand over reversible tasks, handle irreversible tasks yourself.

Don't expect it to replace architectural thinking. It excels at execution, but decisions like "Should we build this feature? Should we split services? How should the data model be designed?" remain your job. If you want cross-comparisons, pair it with editor integrations like Cursor.

Recommended Workflow

My rhythm is: assign well-defined tasks to it in the morning, handle tasks requiring human judgment myself, and review its generated diffs collectively in the afternoon. For more ways to integrate AI into your daily work, check out the AI Task Guide or Prompt Template Library.

The AI Academy Review

Honestly, I’ve always been skeptical of the narrative that "AI will replace software engineers," but after using it for a few months, I admit that an engineer's job content is indeed changing. What's changing isn't "whether we still need engineers," but rather where value lies—shifting from "writing code" to "judging whether the code is correct."

Review: Claude Code is currently the most mature AI coding agent, but it merely magnifies your existing judgment—those with strong judgment double their productivity, while those with weak judgment simply manufacture technical debt faster.

Concrete advice for readers: Engineers with over three years of experience should integrate it into their workflow right away, starting with "writing tests" and "fixing clear bugs"—this yields the highest ROI with the lowest risk. For newcomers to the industry, I actually recommend writing code by hand first and using it as a reference, rather than skipping the phase of building your own judgment. If a team is adopting it, let one or two senior engineers test it for a month and calculate the ROI based on saved hours; that is far more accurate than any review.

Sources

• Claude Code Official Product Page (Installation methods, supported platforms, pricing plans)

Compiled based on public information; official sources prevail. Actual features and pricing are subject to version updates.