12 Months of Claude Code Lessons in 45 Minutes

Introduction and Course Overview

AI with Avthar distills a full year of hands-on Claude Code experience into 52 concrete lessons, organized so any developer can level up fast.

What This Guide Covers

Built from "12 months of using Claude Code to build real applications," the guide moves through three levels:

• Beginner — foundations: installation, models and modes, and the Claude.md file
• Intermediate — customization: custom commands, agent skills, MCPs, and feature-build workflows
• Master — advanced: parallel Claude Code instances, autonomous iteration loops, async task delegation, and PR-ready handoffs

Why the Three-Level Structure Matters

Each level builds on the last. Beginners who skip foundations tend to hit walls at the intermediate stage; power users who never formalized their workflows miss the multiplier that comes from master-level techniques. The structure ensures you pick up the right mental model before adding complexity.

The Promise

AI with Avthar frames the guide as a shortcut: "I'm going to save you 12 months of pain by sharing 52 specific lessons." Whether you've never run Claude Code or already use it daily, every level contains at least one lesson that changes how you build.

Installation and Access Options

Getting Claude Code running takes minutes regardless of where you prefer to work — terminal purist, app fan, IDE devotee, or mobile developer on the move.

Tip 1 · Use the Terminal

The default path for most developers. Copy the install command from the Claude Code docs, paste it into your terminal, and you're coding immediately. Claude Code also installs cleanly on remote servers — SSH into AWS, DigitalOcean, or Hetzner and set it up just as you would Python or Node, which is ideal for backend work where you want to operate directly on the server.

claude              # start a fresh session
claude --resume     # continue a previous session

Tip 2 · Use the Desktop App

If the terminal feels like a barrier, the Claude desktop app delivers the full Claude Code experience in a familiar chat-style interface — no command-line knowledge required. AI with Avthar calls it "the easiest way to get started" for complete beginners who want to build right away without a learning curve.

Tip 3 · Run Inside Your IDE

For VS Code, Cursor, or Windsurf users, there are two routes:

• VS Code extension — an integrated UI with buttons and menus for Claude Code's modes and settings.
• Terminal panel — open a terminal inside your IDE and run claude there. This is AI with Avthar's preferred approach.

Both options let you edit files and view Claude's changes side by side, keeping you inside the tools you already trust.

Tip 4 · Web and Mobile for On-the-Go Work

The Claude Code web and mobile apps let you kick off work from anywhere — start a new feature, file a bug fix, or ask a question about your codebase and let Claude make progress while you're away from your desk. When you're ready to dig in, you can "teleport sessions from the web app to your local terminal" to test and modify the results.

Models, Modes, and Plans

Choosing the right model, plan, and workflow mode makes a measurable difference in how fast you ship with Claude Code.

Tip 5 · Use the Best Model You Can

Claude Code offers three models with different cost-performance tradeoffs:

• Opus — most powerful, most expensive; fewest mistakes
• Sonnet — solid middle ground between intelligence and cost
• Haiku — fastest and cheapest, best for lightweight tasks

AI with Avthar's default is Opus. Even though it's slower, it makes fewer errors, so you spend less time debugging and steering — which means you actually move faster overall. If rate limits are a concern, use Sonnet as your everyday driver and "save Opus for the most complex or important tasks."

Tip 6 · Get a Max Plan If You're Serious

Claude Code is only available on paid plans:

• Pro ($20/mo) — a solid starting point for exploration
• Max 5× ($100/mo) — 5× higher rate limits
• Max 20× ($200/mo) — 20× higher rate limits plus early access to new Anthropic products
• API pricing — available but "way too expensive for individual use" unless your employer covers it

AI with Avthar's advice is straightforward: start with Pro, upgrade to a Max plan once you're building in earnest, and don't overthink it. The productivity gains from headroom outweigh the subscription cost.

Core Modes and Built-in Tools

Claude Code ships with a set of built-in modes and tools that, used well, dramatically improve output quality and reduce wasted iteration.

Tip 7 · Use Plan Mode — and Iterate on the Plan

Plan mode lets you review Claude's proposed approach before a single line of code is written. The key habit is not just entering plan mode, but treating the plan as a draft: push back, refine, and only approve when you're genuinely satisfied.

Tip 8 · Get Claude to Ask You Questions

At the start of any significant task, instruct Claude to use the ask user question tool. This surfaces decisions you haven't fully considered — architecture trade-offs, edge cases, scope boundaries. AI with Avthar calls it "incredibly useful because it helps Claude surface things you might not have fully thought through." The answers give both you and Claude clarity before work begins.

Tip 9 · Let Claude Handle Bash Commands

Claude's bash tool lets it run shell commands directly — reading and writing files, searching the codebase, running git operations. You stay in control by approving commands individually or by setting permission rules. There's also a bash mode for running commands inside Claude Code without exiting, handy for quick navigation or git operations.

Tip 10 · Use Extended Thinking Mode

Extended thinking gives Claude a scratch pad for deeper reasoning before it responds. Reach for it on complex problems where a fast answer is likely to be shallow — architectural decisions, tricky bugs, or multi-step refactors.

Tip 11 · Invoke the Explore Sub-Agent for Codebase Search

The explore sub-agent is built for rapid context gathering. It runs on Haiku under the hood, making it fast and cheap. Claude triggers it automatically when it detects exploration is needed, but you can also call it explicitly. Useful scenarios:

• Getting up to speed on an unfamiliar project
• Writing an architecture.md or other documentation
• Understanding the codebase before implementing a new feature

# Explicitly invoke exploration before a large task
> Use the explore sub-agent to map the structure of /src before we begin.

Claude.md and Context Management

A well-structured CLAUDE.md and disciplined context management are the two habits that separate productive Claude Code sessions from frustrating ones.

Tip 12 · Build a Lean CLAUDE.md

Your CLAUDE.md is Claude's operating manual for your project. Keep it concise by linking out to deeper documents rather than embedding everything in it — architecture specs, project requirements, and design docs can live in separate files that Claude pulls in only when needed.

To create one from scratch:

/init          # auto-generates a CLAUDE.md from your project

Alternatively, ask Claude directly to create a CLAUDE.md and use the "ask user question tool to interview you for extra information to populate it." That interview approach surfaces preferences you might forget to write down manually.

Tip 13 · Actively Manage Your Context Window

Each session has a finite context window. Filling it with stale back-and-forth from earlier tasks degrades results on new ones. AI with Avthar recommends treating context hygiene as a core skill, not an afterthought.

Key practices:

• Run /clear liberally once you finish a chunk of work — it resets context without ending the session.
• Run /context to see exactly how much of the window your messages, MCPs, and plugins are consuming.
• Avoid auto-compaction. When Claude runs out of context it tries to compress the conversation, but "important details can get lost" and results measurably suffer afterward.
• Start a fresh session for genuinely new tasks rather than carrying old context forward.

/clear      # reset context mid-session
/context    # inspect current context usage

The decision of when to clear is straightforward once you internalize it:

Debugging, Git, and Prompting

Effective debugging and prompting habits separate productive Claude Code sessions from frustrating ones. Tips 14–21 cover session recovery, terminal customization, and the prompting mindset that gets the best results.

Tip 14–17 · Checkpoints and Git (Recap Context)

Checkpoints let you rewind code, context, or both — but they are "not a replacement for git." Use them for quick session-level recovery only. Keep git and GitHub in place for overall project version control.

Tip 18 · Customize Your Status Line

The status line surfaces key information at a glance without interrupting your flow. AI with Avthar recommends including:

• Git repo name
• Current branch
• Context percentage already consumed

Use the status line command to configure what appears. It's a small addition that makes proactive session management much easier.

Tip 19 · Give Claude Lots of Context

Good prompting is "one of the biggest levers for improving your outputs." Treat Claude like a smart co-worker you're delegating to:

• Set clear goals and success criteria
• Name specific files, folders, and tools
• Describe the before-and-after state you want

The more relevant context you supply, the better the results.

Tip 20 · Just Ask Claude

When you're stuck — on a technical decision, a feature approach, or how to use Claude itself — ask Claude directly. It's an always-available thought partner. AI with Avthar calls this his "number one piece of advice for succeeding with Claude Code as a beginner." Don't search the web or guess; ask first.

Tip 21 · Use the Claude Code Guide Sub-Agent

There's a built-in sub-agent specifically designed to answer questions about Claude Code. To use it, ask Claude to invoke the Claude Code Guide sub-agent. It provides:

• Up-to-date feature information
• Best-practice guidance
• Answers scoped to your specific project context

This beats reading generic docs because the sub-agent responds in the context of what you're actually building.

Custom Commands and MCP Servers

Custom slash commands and MCP servers are the two fastest ways to stop repeating yourself and give Claude Code reach into the tools you already use.

Tip 22 · Create Custom Slash Commands

"If you ask Claude the same thing twice, create a custom slash command for it." Slash commands are prompt shortcuts — one word triggers a whole repeatable workflow.

Examples AI with Avthar uses daily:

• /create-issues — turns a project spec into discrete GitHub issues
• /update-docs-and-commit — refreshes documentation and cuts a commit after a feature lands
• /whats-next — reads GitHub issues, commit history, and the spec doc to surface the next task

To create one, just ask Claude, giving it the command name and a plain-English description of what it should do. Slash commands support:

• Arguments for dynamic input
• Inline bash for scripting steps
• File references for pulling in context

Tip 23 · Use MCP Servers for Third-Party Tools

MCP (Model Context Protocol) is "like USB-C for AI tools" — a standard connector that lets Claude Code both read information from and take actions inside external services.

The ecosystem is growing quickly; whatever is in your stack likely has an MCP server already. AI with Avthar's recommended starting points:

• Playwright MCP — browser automation and end-to-end testing
• MongoDB / Supabase MCPs — database reads and writes
• Vercel / Cloudflare MCPs — deployment and infrastructure operations

Installation is straightforward: follow the docs for the tool you want and Claude walks you through setup.

# Claude guides setup interactively — just ask:
# "Help me install the Playwright MCP server"

Skills, Plugins, and Sub-Agents

Claude's customization system goes deepest when you layer skills, plugins, and sub-agents together — each layer targeting a different kind of knowledge or workflow need.

Tip 24 · Use Third-Party Skills

Skills are files and folders containing a skill.md that loads specialized knowledge into Claude on demand. They use progressive disclosure: Claude sees only names and descriptions first, then pulls full files when relevant — preventing context bloat.

Recommended starter skills:

• Frontend Design (Anthropic) — visual design principles
• Document creation (Anthropic) — PDF, PowerPoint, Word formats
• Expo — React Native mobile development
• Supabase — Postgres best practices

Browse the full directory at skills.sh for skills covering web, mobile, TDD, planning, and marketing.

Tip 25 · Create Your Own Skills

Run /skill-creator (found in Anthropic's example skills plugin) to build skills that encode personal or business knowledge: company processes, brand guidelines, development practices, operating procedures.

The most important part of any skill is its description — specifically, when Claude should use it. Be precise about the scenarios, keywords, and triggers. If a skill isn't firing in the right moments, ask Claude to "upgrade the description so it triggers in that specific scenario going forward." Skills can also be invoked manually with /skill-name.

Tip 26 · Use Plugins for Power-User Workflows

Plugins bundle commands, sub-agents, MCP servers, hooks, and skills into a single installable unit. Use /plugin to browse and install from the official Claude Code marketplace.

AI with Avthar's recommended plugins:

• FeatureDev (Anthropic) — specialized sub-agents for each stage of feature work
• CodeReview (Anthropic) — automated PR reviews
• LSP plugins for TypeScript, Python, or your primary language
• Frontend Design — dramatically improves generated UI quality

Enable and disable plugins on demand; their components consume context.

Tip 27 · Set the Right Scope

Three scopes control where a customization lives:

• Local — this project only
• User — all Claude Code projects on your machine
• Project — committed to Git and shared with your team

To move any skill, plugin, or MCP between scopes, just ask Claude — it relocates the files automatically.

Tip 28 · Frontend Design Plugin

The Frontend Design plugin loads design principles into context. Without it: generic UIs and purple gradients. With it: polished, intentional designs. AI with Avthar calls the difference "dramatic."

Tip 29 · Custom Sub-Agents for Background Tasks

Unlike slash commands, sub-agents run in a fresh, isolated context window — enabling parallel, background execution. Good candidates: end-to-end testing, changelog updates, security reviews, research tasks. Use /agents wizard to configure a new agent's name, description, tools, and system prompt.

Spec-Driven and Test-Driven Development

Pairing a written spec with tests before writing production code is the most reliable way to keep Claude focused and error-free across a multi-session project.

Tip 31 · Practice Spec-Driven Development

A project spec doc gives Claude a stable contract to build against. AI with Avthar found two components are essential:

• Product requirements — what you're building and why
• Engineering requirements — how you're building it, tech choices, constraints

Break the spec into milestones (MVP → v1 → v2) rather than handing Claude one giant feature list. Building in phases produces "fewer mistakes compared to asking it to build everything at once."

You don't have to write the spec yourself. Give Claude a high-level idea and ask it to interview you — using the ask-a-question tool — to extract both product and engineering requirements. It outputs a structured doc you can reference throughout the project.

Tip 32 · Use Claude Code for Research

Before committing to a technical decision, have Claude compile a research report using its web search tool. It reads the results in the context of your project and writes structured output files you can both reference later. AI with Avthar has used this to answer questions like:

• What's the best way to prompt the Gemini image API?
• Which authentication solution fits this project?
• How do I set up Stripe Connect?

This keeps decisions grounded in current documentation rather than stale training data.

Tip 33 · Practice Test-Driven Development

Ask Claude to write tests before it implements a feature, then implement only enough code to make those tests pass. This workflow:

• Prevents regressions as the codebase grows
• Forces Claude to understand success and failure modes before writing production code
• Gives you a clear definition of done for every feature

To automate the loop, create a /tdd slash command that accepts a feature description and runs the full test-driven workflow automatically.

The RPIT Feature Build Loop

A structured feature-build loop called RPIT is AI with Avthar's most-used workflow for shipping individual features with Claude Code.

Tip 34 · Use the RPIT Loop for Every Feature

RPIT stands for Research → Plan → Implement → Test. The same four steps apply to every feature; you only adjust how much time you spend on each.

• Research — Ask Claude to produce a report on any new APIs or tech required. Optional, but valuable for bigger features involving tech-stack decisions or unfamiliar integrations. "A research step up front saves a lot of headaches during implementation."
• Plan — Switch to plan mode so Claude breaks down the work and asks clarifying questions. AI with Avthar calls this "the most important step" because it translates requirements into concrete actions.
• Implement — Claude builds the feature using all configured plugins, sub-agents, and MCPs.
• Test — Claude verifies correctness through unit tests, integration tests, and browser automation via MCP to confirm the user experience.

Tip 35 · Use an External Source of Truth

To kick off the RPIT loop, point Claude at a GitHub issue rather than a scattered Markdown file. GitHub Issues become the single authoritative list of planned work, which brings two benefits:

• One canonical place for all features and tasks — no stray spec files in the repo.
• Easy automation via custom slash commands (e.g., auto-create issues from a project spec, or analyze Git history to surface what to work on next).

AI with Avthar reaches for the GitHub CLI as the simplest path for personal projects and small teams, but the pattern works equally well with Linear, Jira, or any tool accessible via CLI or MCP.

Tip 36 · Practice Issue-Based Development

Routing all work through a tracked issue — rather than ad-hoc prompts — turns each RPIT run into a self-documenting unit. The issue holds the requirement; Claude holds the implementation context; the closed issue and merged code become a permanent audit trail.

Verification and Documentation

Verification and documentation habits separate one-off Claude wins from a sustainable, reliable workflow. Tips 37–40 close out the intermediate level with practices that let you trust Claude's output at scale.

Tip 37 · Verify at Higher Levels of Abstraction

Reading every line Claude produces doesn't scale. AI with Avthar's mindset shift: verify correctness through layers above the code itself.

• Automated code review tools
• Unit, integration, and end-to-end tests
• Acceptance criteria checks
• Security audits
• Manual and automated UX verification

Ask yourself not just "does this code look right?" but "how can I prove it behaves correctly?" The same discipline applies to managing talented engineers — it applies equally to Claude.

Tip 38 · Give Claude a Way to Verify Its Own Work

Don't let Claude stop at building. Equip it with the tools to confirm what it built actually works.

Provide Claude with:

• Build scripts and automated test suites
• Explicit success criteria
• Browser automations (AI with Avthar highlights the Playwright MCP as excellent here)

With Playwright MCP, Claude can open a real browser, navigate your app, and check behavior "the way a user would" — then iterate if something is broken, without waiting for you to catch it.

Tip 39 · Automatically Document Your Project

Have Claude create and maintain living documentation alongside the code. The three files AI with Avthar generates for every project:

• architecture.md — how the system is structured
• changelog.md — what changed and when
• projectspec.md — the evolving project specification

Link to all three from your CLAUDE.md so Claude always knows where to find and update them. You can also wire this up with a slash command:

/update-docs   # updates docs and commits changes after major features

Sub-agents can handle the same task automatically on a schedule or after significant merges.

Tip 40 · Iteratively Improve Your CLAUDE.md

The most underrated tip in the intermediate section. Your CLAUDE.md is not a one-time setup — it should evolve as you discover what Claude gets wrong, what context it needs, and what conventions matter to your project. Treat it as a living file you refine after every significant session.

Parallel Sub-Agents and Multi-Clauding

Parallel sub-agents and multi-Clauding let you compress a week of feature work into hours by running multiple Claude Code instances simultaneously instead of sequentially. These four tips form the core of the "master level" workflow.

Tip 41 · Use Parallel Sub-Agents Within a Single Feature

When a feature has independent steps, Claude can spin up sub-agents to tackle them simultaneously. Prompt Claude with something like:

"Break down this feature implementation, identify which tasks are independent and can be executed in parallel, and create task sub-agents for the parallel work."

Instead of waiting for each step to finish before starting the next, sub-agents run side-by-side and collapse the total wall-clock time.

Tip 42 · Multi-Clauding — Run Multiple Instances at Once

Multi-Clauding means running separate Claude Code sessions in parallel, each owning a different feature of the same project. AI with Avthar frames the mindset shift clearly: you go from "pair programming with a single Claude" to becoming "the conductor of an orchestra of AI coding agents."

Practical starting advice:

• Begin with two or three instances, then scale up as you get comfortable.
• Carry the testing and verification habits from intermediate-level work into every instance so each Claude can self-check its output.

Tip 43 · Use Git WorkTrees to Multi-Claude Safely

Multiple Claudes writing to the same working directory will collide. Git WorkTrees solve this by giving each instance its own directory and branch while sharing a single Git history.

Claude Code has built-in WorkTree support via the -W flag:

claude -W     # start a session in a new, isolated WorkTree

This creates a copy of the repo under .claude/worktrees/ on a fresh branch — no manual setup required. When a WorkTree's work is done, push the branch and open a PR, or merge into main for final review.

Tip 44 · Use the Desktop App as Your Multi-Agent Control Center

The Claude Code desktop app automates WorkTree creation. When starting a new session, check the WorkTree option and the app handles the branch and directory setup for you. The sidebar's session list lets you monitor and switch between all running Claude sessions and their WorkTrees from one place.

Feedback Loops and Self-Improvement

Building feedback loops into your Claude Code workflow turns each session into a source of compounding improvement, not just a one-time task.

Tip 45 · Set Up Feedback Loops for Self-Improvement

After every feature build or RPIT loop, add a deliberate reflection step where you and Claude review what went well, what was challenging, and what could be improved. AI with Avthar describes this as creating "two loops":

• Inner build loop — RPIT (Read, Plan, Implement, Test) for a single feature
• Outer improvement loop — captures learnings and feeds them back into the next build

The Custom Retro Skill

AI with Avthar built a custom retro skill that runs after each feature or project milestone. It pulls context from three sources:

• Git history
• Test results
• Conversation history

From that context, it reflects on the session and surfaces "concrete improvements" in three areas:

1. Updates to CLAUDE.md and supporting documentation
2. New slash commands to formalize repeated patterns
3. New skills to add to the workflow

This transforms one-off observations into durable, reusable system improvements that make every future session a little sharper.

Why the Outer Loop Matters

Most users optimize inside the build loop — faster prompts, better task breakdowns. The outer loop is where leverage compounds. Each retro deposits learnings back into CLAUDE.md, so Claude starts the next session with more context, better constraints, and fewer repeated mistakes. Over many cycles, the system effectively trains itself to work the way you work.

Ralph Wiggum Autonomous Iteration

Autonomous iteration — running Claude in a persistent loop until it solves the problem — is the core idea behind the Ralph Wiggum Loop, named after the Simpsons character who just keeps going no matter what.

Tip 46 · Use Ralph Wiggum Loops for clear-criteria tasks

The loop works by repeatedly feeding the same prompt back to Claude until it either meets the success criteria or exhausts the configured iterations.

AI with Avthar recommends this pattern because "persistent iteration despite setbacks is remarkably effective to solve tough problems."

When to use Ralph Wiggum Loops:

• Tasks with clear, testable success criteria
• Work suited to iterative refinement (e.g., passing a test suite)
• Greenfield projects where Claude can freely regenerate code

Getting started — two plugin options:

• Ralph Loop plugin (Anthropic) — built-in hooks automatically re-feed the prompt whenever Claude stops. Best starting point.
• Ryan Carson's Ralph Skills plugin — more advanced implementation that also extracts reusable skills as it loops.

Self-Improvement Plugins Worth Pairing

Before reaching for Ralph Wiggum, AI with Avthar highlights two companion tools that help Claude learn from each session:

• Compound Engineering plugin (Every) — includes /review and /compound slash commands that document learnings so future work gets progressively easier.
• Claudeception skill — extracts and stores new skills automatically as you build, then loads the relevant skill the next time a similar problem appears.

These aren't loop mechanisms, but they compound the value of every Ralph Wiggum run by preserving what Claude figured out.

Async Delegation and Agent Teams

Delegating work to Claude asynchronously — across web, GitHub, Slack, and multi-agent teams — lets you and your entire organization move faster without staying glued to a terminal.

Tip 47 · Use Web and Mobile for Async Development

Claude Code on web or mobile is the best way to hand off small features and bugs without blocking yourself. You can run multiple repos simultaneously, each in its own sandbox session. The critical habit: make output reviewable. After Claude finishes, use the web app to create a PR so changes can be reviewed and tested before merging.

Tip 48 · Use the Claude Code GitHub Action

The GitHub Action lets Claude operate directly inside GitHub — no terminal, no app required. Tag Claude in issues or PRs and it can:

• Fix bugs
• Review code
• Update documentation
• Answer project questions

Enable automatic PR review so Claude inspects every new pull request and suggests changes. Install it with:

/install-github-app

Tip 49 · Use Claude in Slack

A Claude Code Slack app brings delegation to wherever your team already communicates. Tag Claude in channels to answer questions, kick off bug fixes, or trigger PR reviews. AI with Avthar calls this "a game changer for teams where Slack is the main communication hub" — PMs, marketers, and executives can delegate to Claude without ever opening a terminal.

Tip 50 · Run Agent Teams for Complex Features

Agent teams split complex work across specialized Claude instances that coordinate with each other. This is distinct from the parallel multi-Clauding pattern covered earlier: agent teams collaborate on the same feature through a shared task list and messaging system, while parallel agents tackle independent features separately.

A key gotcha: by default, all agents share the same working directory and can overwrite each other's changes. Fix this with work tree isolation, giving each agent its own copy of the repo. Agent teams shine when a feature can be "cleanly split into distinct specialized roles" — if it can't be partitioned clearly, stick to a single Claude instance.

Permissions and Hooks for Reliability

Hooks let you inject determinism into Claude Code's otherwise unpredictable workflow, making reliability something you engineer rather than hope for.

Tip 51 · Configure Permissions for Predictable Behavior

Before hooks, tighten what Claude is allowed to do. Scoping permissions at the project level prevents Claude from taking actions outside its intended lane — file writes, shell commands, network calls — and reduces the surface area for unexpected behavior during long autonomous runs.

Tip 52 · Use Hooks to Enforce Reliability

Hooks are scripts that fire automatically at defined points in the Claude Code lifecycle. AI with Avthar describes them as "inserting determinism into an otherwise non-deterministic workflow."

Key facts about hooks:

• Over 10 hook events are available, from pre-tool-use to session-end
• The recommended starting point is the stop hook, which fires when Claude finishes responding
• A stop hook that runs your test suite after every response ensures Claude never moves forward with broken code

That single hook — auto-run tests on stop — is the highest-leverage reliability improvement you can add immediately.

Setting up hooks:

/hooks          # open the hooks configuration UI inside Claude Code

Alternatively, ask Claude directly to create hooks for you, or use Anthropic's Hookify plugin to generate custom hooks that block unwanted behavior without writing scripts by hand.

The stop hook fits neatly into any coding loop: