Getting Started

What is Claude Code?

Claude Code is an AI agent that writes, edits, and runs code inside your editor. You describe the outcome in plain language; it plans, generates files, executes commands, and iterates until your app works. It handles the full lifecycle: requirements, architecture, implementation, debugging, and refinement. You'll interact through a chat panel while watching real code appear in your project. It works best when you provide specific goals, examples, and constraints.

Why it matters:
- It turns high-level ideas into working software.
- It's effective for both non-developers and engineers who want speed and leverage.
- It reduces context-switching by keeping planning, coding, and debugging in one flow.

How do I install Claude Code?

Use an editor with an integrated terminal, such as Cursor. Create a new project folder, open the terminal, and run the provided installation command. After installation, type "claude" in the terminal to launch the agent. Ensure your editor can show a file tree, open multiple panes (editor, terminal, agent), and allow background processes. If your environment blocks package installs, use a virtual environment or container to keep dependencies isolated.

Quick flow:
- Install a compatible editor (e.g., Cursor).
- Open a project folder and its terminal.
- Run the Claude Code install command.
- Start the agent by typing "claude".

What is the basic user interface layout?

You'll usually see three areas: a File Explorer (left), the Code Editor (center), and the Claude Code chat (right). The File Explorer shows the evolving codebase. The Editor is where you can read and adjust files. The Agent panel is your command center,plan features, paste errors, and request changes.

Tip for speed:
- Keep the terminal visible to watch installs, server output, and tests.
- Tile windows so you can read errors and the agent's reasoning while viewing the affected file.
- Use split editors to compare before/after code changes.

Core Concepts

What are AI models and which one should I use?

Models are the engines behind the agent. You can switch with the /model command. Common options include Opus (most capable), Sonnet (faster, efficient), and Opus Plan Mode (Opus for planning + Sonnet for execution). Use Opus when the plan is unclear or the system is complex. Use Sonnet when the plan is clear and you're executing straightforward steps. Opus Plan Mode is often the sweet spot: high-quality planning with efficient implementation.

Practical rule:
- Fuzzy requirements → Opus or Opus Plan Mode.
- Clear steps and repetitive work → Sonnet.
- Mixed workload → Opus Plan Mode to balance quality and cost.

What is Plan Mode and why is it important?

Plan Mode lets you align on outcomes before any files change. You iterate on a Product Requirements Document (PRD) or step-by-step plan, spot edge cases early, and block wrong assumptions. Toggle it with Shift + Tab. Keep clarifying until the plan exactly matches your intent. Once approved, the agent executes with fewer surprises. Think of it as your safeguard against scope creep and accidental redesigns.

Use it for:
- New features, architecture changes, or migrations.
- Anything you'd review with a teammate before coding.
- Cutting down rework and inconsistent UX.

How do I start building a new application?

Start in Plan Mode. Describe the app at a high level, constraints, must-haves, and what can wait for later. Ask for a PRD with scope, user stories, tech choices, and acceptance criteria. Request tradeoffs and a phased rollout. Approve the plan, then let the agent scaffold the project and first feature. Keep the feedback loop tight,ship a minimal slice, test it, then expand.

Example prompt:
"Build a note app with folders and AI summarize. Prioritize the editor and folder structure. Draft a PRD, select a framework, and plan the first milestone focused on front-end only."

What do I do when I encounter an error?

Copy the full error message from the terminal or browser console and paste it into the agent chat. Add what you were trying to do and any recent changes. The agent will trace the stack, inspect related files, and propose a fix. For UI glitches, paste a screenshot. If the fix fails, provide the new error output and ask the agent to compare the before/after to locate the gap.

Workflow:
- Paste the exact error (no paraphrasing).
- Add context: what changed since the last success.
- Let the agent test and iterate until green.

What are Background Tasks?

Background Tasks keep processes like dev servers, watchers, or jobs running while the agent reads logs in real time. That means the agent can confirm that hot reloads worked, see stack traces as they occur, and verify that endpoints respond as expected. It shortens the feedback loop and reduces manual restarts.

Best uses:
- Running the app server during feature work.
- Watching test output while refactoring.
- Monitoring build output for missing dependencies or config issues.

Advanced Features and Customization

What is the claude.md file?

claude.md is a persistent rules and context file created via /init after V1. The agent scans your repo and records the stack, folder structure, data models, and patterns. You add custom rules,coding standards, review gates, or "ask before big changes." This is how you make the agent "project-aware" so quality stays consistent across sessions and contributors.

Add rules like:
- "Confirm before changing auth or state models."
- "Explain tradeoffs for any new dependency."
- "Use step-by-step reasoning for all prod errors."

What are "Thinking Modes"?

Thinking Modes adjust reasoning depth with prompt keywords: "think" (standard), "think harder" (more analysis), and "ultra think" (deep, multi-angle reasoning). Use higher levels for architecture, complex bugs, and first-time designs. The input area may shift color, signaling the mode. This is a quick way to direct the agent's cognitive effort without writing long prompts.

Rule of thumb:
- Small UI tweak → "think".
- New feature or mixed concerns → "think harder".
- Foundational design or hairy bug → "ultra think".

Can I create my own commands?

Yes. Ask the agent to build custom slash commands to automate repeatable checks or workflows. Examples: /security for code scans, /docs for README updates, /release for tagging and changelogs. The agent will generate the command files and wiring; after a restart, you can invoke them on demand. This turns expert routines into one-liners you can run anytime.

High-impact ideas:
- /perf for simple performance reviews.
- /uxcopy to generate microcopy and empty states.
- /i18n to scan and extract strings for translation.

What are Sub-agents?

Sub-agents are specialized agents with a focused brief, such as "code reviewer," "test writer," or "security auditor." Your main agent can hand tasks to them automatically after changes or on demand. They use project context and their own rules to enforce consistency and quality. Treat them like role-specific teammates that never forget your standards.

Useful roles:
- Code Review: spot anti-patterns and inefficiencies.
- QA: generate tests and verify acceptance criteria.
- Docs: keep README, ADRs, and changelogs current.

What are Output Styles and how can I use them?

/outputstyle changes how the agent communicates. "Explanatory" describes actions and choices, perfect for learning or audits. "Learning" prompts you to write parts, like a tutor. You can define custom styles (e.g., "direct" for minimal chatter or "PM-mode" for risk calls and tradeoffs). Use styles to match communication to the task and audience.

Tip:
- Switch to "explanatory" for complex code changes to leave a decision trail.
- Use a concise style during quick fixes to save time.

Practical Tips and Strategies

How do I implement AI features (like summarization) in my app?

Ask the agent to add the feature end-to-end: UI trigger, server route, and provider call. It will create a secure place for API keys (e.g., .env.local) and wire everything up. Generate a key with your AI provider, paste it into the env file, and restart the app. Request usage guards: rate limits, input validation, and graceful error states. Test against sample data and edge cases (empty input, long text, timeouts).

Example:
- "Add a 'Summarize' button to the note view, store the key in .env.local, and handle rate-limit errors with a friendly message."

What is the "Co-pilot AI" strategy?

Use a second AI to critique plans before execution. Generate a plan in Plan Mode, copy it to another model, and ask for risks, alternatives, and missing steps. Bring that feedback back to Claude Code to refine. This gives you independent review without slowing down, especially for architecture, data models, or vendor choices.

Prompt example:
"Here's a feature plan. What assumptions look risky? Any simpler stack options? What tests would you require before shipping?"

What are the most important prompting tips?

Be specific, give examples, and show visuals. Reference apps you like and detail behaviors (not just aesthetics). Include constraints: budget, performance targets, or deadlines. For complex tasks, Plan Mode first. For smaller tasks, include acceptance criteria and "done" checks.

Template:
- "Goal: … Constraints: … Examples: … Done when: … Risks: …"
- Add screenshots to eliminate guesswork.
- Link to APIs, design systems, or repos for context.

Where can I find further resources?

Check official documentation for features and commands, community forums for examples and Q&A, and current tutorials for end-to-end builds. Explore open-source repos that use AI agents to see patterns in structure, testing, and deployment. Keep a personal snippets library of prompts and commands that worked well on previous projects.

Go-to sources:
- Official docs for features and flags.
- Community spaces (Discord, Reddit) for tactics and edge cases.
- GitHub repos to study real implementations.

Additional FAQs (From Basic to Advanced)

Who is this masterclass best for and what are the prerequisites?

It's for business professionals, product leads, founders, and developers who want to build working software quickly. You don't need to be a seasoned coder. A basic grasp of files, folders, and copy/paste into a terminal is enough to start. If you can describe outcomes clearly, the agent can translate them into code. Developers will appreciate the speed on scaffolding, refactors, and tests.

To get the most value:
- Be outcome-focused: "What must this do?"
- Provide examples and constraints.
- Use Plan Mode for any feature that could branch in multiple directions.

What is YOLO Mode and when should I use it?

YOLO Mode (Shift + Tab once) lets the agent make changes without asking for confirmation at each step. Use it for small, reversible tasks: copy changes, minor UI tweaks, dependency installs, or adding a single route. Avoid it for system-wide refactors, auth changes, or data migrations,use Plan Mode instead. If in doubt, ask the agent for a quick plan, then flip YOLO on for execution only.

Safe usage:
- Keep Git ready to revert if needed.
- Limit scope to one feature or file area.
- Watch the terminal for warnings as it runs.

How do I choose between Opus, Sonnet, and Opus Plan Mode in practice?

Think "plan vs. do." Use Opus to crystallize the plan when requirements are fuzzy or the system is intricate. Use Sonnet when the steps are clear and speed matters. Opus Plan Mode gives you the best of both: premium planning, efficient execution. Switch mid-stream if complexity increases: promote to Opus for a quick re-plan, then continue with Sonnet.

Example mix:
- Architecture: Opus (plan).
- CRUD scaffolding: Sonnet (execute).
- Security review: Opus (plan), then Sonnet (fixes).

How do I keep costs predictable and monitor usage?

Adopt a budget mindset: prefer Opus for planning only, then switch to Sonnet for coding. Cap session length, keep prompts concise, and reuse context via claude.md instead of repeating long descriptions. Ask the agent to batch changes (one commit per feature) and to summarize diffs instead of verbose explanations when you don't need them.

Controls to use:
- Opus Plan Mode to limit high-cost tokens to planning.
- Short prompts + precise acceptance criteria.
- Request minimal output during routine steps.

How do I use Git with Claude Code for safe changes and rollbacks?

Initialize Git before you start. Ask the agent to create a feature branch, make atomic commits, and write meaningful messages. After each milestone, push to remote. If something breaks, revert or cherry-pick. You can paste diffs into the chat and ask the agent to explain what changed and why, then request a rollback or targeted fix.

Best practices:
- One feature = one branch.
- Commit after each logical step.
- Use PRs with the code-review sub-agent for guardrails.

How do I keep environment variables and API keys secure?

Store secrets in .env files, not in code. Reference them via process environment variables on the server side. Use .gitignore to prevent accidental commits. Add runtime checks for missing keys and fallback behavior. For teams, use secret managers or per-environment env files. Ask the agent to scan for secrets before commits and to rotate keys in config when needed.

Checklist:
- .env in .gitignore.
- Server-only usage of secrets.
- Add a /security command to flag leaks.

How can non-developers succeed with Claude Code?

Describe outcomes in plain language, show examples, and use screenshots. Start with small, shippable features. Let the agent pick default stacks and structure. Use explanatory output style to learn while you build. When something breaks, paste the exact error,don't guess. Over time, you'll learn enough patterns to ask for smarter changes and review the code with confidence.

Focus on:
- Clear goals and constraints.
- Visual references for UI.
- Plan Mode for anything beyond a small tweak.

How do I structure prompts that lead to clear business outcomes?

Use an intent-first template: Goal, Users, Constraints, Examples, Acceptance Criteria, and Risks. Add KPIs (load time, conversion impact, support burden). Ask the agent to propose a phased plan: now, next, later. This ties every code change to a measurable result.

Template snippet:
"Goal: increase demo signups. Users: marketing visitors. Constraints: minimal new deps. Examples: Stripe pricing pages. Done when: conversion lift, Lighthouse scores hold steady."

How do I use screenshots and references to steer UI/UX accurately?

Paste screenshots of the desired layout or components. Annotate with arrows or captions to remove ambiguity. Reference design systems or sites you admire and call out behaviors (empty states, loading, error handling). Ask the agent to match spacing, typography, and component variants. Then request a visual diff summary comparing the implementation to the screenshot.

Prompt example:
"Recreate this card grid from the screenshot. Match spacing, hover states, and responsive behavior at three breakpoints."

How do I prevent unintended large refactors or risky changes?

Codify guardrails in claude.md: "Ask before changing auth, database schema, or global state." In Plan Mode, specify the scope and files that are allowed to change. Ask for a file-by-file impact list before execution. If the agent proposes a big change, require a written rationale, risks, and a rollback plan. Keep Git branches tight and review diffs before merge.

Safeguards:
- Approval gates in claude.md.
- Impact lists and rollback steps.
- Small PRs with sub-agent review.

How do I create and reuse project templates and scaffolds?

After you like an app's structure, ask the agent to extract a "starter" template: folder layout, linting, testing, CI config, and example components. Save it to a repo as your house standard. For new projects, point the agent to that repo and say, "Use this template as the base." Keep a changelog so improvements propagate to future projects.

Template contents:
- Base UI components, auth flow, error pages.
- Test setup and sample tests.
- Pre-commit hooks and CI workflow.

What's a simple deployment path for a Claude-built app?

Pick a host that matches your stack (e.g., Vercel for Next.js). Ask the agent to add production builds, env config, and a health check route. Add a deploy script and CI workflow for push-to-deploy. Start with a staging environment to test secrets and runtime behavior, then promote to production once checks pass.

Minimum set:
- Build command + env vars.
- Health check route for uptime monitors.
- CI with lint, test, and deploy steps.

How do I add tests and continuous checks with Claude Code?

Ask for a testing plan: unit, integration, and e2e. The agent can install frameworks, write sample tests, and wire CI to run on each PR. Add smoke tests for critical paths (login, payment, save actions). Use a sub-agent to enforce coverage thresholds and prevent merges below the bar.

Start here:
- Write tests for the riskiest flows first.
- Add data seeding for deterministic results.
- Run tests locally in Background Tasks while coding.

How do I troubleshoot if the agent stalls, loops, or misreads context?

Pause and summarize the current state: what was changed, what failed, and the target outcome. Ask the agent to restate its plan in bullets before trying again. If context seems off, reset the session and paste the relevant plan or claude.md sections. Provide the exact error or screenshot. As a last resort, ask for a minimal repro and fix it in isolation, then merge back.

Reset kit:
- Summarize "now vs. next."
- Repost the plan and constraints.
- Ask for a minimal, testable reproduction.

How should teams use claude.md for shared standards?

Treat claude.md like a contract for architecture, style, and process. Add sections for naming, error handling, testing, performance budgets, and "ask-before-edit" areas. Include a review checklist for PRs. Keep it short, living, and specific. When the team's practices evolve, update claude.md and ask the agent to re-scan so all sub-agents align.

Team wins:
- Consistent decisions across contributors.
- Faster onboarding with explicit norms.
- Fewer regressions due to shared rules.

What are the most common misconceptions about AI-assisted development?

Misconception 1: "It replaces planning." In reality, planning is where you get most of the gains. Misconception 2: "It guesses what I mean." It only sees what you provide; examples and constraints matter. Misconception 3: "It's hands-off." You still approve tradeoffs and protect scope. Treat it like a diligent teammate that benefits from clear direction and fast feedback loops.

Mindset shift:
- Plan first, execute second.
- Specificity beats length.
- Smaller steps ship faster and safer.