Claude Code Deep Dive: Two Weeks with an AI Programmer in My Terminal

Anthropic just dropped another Claude Code update — Agent Teams, 1M token context, auto-memory. I've been a Cursor user for months, dabble with Copilot here and there, but this "pure terminal" AI coding thing got me curious. No GUI, no sidebar, just you and an AI in a command line, getting stuff done.

Two weeks in, I've hit some walls and genuinely changed how I work. Here's what actually happened — no hype, no trash talk.

What Claude Code actually is

Let me be clear about what it's not. It's not another IDE plugin. It's not another autocomplete tool.

Claude Code is an AI coding agent that runs in your terminal. You cd into a project, type claude, and it starts working. It reads your files, edits your code, runs commands, searches the web — basically an invisible programmer sitting next to you.

The biggest difference from Cursor? Cursor works in a GUI where you see every file change and can accept/reject line by line. Claude Code is different — you give it a task, and it explores, plans, and implements on its own. It might touch a bunch of files and run a bunch of commands in the process.

The upside: you can hand off an entire feature and go grab coffee. The downside: you have to trust it, because it makes way more changes than Cursor, and you can't see the diff in real time.

Getting it running

Installation is one command:

curl -fsSL https://claude.ai/install.sh | bash

Then cd into your project and just type claude:

cd my-project

claude

First run asks you to sign in with your Anthropic account. I'm on Claude Pro ($20/month), which works fine for moderate use. If you're a heavy user, you might need the Max plan ($100 or $200/month) for higher token limits.

I made a dumb mistake on my first run — I started claude in a project directory without initializing git. Got a warning saying some features might not work without a git repo. Quick git init and I was good.

Another gotcha: on Windows, install Git for Windows. Otherwise Claude Code falls back to PowerShell as its shell, and some commands behave differently.

CLAUDE.md: Writing a "work manual" for your AI

This is one of Claude Code's most interesting designs. You put a CLAUDE.md file in your project root, and Claude reads it at the start of every conversation. Think of it as a work manual — telling Claude your code style, common commands, project structure, etc.

Mine looks like this:

# Code style

- Use ES modules (import/export) syntax, not CommonJS (require)

- Destructure imports when possible (eg. import { foo } from 'bar')

- Prefer functional components in React

# Workflow

- Run `npm run typecheck` after making code changes

- Run `npm test -- --watch` for single test file, not the whole suite

- Use `npm run lint:fix` to auto-fix lint issues

# Project structure

- src/components/ - React components

- src/lib/ - utility functions

- src/app/ - Next.js app router pages

At first I wrote a huge one, cramming the entire README in there. Turns out that's a bad idea — if CLAUDE.md is too long, Claude starts "ignoring" some of your instructions. The official advice: for each line, ask "would removing this cause Claude to make mistakes?" If not, cut it.

After I trimmed mine down to about 30 lines, results got noticeably better. Claude stopped getting hung up on irrelevant details and focused on what actually mattered.

Real scenarios

Scenario 1: Fixing bugs

This is where Claude Code shines. Give it an error message, and it investigates on its own.

claude "How do I fix this type error: src/lib/api.ts:42 - Type 'string' is not assignable to type 'number'"

It reads the file, looks at the context, finds the issue, and gives you a fix. Better than Cursor: it actually runs npm run typecheck to verify the fix works, instead of just giving you code to test yourself.

One time was wild — I gave it a vague description: "login sometimes fails." It went digging through src/auth/, found a token refresh logic bug, wrote a test to reproduce it, then fixed the whole thing. One sentence from me.

Scenario 2: Building new features

For new features, I start with plan mode:

claude --plan "Implement a user bookmarks feature with frontend component and backend API"

In plan mode, Claude only explores and plans — no code changes. It asks you questions like "where should bookmark data be stored?" and "do you need batch operations?" Once you answer, you let it implement.

This is way better than jumping straight to coding. One time I skipped plan mode and asked it to implement search. It picked a search library my project had never used, and I had to manually roll back. With plan mode, it checks what you're already using and builds on that.

Scenario 3: Code review

You can have it review your code:

claude "Review my recent changes, focus on performance and security issues"

It runs git diff to see what you changed, then gives feedback. Honestly, the review quality surprised me. It caught an N+1 query issue I completely missed.

Scenario 4: Refactoring

Refactoring is another killer use case. I had an old project using React Class Components that I wanted to migrate to Function Components with Hooks.

Doing it manually would've taken two or three days. With Claude Code:

claude "Migrate all Class Components in src/components/ to Function Components, replace state and lifecycle methods with useState and useEffect, keep functionality identical"

It took about 20 minutes to convert all 15 components. When I reviewed the result, it actually did better than I expected — not just the basic migration, but also extracted repeated logic into custom Hooks.

One small issue: it removed componentDidCatch from a component without adding a corresponding Error Boundary. I caught it and asked it to fix, which it did quickly.

Lesson learned: even Claude Code can't be fully trusted. For big refactors, always review its changes.

Scenario 5: Writing tests

Writing unit tests is one of my least favorite things. Claude Code makes it way less painful.

claude "Write unit tests for src/lib/utils.ts, cover all edge cases, use vitest"

It reads the file, analyzes each function's inputs and outputs, and generates a complete set of test cases. I usually add: "test cases should include normal input, empty values, edge cases, and invalid input."

The generated tests are decent, but sometimes miss business logic edge cases. Like it doesn't know "username can't be empty string" unless there's validation code in the source.

My approach: let it generate a first version, then review and add business-specific test cases. Still way faster than writing tests from scratch.

Scenario 6: Debugging production issues

A user reported that a page was loading slowly. I used Claude Code to investigate:

claude "Users report /dashboard loads slowly. Help me investigate performance issues. Check for unnecessary re-renders, large data queries, or network request problems."

It did this:

1. Read the /dashboard component code
2. Checked data fetching logic, found an API call with no caching
3. Checked component rendering, found a list component recalculating sorts on every render
4. Gave two optimization suggestions: add React.memo and use SWR for data caching

I followed its suggestions, and page load time dropped from 3 seconds to 0.8 seconds. Way faster than I would've found this on my own.

Configuration and customization

Permission modes

Claude Code has several permission modes:

• Default mode: asks before executing risky operations
• Plan mode: only explores and plans, no code changes
• Accept edits: auto-accepts file changes, but still confirms before running commands
• Yolo mode: auto-allows everything (not recommended)

I recommend default mode or Accept edits. Yolo mode seems convenient, but once it ran rm -rf and deleted a temp folder of mine. Not a big deal, but scary.

Custom slash commands

You can create custom commands in .claude/commands/. I created a /test command:

# .claude/commands/test.md

Run tests for the current file, fix any failures:

1. Find the test file corresponding to the current file

2. Run the tests

3. If failures, analyze and fix

4. Re-run tests to confirm they pass

Now I just type /test and Claude knows what to do.

MCP servers

Claude Code supports MCP (Model Context Protocol) servers for extending its capabilities. You can connect:

• Database query tools
• API testing tools
• Document search tools
• Custom internal tools

I connected a PostgreSQL MCP server, so Claude can query databases directly when debugging data issues. Much better than copying and pasting data manually.

Pricing and subscription choices

Claude Code billing ties to your Claude subscription:

• Claude Pro ($20/month): daily token limits, enough for 3-5 moderate tasks
• Claude Max 5x ($100/month): 5x the Pro token limits
• Claude Max 20x ($200/month): 20x the Pro token limits
• API pay-as-you-go: no limits, but higher costs

With Pro, I can handle about 4-5 tasks before hitting the daily limit. If you're a heavy user, go with Max.

A money-saving tip: use Plan mode first to explore and confirm your approach, then switch to normal mode for implementation. Plan mode burns way fewer tokens, and it prevents wasting money on wrong directions.

Compared to other terminal AI tools

Beyond Claude Code, there are similar terminal AI tools:

Aider: open source terminal AI coding tool, supports multiple models (GPT-4, Claude, local models). Pros: free. Cons: less capable than Claude Code.

Cursor Agent: Cursor also has an Agent mode that runs in terminal. But its design philosophy is still IDE-first — Agent mode feels more like a bolt-on.

GitHub Copilot CLI: GitHub's terminal tool, but fairly basic — mostly command suggestions and explanations.

OpenAI Codex CLI: OpenAI's terminal AI tool, similar positioning to Claude Code, but still early stage.

I think Claude Code is the most mature in this space right now. Its "understand the entire project" capability is the strongest, and Anthropic keeps shipping updates.

FAQ

Does Claude Code need internet?

Yes. Claude Code calls Anthropic's models via API, so you need a connection. If you're working offline, it won't work.

Workaround: you could use Claude Code's SDK to build a local agent with local models, but that's a different tool entirely.

What programming languages does it support?

Basically all mainstream languages. I've tried TypeScript, Python, Go, and Rust — all worked fine. Its capability depends on the underlying model's (Claude's) understanding of these languages, not Claude Code itself.

Some languages get a smoother experience though. TypeScript and Python are the most polished, because their ecosystems are the most mature and Claude has seen the most code in them.

How is it different from GitHub Copilot Workspace?

GitHub Copilot Workspace is GitHub's AI coding environment, also agent-based. But it's more GitHub-workflow-oriented — starting from issues, auto-creating PRs.

Claude Code is more general-purpose. It's not limited to GitHub workflows — you can use it in any project for any coding task. And its "understand the entire project" ability is stronger because it actively explores your codebase.

Can it write production-grade code?

Yes, but it needs human review. I've shipped quite a bit of Claude Code-generated code to production. Quality is generally fine, but there are occasional issues.

My advice: treat Claude Code as a sophisticated code generator, not a fully trusted programmer. Always review what it generates, especially for security, performance, and data consistency.

Will it leak my code?

This is a common concern. Claude Code sends your code to Anthropic's servers for processing. If you're using an API key, Anthropic doesn't use your data for training. But with free or Pro subscriptions, data might be used to improve the service.

If your code involves trade secrets or sensitive info:

1. Use API key pay-as-you-go instead of subscriptions
2. Read Anthropic's privacy policy carefully
3. Consider local model alternatives (like Aider + Ollama)

Practical workflow example

Let me share my actual workflow to show how Claude Code fits into daily development.

Morning: starting a new feature

# 1. Explore with plan mode first

claude --plan "Implement a user notifications feature including:

- Notification list page

- Unread notification count badge

- Mark-as-read functionality

- Real-time push via WebSocket"

# 2. Confirm the plan, then implement

claude "Implement the notifications feature per the plan above"

Midday: fixing bugs

# A user-reported bug

cat error.log | claude "Users report occasional 500 errors when submitting forms. Analyze this error log."

Afternoon: code review

# Review today's changes

claude "Review today's changes, focus on:

1. Security issues

2. Performance issues

3. Test coverage"

Evening: refactoring

# Refactor an old module

claude "Refactor src/utils/legacy.js to TypeScript, keep functionality identical, add type definitions"

This workflow lets you switch between tasks quickly, using Claude Code to accelerate each one. But you're always the driver — Claude is the co-pilot.

Advanced tips

1. Use /goal to set targets

You can set a goal in your session with /goal, and Claude keeps working until it's achieved:

claude

> /goal All tests pass, type checking shows no errors

Claude will repeatedly run tests and type checks until everything passes. Great for fixing complex bugs.

2. Use /compact to compress context

If your session gets long, use /compact to have Claude summarize the conversation and free up context space:

claude

> /compact

Better than /clear because /compact preserves key information, while /clear wipes everything.

3. Use Hooks for automation

You can configure Hooks in .claude/settings.json to auto-run commands on specific events:

{

  "hooks": {

    "postToolUse": [

      {

        "matcher": "Write|Edit",

        "command": "npm run lint:fix"

      }

    ]

  }

}

This means: every time Claude writes or edits a file, auto-run lint fix. Keeps code style consistent.

4. Use Remote Control across devices

Claude Code supports Remote Control — start a task on one machine, monitor progress from your phone or another computer. Handy for long-running tasks: start a refactor, then watch from the couch on your phone.

5. Use Channels for notifications

Configure Channels to push task completion notifications to Telegram, Discord, or Slack. No need to stare at the terminal — you'll get notified when the task is done.

Who is this for

Good fit for:

• Terminal power users who prefer command-line workflows
• Developers who need to handle complex tasks (not line-by-line coding, but "implement a feature")
• People willing to invest time configuring CLAUDE.md for better results
• Those comfortable with some AI autonomy

Not ideal for:

• People who prefer GUI operations and dislike terminals
• Those who need to see every line change in real time (Cursor is better for this)
• Budget-conscious users who don't want to spend much on AI tools
• People with strict code quality requirements who don't trust AI autonomy

What's next

I plan to keep using Claude Code for a while, especially trying the Agent Teams feature — multiple Claude instances collaborating on a single task. Sounds cool but I haven't really used it yet.

I also want to explore integrating Claude Code into CI/CD pipelines. It officially supports GitHub Actions for auto-reviewing PRs and handling issues. If that works well, it could save a lot of manual effort.

Questions? Drop them in the comments.

• Written June 2026, based on the latest Claude Code version. AI tools update fast — features and pricing in this article may change. Check official docs for the latest.*