Getting Started with Claude Code: A Developer’s First Day

I still remember my first day with Claude Code. I installed it expecting another chatbot with a code wrapper. What I got was something fundamentally different: an AI that lives in my terminal, understands my project structure, and works the way I actually work. Here’s everything I wish someone had told me on day one.

Installation and First Run

Getting Claude Code running takes about two minutes. You need Node.js 18+ installed, then it’s a single command:

npm install -g @anthropic-ai/claude-code
cd your-project
claude

That’s it. No VS Code extension to configure, no API keys to juggle in settings files. On first launch, it walks you through authentication and you’re in a conversation right inside your terminal. If you’re coming from GUI-based AI tools, this feels surprisingly natural once you get past the initial “wait, it’s just a CLI?” reaction.

How Context Works (This Is the Key)

The single most important thing to understand about Claude Code is context. When you launch it inside a project directory, it can see your files, your git history, your package.json, your directory structure. This isn’t just cosmetic. It means you can say things like:

> Look at the auth middleware in src/middleware/auth.ts
  and write a test that covers the token expiry edge case

It will actually read that file, understand the logic, check your existing test patterns, and generate a test that fits your project’s style. Compare that to pasting code snippets into a chat window and hoping for the best.

Your First Meaningful Prompt

Here’s a mistake I see every beginner make: starting with toy prompts like “write a hello world function.” Instead, try something real from your actual work. The first thing I asked Claude Code to do was help me with a genuine task:

> I need to add rate limiting to the /api/upload endpoint.
  Check how we handle rate limiting on other endpoints
  and follow the same pattern. Use Redis for the store
  since we already have it configured in src/config/redis.ts

Notice the specificity. I told it what I wanted, where to look for existing patterns, and which tools to use. The result was a implementation that matched our existing code style and actually used our Redis configuration. Had I just said “add rate limiting,” I’d have gotten a generic solution that didn’t fit the project at all.

The CLAUDE.md File: Your Project’s AI Manual

Create a CLAUDE.md file in your project root. This is one of the most underused features. It’s a markdown file that Claude Code reads automatically to understand project conventions. Here’s a minimal example:

# CLAUDE.md

## Project Overview
Express.js API with TypeScript, PostgreSQL, Redis.

## Conventions
- Use zod for all input validation
- Error responses follow RFC 7807 (Problem Details)
- All database queries go through the repository pattern in src/repos/
- Tests use vitest, co-located in __tests__/ directories

## Commands
- `npm test` - run all tests
- `npm run build` - TypeScript compilation
- `npm run lint` - ESLint check

With this file in place, every response from Claude Code will naturally follow your conventions without you having to repeat them. It’s the difference between working with a contractor who read the docs and one who didn’t.

Slash Commands Worth Knowing

Claude Code has several built-in commands that are easy to overlook:

• /help – Shows available commands and usage tips
• /clear – Resets the conversation context when you’re switching tasks
• /compact – Summarizes the current conversation to free up context space on long sessions
• /cost – Shows token usage for the current session, useful for keeping an eye on API costs

The one I use most is /clear. When I finish one task and start another, a clean context prevents the AI from mixing concerns. It’s like closing browser tabs when you switch projects.

A Real Workflow Example

Here’s what my first productive session looked like. I had a React component that needed to be refactored from class-based to functional with hooks:

> Refactor src/components/Dashboard.tsx from a class component
  to a functional component using hooks. Keep the same props
  interface and behavior. Run the existing tests after to make
  sure nothing breaks.

Claude Code read the file, identified the state and lifecycle methods, converted them to useState and useEffect hooks, preserved the prop types, and then ran the test suite. Two tests failed because of a subtle difference in how componentDidMount vs useEffect timing worked. It identified the issue and fixed it without me having to explain what went wrong.

Total time: about 4 minutes for a refactor that would have taken me 30-40 minutes manually, including the debugging.

Tips for Day One

• Be specific in your prompts. “Fix the bug” is bad. “The login form submits twice when the user double-clicks; add debouncing to the submit handler in src/components/LoginForm.tsx” is good.
• Let it read files first. Reference specific paths. The more context it has, the better the output.
• Review everything. Even when the output looks perfect, read it line by line. You’re the senior developer; it’s the junior. Act accordingly.
• Start with refactoring and tests. These are tasks where AI assistance has the highest hit rate and lowest risk.
• Don’t fight the terminal. If you’re a GUI person, give the CLI workflow an honest week before judging it.

The first day with Claude Code won’t make you 10x productive. But it will show you a fundamentally different way of working with code, one where you spend more time thinking about what to build and less time grinding through how to build it.