---
title: "10 Mistakes Everyone Makes with Claude Code"
description: "The same errors show up repeatedly. Here's what goes wrong, why it happens, and how to fix it."
pillar: "Claude Code"
level: "intermediate"
date: "2026-01-20"
url: "https://theglitch.ai/academy/claude-code/claude-code-mistakes"
---

# 10 Mistakes Everyone Makes with Claude Code

The same errors show up repeatedly. Here's what goes wrong, why it happens, and how to fix it.


# 10 Mistakes Everyone Makes with Claude Code

> **The Glitch's Take:** "Everyone makes these mistakes. The difference is how long it takes you to stop making them."

**Part of:** [The Complete Guide to Claude Code](/articles/claude-code/claude-code-complete-guide)
**Level:** Intermediate
**Reading Time:** 10 minutes

---

## The Point

Claude Code has a learning curve. Not because it's complicated, but because the instincts that work with traditional tools don't transfer cleanly. These 10 mistakes appear repeatedly across skill levels. Knowing them saves you the trial and error.

---

## TL;DR

1. No CLAUDE.md (context starvation)
2. Vague instructions (output lottery)
3. Massive prompts (cognitive overload)
4. Never reviewing output (blind trust)
5. Wrong model for task (money wasted or quality lost)
6. Fighting the tool (forcing unnatural workflows)
7. No iteration (expecting perfection)
8. Ignoring errors (hoping problems disappear)
9. Context overload (too much at once)
10. Not using it for real work (perpetual experimenter)

---

## Mistake 1: No CLAUDE.md

### What Happens

Claude Code guesses about your project. It creates files in wrong directories. Uses conventions that don't match yours. Asks questions it shouldn't need to ask.

### Why It Happens

CLAUDE.md feels optional. It's not marked as required. You can start using Claude Code without it.

### The Fix

Create CLAUDE.md before your first task. Even a minimal one helps:

```markdown
# CLAUDE.md

## Project: [Name]
- Type: [Web App/API/CLI]
- Language: [Primary]
- Framework: [Framework]

## Commands
- Dev: `npm run dev`
- Test: `npm run test`
- Lint: `npm run lint`

## Structure
[List key directories]

## Conventions
[Top 3-5 rules]
```

Time investment: 15 minutes. Improvement: 2-3x accuracy.

Full guide: [Building Your Context Layer](/articles/claude-code/building-context-layers)

### Impact

| With CLAUDE.md | Without |
|----------------|---------|
| 70-90% first-attempt accuracy | 40-50% |
| 1-2 iterations | 4-6 iterations |
| Correct conventions | Generic conventions |

---

## Mistake 2: Vague Instructions

### What Happens

You get output that technically matches what you said but doesn't match what you meant.

### Why It Happens

Natural language is ambiguous. "Make this better" means nothing specific. Claude Code does its best interpretation, which may not be yours.

### The Fix

Be specific about outcomes, not implementation:

**Bad:**
```
Make the login page better.
```

**Good:**
```
Update the login page:
- Add password visibility toggle
- Show inline validation errors (not alerts)
- Add "remember me" checkbox
- Match the styling of /signup page

Keep the existing form submission logic.
```

### The Pattern

1. **What to change** — specific elements
2. **How it should work** — behavior requirements
3. **What to preserve** — constraints
4. **Reference** — examples of desired outcome

---

## Mistake 3: Massive Prompts

### What Happens

You write 500 words with 10 requirements. Claude Code addresses 7 of them. You iterate 5 times to get the last 3.

### Why It Happens

Complex tasks feel like they need complex prompts. They don't. They need sequenced prompts.

### The Fix

Break into phases:

**Instead of:**
```
Build a user authentication system with signup, login, password reset,
email verification, session management, rate limiting, and admin controls.
Use JWT, integrate with our existing database, add tests, update docs.
```

**Do this:**
```
Phase 1: "Create basic signup and login forms. Use JWT for sessions.
Follow patterns in /app/api/. No email verification yet."

Phase 2: "Add password reset flow. Email template in /templates/."

Phase 3: "Add email verification on signup."

Phase 4: "Add rate limiting to auth endpoints."

Phase 5: "Write tests for all auth endpoints."
```

Each phase: clear scope, verifiable outcome, builds on previous.

---

## Mistake 4: Never Reviewing Output

### What Happens

You tell Claude Code to implement something. It does. You commit it. It has bugs, security issues, or doesn't match your patterns.

### Why It Happens

Autonomous feels like "done without me." It isn't. It's "done with less of me."

### The Fix

Review before commit:

1. **Read the diff** — Understand what changed
2. **Check the logic** — Does it do what you intended?
3. **Run tests** — Verify behavior
4. **Check patterns** — Does it match your codebase?

Claude Code is a fast junior developer, not an infallible senior. Supervision required.

### Review Checklist

- [ ] Changes match my request
- [ ] No obvious logic errors
- [ ] Error handling exists
- [ ] No hardcoded secrets
- [ ] Tests pass
- [ ] Follows project conventions

---

## Mistake 5: Wrong Model for Task

### What Happens

You use Opus for renaming a variable (expensive). You use Sonnet for complex architecture decisions (inadequate).

### Why It Happens

One model works, so you use it for everything. Switching feels like overhead.

### The Fix

Match model to task:

| Task | Model | Why |
|------|-------|-----|
| Simple edits | Sonnet | Fast, cheap, sufficient |
| Routine features | Sonnet | Good enough quality |
| Complex reasoning | Opus | Needed for quality |
| Architecture decisions | Opus | Worth the cost |
| Debugging hard issues | Opus | Better problem-solving |
| Tests, docs | Sonnet | Pattern-following work |

Opus costs more per token. Using it for everything wastes money. Using Sonnet for everything sacrifices quality on complex work.

---

## Mistake 6: Fighting the Tool

### What Happens

You try to make Claude Code work like Copilot (line-by-line autocomplete). Or like a text editor. Or like a human pair programmer who shares your exact mental model.

### Why It Happens

Previous tool habits. Expectations from other AI tools.

### The Fix

Work with Claude Code's strengths:

**Claude Code is good at:**
- Multi-file coordinated changes
- Following documented patterns
- Iterating based on feedback
- Explaining what it did and why

**Claude Code is not good at:**
- Real-time autocomplete
- Reading your mind
- GUI interactions
- Tasks you can't describe

If a task feels awkward, you're probably approaching it wrong. Try a different angle.

---

## Mistake 7: No Iteration

### What Happens

First output isn't perfect. You conclude Claude Code doesn't work and give up. Or you accept subpar output because iterating feels like failure.

### Why It Happens

Expectation of one-shot perfection. Treating iteration as inefficiency.

### The Fix

Expect 2-4 iterations. That's normal.

```
First prompt: "Build X"
Output: 70% right

Second prompt: "Good, but change Y and Z"
Output: 90% right

Third prompt: "Fix the edge case where..."
Output: Done
```

Three iterations taking 3 minutes each beats one hour of manual work.

### Iteration Phrases

- "Good, but..."
- "Change X to Y"
- "Keep everything except..."
- "Add handling for..."
- "Make it match the pattern in..."

---

## Mistake 8: Ignoring Errors

### What Happens

Claude Code reports an error. You tell it to try again without reading the error. Repeat 5 times. Same error.

### Why It Happens

Errors feel like Claude Code's problem. They're usually your project's problem.

### The Fix

Read error messages. Act on them.

```
Claude: "npm install failed with ENOENT"

Bad response: "Try again"

Good response: "The package.json is missing. Create it first with
these dependencies: [list], then run install."
```

Claude Code can fix errors, but it needs to know you understand the problem. Otherwise it guesses, and guessing loops.

---

## Mistake 9: Context Overload

### What Happens

You paste an entire codebase worth of context. Or 50 requirements. Claude Code gets confused, misses things, or produces inconsistent output.

### Why It Happens

More context seems better. It isn't always.

### The Fix

Provide relevant context, not all context.

**Instead of:** Pasting 10 files

**Do:** Reference specific files that Claude Code should read

```
"Look at the pattern in /lib/api/users.ts and create the same
structure for /lib/api/products.ts"
```

Claude Code reads files itself. Your job is pointing, not copying.

### Context Hierarchy

1. CLAUDE.md (always present)
2. Referenced files (Claude reads when needed)
3. Conversation context (builds during session)
4. Pasted content (only when necessary)

---

## Mistake 10: Not Using It for Real Work

### What Happens

You "test" Claude Code on toy projects. Demo apps. Tutorial exercises. You never graduate to production code.

### Why It Happens

Fear of breaking things. Imposter syndrome. Waiting until you "understand it better."

### The Fix

Use it on real work. Today.

Start with low-stakes production tasks:
- Add a feature nobody is waiting for
- Fix a minor bug
- Write tests for existing code
- Refactor internal-only code

Build confidence through practice, not theory.

### The Math

| Hours studying Claude Code | Productivity gained |
|----------------------------|---------------------|
| 10 hours tutorials | 0 (no real usage) |
| 10 hours real work | 10+ hours saved going forward |

Learning happens by doing.

---

## Quick Reference

### The Mistake → Fix Cheatsheet

| # | Mistake | Fix |
|---|---------|-----|
| 1 | No CLAUDE.md | Create one in 15 minutes |
| 2 | Vague instructions | Specific outcomes + constraints |
| 3 | Massive prompts | Phase into 3-5 step sequences |
| 4 | Never reviewing | Review diff before commit |
| 5 | Wrong model | Match model to task complexity |
| 6 | Fighting tool | Work with its strengths |
| 7 | No iteration | Expect 2-4 rounds |
| 8 | Ignoring errors | Read and address them |
| 9 | Context overload | Reference, don't paste |
| 10 | No real work | Use on production today |

### Self-Assessment

How many of these are you currently making?

- 0-2: You're using Claude Code effectively
- 3-5: Room for improvement
- 6-8: Significant gains available
- 9-10: Start with mistakes 1 and 10

---

## Next Steps

- [Building Your Context Layer](/articles/claude-code/building-context-layers) — Fix mistake #1
- [Claude Code + MCP Integration](/articles/claude-code/claude-code-mcp-integration) — Advanced usage
- [Back to Claude Code Guide](/articles/claude-code/claude-code-complete-guide)

---

## Sources

- [Anthropic Claude Documentation](https://docs.anthropic.com)
- The Glitch's observations from 200+ Claude Code sessions

---

*Last verified: 2026-01-20. Based on common patterns observed across beginner to advanced users.*