USING CLAUDE CODE

You've got it configured. Now let's actually use it.

Starting a Session

Always start from your project directory:

cd ~/my-project
claude

Claude Code reads the current directory structure. Starting from the wrong place means it doesn't know about your files.

The Interface

You'll see a prompt:

>

That's it. Type your request. Press Enter. Wait.

With local models, responses take 30-120 seconds. Get used to it.

Basic Requests

Simple question:

> What does lib/Server.pm do?

Claude reads the file and explains it.

Code generation:

> Create a Perl module that fetches RSS feeds

Claude writes the code and creates the file.

Editing:

> Fix the bug in line 42 of app.pl

Claude reads the file, identifies the issue, and edits it.

Running commands:

> Run the tests and tell me what failed

Claude executes "prove -l t/" (or whatever test command fits) and reports results.

Being Specific

Vague requests get vague results. Be specific:

BAD:  "Fix the bug"
GOOD: "Fix the authentication bug where users get 500 errors on login"

BAD:  "Make it faster"
GOOD: "Optimize the database queries in User.pm - they're doing N+1"

BAD:  "Write tests"
GOOD: "Write tests for the Token.pm module, covering valid tokens,
       expired tokens, and malformed input"

Multi-Step Tasks

Claude Code handles multi-step tasks naturally:

> Create a new REST endpoint for user profiles:
> 1. Add a route in the main app
> 2. Create a controller method
> 3. Write a database model function
> 4. Add basic tests

It works through each step, creating and editing files as needed.

@ Mentions

Reference files explicitly with @:

> Look at @lib/Auth.pm and @lib/Token.pm - why is auth failing?

This ensures those specific files get read into context.

You can also @ directories:

> Explain the structure of @lib/Controller/

Watching Files Change

As Claude edits files, you can watch in real-time. Open another terminal and use your editor's auto-reload, or:

watch -n 1 cat lib/Module.pm

See changes as they happen.

Canceling

If Claude is generating garbage, press Ctrl+C to cancel.

You won't lose the conversation. Just interrupt the current response.

Regenerating

If a response is bad:

> Regenerate

Or be more specific:

> Try again but use a simpler approach

Editing Responses

Claude writes something almost right? Edit the result:

> In your last response, change the function name from "process" to
> "handleRequest"

Staying in Context

Don't repeat yourself. Claude remembers the conversation:

> Create a login endpoint

[Claude creates it]

> Now add rate limiting to it

Claude knows "it" refers to the login endpoint you just discussed.

When To Start Fresh

Start a new session when:

• Switching to a completely different topic
• Context is getting full (/context shows 70%+)
• Claude seems confused about what you want
• You're starting a new day's work > /clear

Or just quit and restart:

Ctrl+D to exit
claude to restart

Session Management

Continue where you left off:

claude --continue

Resume a specific past session:

claude --resume

These are useful when you had to close the terminal but want to keep working on the same thing.

Good Habits

1. Start with context

Before diving into changes, let Claude understand:

> Read @lib/App.pm and explain the architecture

2. One thing at a time

Don't cram multiple unrelated tasks into one request:

BAD:  "Fix the bug and also add a new feature and refactor auth"
GOOD: "Fix the login bug" [done] "Add the feature" [done] "Refactor"

3. Verify before continuing

After Claude makes changes, check they work:

> Run the tests

Don't keep building on broken code.

4. Use /compact proactively

Don't wait until you hit the wall:

> /compact

After every major milestone, compress context.

What Claude Code is Good At

• Reading and explaining code
• Writing new modules/functions
• Refactoring existing code
• Writing tests
• Fixing bugs when you describe them
• Running commands and interpreting output
• Multi-file changes that stay consistent

What It's Bad At

• Guessing what you want from vague requests
• Very long files (context fills up)
• UI/visual design work
• Tasks requiring real-time internet access
• Security-critical decisions (always review)

Speed Expectations

With local models:

Simple question: 20-40 seconds
Code generation: 60-120 seconds
Large refactor: 2-5 minutes

The model is thinking. Let it think. Don't spam requests.

Summary

Start:    cd project && claude
Talk:     Natural language requests
Files:    Use @ to reference specific files
Context:  /context to check, /compact to compress
Cancel:   Ctrl+C
Exit:     Ctrl+D or "exit"
Resume:   claude --continue

Next chapter: Power user features.