All posts

Mastering Claude Code (Part 1): Getting Started — From Zero to Productive in 15 Minutes

claude-codeaitutorialbeginner

When I first heard about Claude Code, I thought it was just another AI chatbot for coding questions. I was wrong. It’s completely different, and honestly, it’s changed how I build at ZenoLab.

This is Part 1 of a six-part series called Mastering Claude Code. By the end, you’ll understand how to use Claude as a full development partner—not just for quick questions, but for building entire features, debugging, refactoring, and shipping faster. Let’s start with the fundamentals.

What Claude Code Actually Is

Claude Code is a command-line tool that lets you interact with Claude (Anthropic’s AI) directly in your terminal. It’s agentic—meaning Claude can see your codebase, understand context, make changes, and reason through problems with real dependencies and constraints.

Here’s what it’s not: It’s not a code generator that writes boilerplate. It’s not a documentation chatbot. It’s not a replacement for thinking.

Here’s what it is: A senior programmer sitting next to you who can read your entire project, understand your architecture, propose changes, write tests, debug errors, and iterate until something works. It runs right in your terminal, it has memory across sessions, and it can interact with your file system directly.

I use Claude Code to build and maintain all 19 applications in the ZenoLab app catalog. It’s the closest thing I have to a full development team.

Why This Matters for Indie Developers

Let me be direct: indie development is lonely. You don’t have a senior engineer to rubber-duck with. You don’t have teammates to review your code. You’re making architectural decisions alone, debugging at midnight alone, and shipping without a safety net.

Claude Code solves the loneliness problem without adding overhead. It’s:

  • Available instantly. No waiting for code review, no Slack back-and-forth.
  • Context-aware. It reads your project, understands your patterns, and makes suggestions that fit your codebase, not generic advice.
  • Fast. A 10-minute conversation beats a 2-hour Slack debate.
  • Iterative. You can propose, refine, reject, and try again without ego or friction.

I’ve cut my feature development time by 30-40% using Claude Code effectively. That directly translates to shipping more, shipping faster, and having time to actually maintain projects instead of being buried in them.

The 5-Minute Setup

First, install Claude Code. You’ll need Node.js 18+ and npm.

npm install -g @anthropic-ai/claude-code

Create an Anthropic API key at console.anthropic.com. Set it as an environment variable:

export ANTHROPIC_API_KEY="sk-ant-..."

(Add this to your .bashrc or .zshrc to make it permanent.)

That’s it. You’re ready.

Navigate to any project directory and run:

claude

You’ll see Claude waiting for input. Type a question or task. Claude reads your codebase and responds. You can continue the conversation in the same session.

The Mental Model: Senior Pair Programmer, Not Code Generator

Here’s the mindset shift that matters:

Don’t think of Claude Code as a code generator. Don’t think “I’ll ask Claude to write this function and I’ll paste it in.” That’s not how senior programmers work, and Claude Code isn’t designed for that.

Think of it as a pair programmer. You:

  1. Describe what you need or what’s broken
  2. Claude asks clarifying questions or proposes an approach
  3. You discuss tradeoffs and constraints
  4. Claude writes code, tests, or refactoring
  5. You review, iterate, and ship

The difference is collaboration, not automation. Claude Code shines when you’re thinking together—bouncing ideas, catching problems before they’re written, and making decisions as a team (even though the team is one human and an AI).

I use it for:

  • Architecture discussions. “I’m redesigning the auth flow. Here’s my constraint… what am I missing?”
  • Feature implementation. “I need a form validator for this schema. We use [zod], here’s the schema.”
  • Debugging. “This test is failing. Here’s the error. Here’s the code. What’s wrong?”
  • Refactoring. “This module grew too big. What would you break it into?”
  • Migration. “I want to move from [X] to [Y]. Here’s why. How would you approach it?”

Basic Usage Patterns

Interactive Mode (the Default)

claude

You get a live conversation. Claude has memory across your entire session. You can reference previous messages, follow up, and iterate. This is where most of the thinking happens.

claude -p "Add TypeScript types to this function" < my_file.ts

Claude outputs once and exits. Useful for quick questions or piping into other commands. The -p flag means “print and exit.”

Piping Input

Claude reads from stdin. Useful in shell pipelines:

cat complex-error.log | claude -p "What went wrong here?"

Or with file input:

claude -p "Write unit tests for this" < utils.ts

Resuming Sessions

Claude automatically saves sessions. List them:

claude --list

Resume a specific session:

claude --session your-session-name

Session Management

You can rename, fork, or clean up sessions:

claude --rename old-name new-name
claude --fork session-name new-name
claude --delete session-name

Forking is useful when you want to explore a different approach without losing the original work.

Permission Modes

By default, Claude suggests changes but doesn’t make them. You decide when to apply them. There are a few modes:

Default: --mode=ask (Explicit Approval)

claude --mode=ask

Claude proposes changes. You see a prompt for each one. You can review before accepting. This is safest and gives you full control. I use this 80% of the time.

Auto-Apply: --mode=acceptEdits

claude --mode=acceptEdits

Claude writes changes directly to your files without asking. Faster, but only use this when you’re confident and have git backing you up.

Plan First: --mode=plan

claude --mode=plan

Claude outlines its approach before making changes. Good for big refactors where you want to review the plan first.

No-Dialog: --mode=dontAsk

claude --mode=dontAsk

Claude acts silently. It applies changes without showing prompts. Useful for automated workflows but potentially risky.

My recommendation: Start with --mode=ask. You learn more, you keep control, and you avoid surprises. Once you’re comfortable with Claude Code’s style, experiment with the faster modes.

Session Management for Real Work

Here’s how I actually work:

  1. Start a session when I’m tackling a feature or bug:

    claude --session feature/user-auth

  2. Iterate in the session. Multiple back-and-forths. Claude builds memory of the problem, the code, the constraints.

  3. When it’s done, the session stays. If I need to revisit it later:

    claude --session feature/user-auth

  4. I can fork if I want to explore a different approach without losing the original:

    claude --fork feature/user-auth feature/user-auth-v2

  5. I delete old sessions when they’re stale:

    claude --delete feature/old-idea

Sessions are your memory. They’re gold. Don’t delete them hastily.

A Quick Example

Let me show you what a real Claude Code session looks like:

$ claude --session feature/dark-mode

Me: "I'm adding dark mode to my React app. Here's my color config. What's the best way to switch themes?"

Claude: [reads the file] "I'd suggest using Context API with a custom hook.
Here's a theme provider component... [shows code]"

Me: "That looks good. Can you write the CSS module to go with it?"

Claude: [writes the CSS module]

Me: "Perfect. Now add a toggle button to the navbar."

Claude: [adds the toggle]

Me: "Great. Write a test for the theme switching."

Claude: [writes the test]

Me: "Done. Thanks!"

That whole flow took 10 minutes. It would have taken me an hour solo.

What’s Next?

You’re now up and running with Claude Code. You understand the basics:

  • It’s a pair programmer, not a code generator
  • You interact via your terminal
  • Sessions persist and have memory
  • You control what gets applied

In Part 2, we’ll dive into Slash Commands & Memory—the features that let you organize sessions, attach context, and give Claude real knowledge about your project.

For now, try this: Open a project you’re actively working on. Run claude. Ask Claude to review a file you wrote recently. Have a real conversation about it. Get a feel for how it thinks and how it complements your thinking.

That’s the actual skill—learning to work with Claude Code, not just get code from it.

Happy coding. I’ll see you in Part 2.

Using Claude Code to build at ZenoLab? Check out the app catalog to see the 19 applications I’ve built with this workflow, and explore the blog for deeper dives into development patterns and tools.

More from the studio.

Back to blog