New to AI-Assisted Coding

A gentle introduction for developers who've never used AI assistants. You'll learn what AI-assisted coding actually is, run your first session, and build the mental model that makes everything else click.

The key mental shift:

Think of yourself as a manager of a knowledgeable but occasionally confused intern who reads documentation really fast.

What AI-Assisted Coding Actually Is

AI-assisted coding is collaboration, not automation. You're still the architect, decision-maker, and quality gatekeeper. Claude is a capable assistant that can write code, explain concepts, and explore solutions, but it needs your guidance and verification.

This isn't a replacement for understanding your code. It's a force multiplier for developers who already think carefully about what they're building. The AI handles the typing; you handle the thinking.

✓

What it's good at

  • Generating boilerplate and repetitive code
  • Explaining unfamiliar code or concepts
  • Implementing well-defined, scoped tasks
  • Refactoring and improving existing code
  • Writing tests for functions you describe
  • Exploring solutions you can then evaluate
✗

What it's not

  • A replacement for understanding your code
  • Infallible or all-knowing
  • Good at maintaining large-scale architecture
  • Able to remember context indefinitely
  • A substitute for testing and verification
  • Magic (it's a tool that needs skilled use)
💡 The Right Mental Model

Claude is like a brilliant intern who just started. They have encyclopedic knowledge but no context about your specific project. They'll work fast and confidently, sometimes too confidently. Your job is to provide direction, review their work, and catch mistakes.

💡 Learning by Doing

Theory only goes so far. The fastest way to build intuition is to experiment. Try things, see what happens, and don't worry about 'breaking' anything (you have version control). The Try This boxes throughout this guide give you concrete starting points, but feel free to go off-script.

Your First Claude Code Session

Let's get you running Claude Code for the first time. This walkthrough assumes you have Claude Code installed. If not, install it first with npm install -g @anthropic-ai/claude-code.

Step 1: Open your terminal and start Claude

Navigate to a project directory, any project where you want to try AI assistance.

Try This

Start Claude Code:

❯ claude

You'll see Claude's interface appear. It's ready for your first request.

Step 2: Start with exploration, not coding

Your first instinct might be to ask Claude to write code immediately. Resist that urge. The best first request is asking Claude to understand something.

Try This

Ask Claude to explore your codebase:

❯ What does this project do? Look at the main files and give me a summary.

This does two things: it gives Claude context about your project, and it shows you how Claude thinks about code. Read its response carefully. Does it match your understanding?

Step 3: Ask something specific

Now try a focused question about code you're curious about.

Try This

Ask about specific code:

❯ Explain how the authentication flow works in this project. Walk me through what happens when a user logs in.

Notice how Claude navigates files, reads code, and synthesizes an explanation. This is the basic interaction pattern you'll use constantly.

Step 4: Make a small change

For your first edit, choose something low-stakes, a small improvement you can easily verify.

Try This

Request a small, verifiable change:

❯ Add a comment to the login function explaining what each step does.

After Claude makes the change, read what it did. Does the explanation make sense? Is it accurate? This review habit is essential.

⚠️ Start Small

Your first few sessions should focus on small, verifiable tasks. Don't try to build a new feature or refactor major code until you've developed intuition for what Claude does well and where it struggles.

The Basic Loop

Every effective AI-assisted coding session follows this pattern:

1

Ask

Give Claude a clear, scoped request. The more specific, the better. Include context about what you're trying to achieve, not just what you want it to do.

Vague: "Fix the login bug"
Better: "The login function in src/auth.js throws an error when the password is empty. Add validation that returns a helpful error message instead of crashing."
2

Review

Read and understand what Claude produces. Don't just glance. Actually trace through the logic. Could you explain this code to a colleague? If not, you don't understand it yet.

Ask yourself: Does this do what I asked? Does it handle edge cases? Would I write it this way?
3

Refine

Ask for changes or clarifications. Claude's ability is uneven: it might nail five tasks in a row, then make a rookie mistake on the sixth. The refinement step is where you shape output into exactly what you need.

"That's close, but also handle the case where the email is malformed. And use our existing validation library instead of regex."
4

Verify

Test that the code actually works. Run the tests. Try it manually. Check edge cases. Trust is built through verification, not assumption.

Run your test suite. Try the feature in the browser. Check the logs. This step catches the mistakes that looked correct on paper.
💡 Don't Skip Review

The review step is where learning happens. If you accept code without understanding it, you'll hit problems later that you can't debug. You're building a codebase you'll need to maintain. Make sure you understand what's in it.

💡 Extended Thinking

In Claude Code, including the word 'think' in your prompt triggers extended reasoning. 'Think' gives basic extended thinking, 'think hard' or 'think deeply' gives more, and 'ultrathink' gives maximum reasoning budget. Use these for architecture decisions, tricky bugs, or any time you want Claude to slow down rather than jump to implementation.

Common First-Timer Mistakes

Everyone makes these mistakes when starting out. Recognizing them will save you hours of frustration.

🚫

Asking for too much at once

The mistake: "Build me a todo app with user authentication, real-time sync, and offline support."
The fix: Break it down. Start with "Create a function that adds a todo item to an array." Then build up piece by piece. Large tasks fail because Claude can't hold all the requirements in context simultaneously.
🚫

Accepting code without understanding

The mistake: Claude writes 50 lines, you paste it in, it works, you move on. Two weeks later, something breaks and you have no idea why.
The fix: Always ask "Can you explain how this works?" if anything is unclear. Treat generated code like code from a new team member. You need to understand it before accepting it.
🚫

Not providing enough context

The mistake: "Fix the bug" with no information about what file, what behavior, or what you expected.
The fix: Tell Claude about your project structure, constraints, and goals. Point it at relevant files: "Read src/auth.js first to understand how we handle sessions." Claude can only work with what you give it.
🚫

Giving up after one bad response

The mistake: Claude misunderstands your request, you conclude AI coding doesn't work, you give up.
The fix: Refine your request or provide more context. Claude improves dramatically with clearer instructions. Say what was wrong and what you actually wanted. Most failed requests are communication failures, not capability failures.
🚫

Letting Claude run without supervision

The mistake: You give Claude full autonomy, walk away, come back to find it made 20 files and solved the wrong problem.
The fix: Stage your work explicitly. Ask Claude to read and understand first. Have it propose a plan. Only then let it implement. This prevents expensive wrong-direction work.
Try This

Practice the staged approach:

❯ Read the files in src/components/ and understand how we structure React components. Don't write any code yet. Just explain the patterns you see.

Planning Mode: Your Safety Net

For anything beyond simple changes, planning mode is essential. It's how you manage larger changes without losing control.

Enter planning mode with /plan or by pressing Shift+Tab twice. In this mode, Claude proposes changes and explains its approach before executing anything. You review, refine, and approve the plan before any code is written.

✓

Why use planning mode

  • See what Claude intends before it acts
  • Catch misunderstandings early
  • Break large tasks into reviewable steps
  • Manage context more effectively
  • Build confidence in the approach before committing
💡

When to use it

  • Any change touching more than one file
  • When you're not sure how to approach a task
  • Before refactoring or restructuring
  • When Claude might have multiple ways to solve something
  • Any time you want to think before acting
Try This

Try planning mode:

❯ I want to add user authentication to this app. Enter planning mode and propose how you'd approach this. Don't write code yet.
💡 Git Checkpoints

Commit good results before moving to the next step. If something goes wrong later, you can always revert. Small commits create safe checkpoints for complex work.

Building Confidence Gradually

Learning AI-assisted coding is a skill. Like any skill, it develops through practice and graduated difficulty. Here's a progression that works.

The most important thing: actually use the tool. Reading guides is useful, but real learning happens when you're in a session, trying things, making mistakes, and discovering what works. The "Try This" boxes throughout this guide aren't optional. They're the curriculum. Each one is designed to teach you something through direct experience.

Week 1: Understanding and Explanation

Focus on using Claude to understand code, not write it. Ask Claude to explain functions, trace data flow, and summarize modules. This builds your intuition for how Claude reads code and whether you can trust its analysis.

Try This

Start with explanation:

❯ Explain what happens when I call the handleSubmit function. Trace through all the functions it calls.

Week 2: Low-Stakes Modifications

Graduate to small changes where the impact is obvious and reversible. Add comments, improve variable names, write tests for existing functions. You can easily verify these and undo if needed.

Try This

Try a low-stakes change:

❯ Add JSDoc comments to all the exported functions in src/utils.js. Include parameter types and return values.

Week 3: Bounded Feature Work

Take on small, well-defined features. Add a new utility function. Implement a single API endpoint. Create a new component from a clear specification. These have clear success criteria.

Try This

Attempt bounded features:

❯ Create a new function called formatCurrency that takes a number and returns a string with proper currency formatting. Include tests.

Week 4: Integrated Workflows

Start combining Claude's capabilities: explore code, plan an approach, implement it, write tests, review. This is the full loop you'll use for real work.

💡 Track What Works

Keep notes on what kinds of requests work well and which ones don't. Over time, you'll develop a personal sense for how to phrase things and what Claude needs to succeed.

When AI Helps vs. When It Doesn't

AI-assisted coding isn't always the right tool. Knowing when to use it (and when not to) is part of the skill.

✓

AI helps most when...

  • The task is well-defined with clear success criteria
  • You can verify the output quickly (tests, type checking, visual inspection)
  • The problem has known patterns (CRUD operations, standard algorithms)
  • You need to explore or understand unfamiliar code
  • You're doing repetitive transformations across many files
  • You want a starting point to iterate from
✗

AI struggles when...

  • Requirements are vague or keep changing
  • The task requires deep understanding of business logic
  • You're working across many files with complex dependencies
  • The problem requires novel architectural decisions
  • Correctness depends on implicit knowledge only you have
  • You can't easily verify whether the output is right

The Golden Rule

If you can explain exactly what you want and verify whether you got it, AI can probably help. If you're still figuring out what you want, or can't tell if the result is correct, you need to think more before involving AI.

💡 Start with Your Strengths

Use AI first in areas where you're already confident. You'll be better at reviewing the output and catching mistakes. As you build trust, you can expand into less familiar territory.

Where to Go Next

⚡
5-Minute Overview Essential concepts in a quick read
⚙️
Setting Up on a Codebase Configure CLAUDE.md for your project
🔄
Troubleshooting When things go wrong, look here
🧠
Mental Models Deeper understanding of why it works