The Claude Code Guide: What Actually Matters in 2026
The Claude Code Guide: What Actually Matters in 2026
If you want to master Claude Code, you don't need 1,000 hours of trial and error — you need to focus on the right things at the right stage. I've spent enough time inside this tool with clients and my own projects to know where beginners waste time and where the real leverage is. Here's the complete roadmap: beginner setup, intermediate context engineering, and the advanced stuff like loop engineering, graph engineering, and building your own agentic OS.
This isn't a feature dump. It's the shortlist of what gives you the most bang for your buck at each level.
Where Should You Actually Run Claude Code?
You can run Claude Code three ways: the web app in the cloud, the desktop app, or the terminal — and if you're not technical, the desktop app is now the right call. A few months ago I would have pushed you straight to the terminal or VS Code with the extension. That's changed.
The desktop app has gotten a lot better and it's getting features the terminal doesn't have: voice mode, browser automations, inline artifacts, and a genuinely better experience for anyone who's never touched a command line. And it's not either-or — you can still open a terminal inside the desktop app whenever you want.
To install it, search "Claude Desktop App," hit the first link, download the installer, and run it. Done.
What Settings Should You Change First?
Open Customize on the left, then the General tab, and look at "Instructions for Claude." Mine is blank. Yours probably should be too.
These are global instructions — they apply to every project and every prompt. If you write "make all your responses rhyme," every single response will rhyme. So ask yourself: do you actually have something relevant to every chat you'll ever have? That's a high bar. If what you're about to add doesn't clear it, leave it blank.
A few more defaults worth knowing:
- Capabilities tab — set tool access mode to "load tools when needed" and turn everything else on.
- Pull requests — if you don't know what a PR is, leave it off. It's more advanced.
- Claude in Chrome — turn it on if you want Claude to control your browser, but you'll need the Chrome extension.
What Do the New-Chat Options Mean?
When you start a new chat you'll see a few things: Local, a folder name, main / worktree, and a plus button.
- Local tells Claude where it's running. If you don't know what cloud, remote control, WSL, or SSH mean, you should be on Local 99.99% of the time. The rest are for using Claude away from your computer.
- The folder is where you're working. Everything you do lives there — make a folder like "claude code projects" and point at it.
- main / worktree is a git thing. Oversimplified: git is about saving your work. If you don't know git, keep it on main and don't check worktree.
Then there's permissions, and this one matters. Click the mode selector and you get five options along a spectrum:
- Manual — asks permission for everything.
- Bypass permissions — does whatever it wants, including deleting and installing things. A little scary.
- Auto — basically bypass, but a classifier inspects each command and stops the dangerous ones. This is the default, and it's where you should live most of the time.
- Plan — more on this below.
Which Model and Effort Level Should You Use?
It depends on your plan. On the $20/month plan, Fable burns too much usage, so you'll mostly sit on Opus. On a Max plan ($100 or $200/month), work in Fable most of the time — it's the best model by far.
The catch is usage limits: there's a 5-hour limit, a weekly limit, and a Fable-specific limit where only half your weekly usage can go to Fable. So don't torch it early.
The bigger lever is effort level, which runs from low up to Ultra Code. More thinking means better performance — but it's not linear. Going from extra-high to Ultra Code might buy you a 1% improvement while costing 5x more. Most problems, especially at the beginner stage, don't need anything past medium. I sit on Fable 5 medium most of the time unless something's genuinely complex or I'm about to hit a usage reset and can afford to burn it.
How Should You Prompt Claude Code?
Start every new project in plan mode, and stop looking for a magic prompt format. There's no secret template with a goal block and a context block and a persona block. That era is over.
Here's what actually works: buy a microphone, turn it on, and give Claude a stream of consciousness. Ramble. For a demo site I built for a fake AI analytics company called Lighthouse, my prompt was literally "I want a website for a fake AI analytics company, I want a book-a-call CTA at the end, target audience is small startups, and other than that just ask me whatever questions you think are relevant that I haven't thought of."
That last part is the key. Add "what am I not thinking about?" to the end of your prompts. Plan mode does this automatically — it forces Claude to interview you before it executes. And that matters most when you're non-technical, because the real problem with AI isn't what you don't know. It's the unknown unknowns — the questions you don't even know to ask. Plan mode shines a light on them.
Why You Should Never Just Hit "Recommended"
When plan mode asks you something like "which tech stack — plain HTML, Next.js plus Tailwind, or Astro plus Tailwind?" — and you have no idea what those are — the temptation is to click "Recommended" and move on. The models are good enough that you'll still get a decent output.
Here's the trap: repeat that behavior and you learn nothing, and there's no difference between you and any random person off the street doing the same thing. No moat, fully replaceable. And eventually you'll hit a weird, unique project where Claude doesn't know the best approach, and you'll be lost.
You never have to learn to code again. But you do need to build AI software engineering fundamentals — big-picture stuff about how the building blocks fit together. So when you hit a question you don't understand, don't click Recommended. Type: "Can you explain what a tech stack actually is? I don't really understand these options." Do that for weeks and months and you build a real foundation instead of becoming a caricature of a vibe coder.
What Are Skills, and Why Do They Matter So Much?
Skills are simply prompts that tell Claude Code to do a specific thing in a specific way — and mastering them is the single biggest lever for leveling up your performance. A front-end design skill, for example, is just a prompt that says "when building this site, avoid these gradients, avoid AI slop, do this, don't do that."
Why do they matter? Because AI is non-deterministic — ask it to do something 10 times and you might get 10 different results. Skills give you back control and make outputs more repeatable.
You find skills in a few places:
- Inside the Claude app — Customize > Skills, plus the Plugins browser (Anthropic's official plugins include the front-end design skill).
- On GitHub — where most skills actually live. To install one, copy its GitHub URL, paste it into Claude Code, and say "add this skill." Then invoke it with a slash command or just natural language like "use the front-end design skill."
The most important skill to install right now is the skill creator skill. It's a skill that builds other skills — and it measures performance, runs tests, and runs evals. Once you have it, you can say "look at everything we did today and turn it into a skill," and it codifies your repeated work into something reusable.
How Do You Fix an Ugly AI Website? Context Engineering
My first Lighthouse site looked generic and awful. Why? Because I gave it almost no context — no inspiration, no screenshots, just "clean SaaS product." That's the whole theme of the intermediate stage: context engineering, giving Claude access to your vision plus external tools and references so it can do a better job.
The fix was two moves. First, I grabbed a SaaS landing-page screenshot off Pinterest. Then I prompted: "Use the front-end design skill to redesign this page — and give me three divergent versions in the browser pane to choose from." One generic Anthropic skill, one screenshot, a basic prompt — and I got three genuinely different, dramatically better designs. One screenshot plus one skill equals an infinitely different end result. That's the power of injecting context.
How Do You Connect Outside Tools to Claude Code?
Anytime you're working with something outside Claude, ask: can I just control it with Claude instead? There are three ways to wire in an external tool:
- Connectors — Customize > Connectors. Gmail, Google Calendar, Google Drive. Connect once and Claude can read and control them by prompt.
- Plugins / MCPs — the Plugins browser has partner integrations like GitHub and Supabase. Adding one lets Claude control that app.
- CLIs — command-line tools like the GitHub CLI or the Vercel CLI. CLIs tend to give more functionality than an MCP and often ship with their own skills.
Installing a CLI is as simple as telling Claude to add it — paste the URL and say "add this CLI." Once it's in, Claude can drive it.
The real payoff is chaining them. With the GitHub CLI plus the Vercel CLI, I built a full deployment pipeline from inside Claude Code: create the repo, push the site's code, connect it to Vercel, get a live URL — all in plain language, never opening either dashboard. And because it's a live GitHub-Vercel connection, any change I make in Claude Code ships to the live site just by asking.
You don't even have to hunt for the tools. You can literally say: "I want to deploy this site, I've heard of GitHub and Vercel and maybe they have CLIs — go check, add them if they exist, and set up the pipeline." Claude does the rest.
What Is Loop Engineering?
Loop engineering is how you get Claude Code to handle long-horizon tasks — work that runs for hours, or repeats forever, without you babysitting it. Every long-horizon task has three or four parts: a trigger, a task, a success criteria, and (for anything that loops indefinitely) a logging step.
For a one-and-done long task, Claude Code has a built-in command: /goal. You pass it a prompt that defines the success criteria — the objective end state, not just the instructions. It runs an iteration, checks it against the criteria, and if it fails it spins up another session, learns from the previous attempt, and tries again until it succeeds. It's similar to a Ralph loop.
The catch is objectivity. "Make a cool website" is useless — how does it grade "cool"? The more subjective your criteria, the less likely it hits your needs.
For something that runs forever — say a daily morning report that scrapes YouTube, X, Reddit, and your Gmail and synthesizes a brief at 7am — you add logging. The practical path: use the skill creator skill to build the report as a skill, run it manually until it's good, add language to log every run to a database and compare against past iterations (that's the self-improving part), then turn it into a routine (Routines > New Routine > Local) that runs on a schedule. That's loop engineering in practice.
What Is Graph Engineering?
Graph engineering is loop engineering applied at every step instead of once. Instead of one giant loop scraping everything, you give each source — YouTube, X, Reddit, Gmail — its own micro-loop with its own trigger, task, self-scoring, and logging, and those looping agents talk to each other inside one run.
That's it: a bunch of looping agents nested together that also communicate. For most people this is total overkill — you rarely need it — but conceptually that's all it is.
What Is Ultra Code and Dynamic Workflows?
Ultra Code builds a custom harness for whatever problem you're solving — usually by spinning up a bunch of sub-agents. It's extremely effective and extremely expensive.
The best pre-built example is /deep-research. Instead of a normal web search with a handful of sub-agents, it decomposes your question into search angles, spawns parallel web-search agents, scrapes sources, then runs adversarial agents that stress-test each claim before synthesizing a final report. I've watched a single deep-research run spin up 103 agents and burn 6 million tokens — all on Fable. So yes, it's pricey.
One important control: by default Ultra Code uses whatever model you're on for the sub-agents. You can override that in the prompt — "limit it to 20 sub-agents" or "use Sonnet for the sub-agents" — so you're not a slave to running 100 Fable agents at once. Common workflow patterns include classify-and-act, fan-out-and-synthesize, adversarial review, generate-and-filter, tournament, and loop-until-done. Of all of them, deep research is the one you'll use most — especially before a complex build, to get your ducks in a row before you even enter plan mode.
How Do You Bring Other Models Into Claude Code?
AI models are bad at grading their own work — ask Opus to grade itself and it'll basically always say it did great — so bring in a second frontier model as a reviewer. This is model routing, and you do it through skills and plugins.
There's an official Codex plugin from OpenAI for Claude Code: paste the URL, install it, and Codex can do adversarial review of your code or work on specific features. For the planning stage I built a skill called grill-me-codex that combines Matt Pocock's grill-me skill with Codex review. You and Fable hammer out a plan, then it routes to Codex, and the two go back and forth for up to five rounds — Codex says "this is wrong and here's why," Claude reacts, and they iterate until they agree. It solves the self-grading problem and gives you a real second set of eyes. And you're not locked into Codex — you can wire in cheaper or even local models the same way, as a skill.
What Is an Agentic OS?
An agentic OS is a series of skills and automations mapped to your daily tasks, wrapped in a custom visual interface and backed by an Obsidian memory layer. The visual dashboard — social metrics, daily research, buttons that trigger skills — is nice, but the real value is the skill architecture behind it. The goal is turning Claude into a personal assistant that can do everything you do.
You build it the same way as everything else: turn on the microphone, stream-of-consciousness what you do day to day, and ask Claude to turn those tasks into skills where it makes sense. Do that over and over and you build a corpus of skills that automates huge swaths of your work. The ones that make sense become automations.
Underneath sits Obsidian — not a superpower on its own, but a clean markdown file system that gives Claude memory and navigation. This is the Karpathy Obsidian setup: a vault with a clear structure — a raw section for research data, a wiki section where raw data becomes articles, and an output section for finished artifacts like slide decks. The secret ingredient is an index markdown file at every level — a table of contents that lets both you and Claude navigate hundreds of thousands of files accurately and cheaply.
And the way these dashboards actually call Claude is headless mode — claude -p — which runs Claude invisibly in the background via the terminal. There was old drama about Anthropic charging different rates for it, but that's no longer the case, so these systems are as cost-efficient as anything else.
Frequently Asked Questions
Should beginners use the Claude Code terminal or the desktop app?
If you're not technical, use the desktop app. It now has voice mode, browser automations, and inline artifacts that the terminal doesn't, and you can still open a terminal inside it. The terminal remains powerful for technical users, but you're not missing out by starting with the desktop app.
What permission mode should I use in Claude Code?
Use Auto for most work. It behaves like bypass permissions but runs a classifier that inspects each command and blocks the dangerous ones. It's the default for a reason. Only drop to Manual if you want to approve everything, and be careful with full bypass.
What's the difference between /clear and /compact?
/clear wipes the conversation and starts a fresh context window for top performance. /compact summarizes the entire conversation and starts a new chat with that summary. Because you're working inside a project folder, starting a new chat doesn't lose your work — Claude can still read all the files and code you created.
When should I start a new chat to protect performance?
Watch your context window. Performance degrades as it fills, especially for questions about the middle of a long session. A good rule of thumb is to consider a fresh chat around 30-50% of a 1M-token window — personally I reset around 30%.
Do I need to build an agentic OS to get value from Claude Code?
No. The visual agentic OS wrapper isn't necessary. What matters is the skill architecture underneath — building skills for your repeated tasks and turning the ones that make sense into automations. The dashboard is a nice-to-have on top of that foundation.
If you want to go deeper into mastering Claude Code, join the free Chase AI community for templates, prompts, and live breakdowns. And if you're serious about building with AI, check out the paid community, Chase AI+, for hands-on guidance on how to make money with AI.
