Claude Code Tutorial for Complete Beginners (2026)

My cousin called me on a Tuesday night, almost whispering, like she was confessing something. "I think I want to learn to code. Am I too late?" She runs a small bakery in Lisbon. She asked me for a claude code tutorial that wouldn't make her feel stupid, the kind a friend would write, not a robot. So I told her to sit down, open a laptop, and give me thirty minutes.

By the end of that call she had installed Claude Code, written her first prompt, and deployed a tiny task tracker to the internet that her husband could actually use. That's what this claude code tutorial is about. Not theory. Not vibes. A real, bite-sized hour where you go from I don't know if I belong here to look, my thing is live on the internet.

I'm Sofia. Later in this post, my co-writer Omar takes the wheel for a section, because he broke his first project the exact way beginners always break their first project, and his recovery story is better than anything I could invent. Let's go.

What Claude Code actually is (in plain language)

Think of Claude Code as a coding partner that lives in your terminal. Not a chatbot you paste code into. Not a website you switch tabs to. A teammate sitting inside the folder where your project lives, able to read your files, write new ones, run commands, and explain what it's about to do before it does it.

If you've ever taken a cooking class, you know the magic isn't the recipe. It's the person standing next to you saying "taste the sauce now, tell me if it needs salt." That's the shape of Claude Code. The recipe is your idea. The kitchen is your computer. Claude is the one asking does this need salt at every step.

Under the hood, it's a command-line tool made by Anthropic, powered by the Claude family of models. It's agentic, which is a fancy word that means it can do more than answer. It can edit files, run your tests, check if a build works, read the error that came back, and try again. You can watch it work. You can interrupt it. You can say "no, not that file, this one."

That's it. That's the whole idea. Everything else in this tutorial is detail on top of that one mental model.

Install in three commands

You need Node.js version 20 or newer. If you don't have it, go to nodejs.org and install the LTS version. It's a five-minute install, and you only ever have to do it once.

Then, in your terminal, run this:

npm install -g @anthropic-ai/claude-code

That's the whole installation. It works on Mac, Windows, and Linux the same way. If the command fails with a permissions error, don't panic. It means npm is trying to write to a system folder it doesn't own. On Mac and Linux, you can put sudo in front of it. On Windows, open your terminal as administrator. I know, it feels clunky. One day it won't. For now, breathe through it.

Next, log in:

claude /login

A browser window pops open, you sign in with your Anthropic account, and you're done. If you don't have an account, you can make one in about ninety seconds. There's a free tier that's generous enough to finish this tutorial. If you end up using Claude Code every day, the Pro plan is twenty dollars a month, which is roughly one overpriced airport sandwich. Napkin math: if it saves you even thirty minutes a month, at minimum wage that's a 300% return. At any professional rate, it's embarrassing how quickly it pays for itself.

Finally, from any folder on your computer, type:

claude

You're in. There's a blinking cursor. Claude is waiting. Say hi if you want. I still do.

Your first prompt (and how to phrase it)

Most beginners type their first prompt like they're typing a Google search. Two or three words. Build todo app. Claude will absolutely try, bless it, but you'll get something generic. The trick isn't to write more. It's to write with intention.

Here's a pattern I give to everyone starting out. Three parts: context, goal, constraints.

• Context: what exists, what I care about, what I know.
• Goal: what I want at the end.
• Constraints: what it shouldn't do, what matters, what to skip.

For example, instead of build todo app, try:

"I'm a complete beginner, just installed Claude Code. I want a tiny task tracker I can open in my browser, add tasks, check them off, and have them persist when I refresh the page. Keep it one HTML file, no frameworks, no build step. Explain what you're doing as you go, because I'm learning."

Read that prompt again. It's not that long. But every sentence is working. You told Claude who you are. You told it what you want. You told it what to avoid. You invited it to teach.

Good prompts are a form of self-respect. They force you to know what you actually want before you ask for it. That alone is worth the price of admission, and I'd say this even if Claude never shipped a single line of code for me.

One more tip. If you don't know what you want yet, just say that. Try something like "I'm not sure what I want to build. Can you ask me three questions to help me decide?" Claude is surprisingly good at interviewing you. Some of my best projects started with me not knowing what I wanted, and being honest about it.

The 30-minute project: a tiny task tracker

Let's build the thing. Make a new folder somewhere easy to find, like your desktop. I'll call mine tiny-tracker. Open your terminal in that folder. Start Claude with claude. Then paste this prompt:

"Build me a single-file task tracker. One index.html file. No frameworks, no build step. Features: add a task with a text input, mark it complete with a checkbox, delete it with an X button, filter between All, Active, and Completed, persist to localStorage so tasks survive a page refresh. Clean, minimal design, system font, plenty of whitespace. Explain briefly what each part does. Let's go."

Claude will think for a moment. Then it will start writing. You'll see it create index.html. You'll see it add HTML structure, CSS, and a small chunk of JavaScript. It'll probably explain the localStorage piece, because that's the interesting part. It might ask if you want dark mode or drag-to-reorder. Say no to any scope creep. We're going for shippable, not impressive.

Open the file by double-clicking it in your file manager. Your default browser opens. You see an input field. You type "buy lemons." You hit enter. A task appears. You check the box. It crosses out. You refresh the page. The task is still there.

You just built software. Real software, running on a real machine, doing a real thing. Sit with that for a second. I still remember the first time mine worked. I laughed out loud in my kitchen, and my dog thought I'd lost it.

Now comes a small ritual I recommend. Ask Claude to write you a README. Something short. What the app does, how to run it, what could be improved. Read it. Notice how your own thing is described back to you. That mirror is one of the most underrated parts of working with an AI coding agent. It shows you what you've made in someone else's words, and that's how you start to understand it.

Napkin math on this step: a beginner building this from scratch with a tutorial probably takes four to six hours. A beginner with Claude Code and this exact prompt takes fifteen to twenty minutes. That's not a speedup. That's a different category of possibility. It's the difference between "I might try this on a long weekend" and "I'll do this tonight after dinner."

Omar takes over: the first time it broke, and what I did

Hi, I'm Omar. Sofia asked me to write this section because I am, in her words, the patron saint of beginner mistakes.

My first Claude Code project was a little expense splitter for my roommates. Four people, shared groceries, someone always forgot who bought the olive oil. I prompted Claude, it shipped something that worked, I was delighted. Then I said "add a feature to export the totals as a CSV." Claude did it. I hit run. Broken. White screen. A wall of red errors in the browser console.

My first reaction was the reaction every beginner has. I did something wrong. I'm not smart enough for this. I almost closed the laptop.

Here's what I did instead, and it's the most important thing in this whole tutorial. I copied the error message. All of it. Every line. And I pasted it back into Claude with one sentence:

"This is what I see when I run the app. I don't understand it. Walk me through what it means and what we should try first."

Claude read the error. It explained that a function was being called before it was defined, because my earlier code assumed a certain load order. It suggested a one-line fix. I applied it. The app worked again.

The lesson is this. Errors are not failures. Errors are conversations. When something breaks, your job is not to feel bad. Your job is to copy the error, paste it into Claude, and ask what it means. Every error I've ever hit has been explainable. Most take less than three minutes to fix. The ones that take longer teach you something real.

I'll give you one more. A week later, I broke the same app in a different way, and when I pasted the error, Claude tried a fix that made it worse. Beginners always think the agent is infallible, and the moment it's wrong they spiral. Don't. Just say "that didn't work, here's the new error, what else could it be?" Two tries later, it was fixed. The trick is you're the tiebreaker. You bring patience. Claude brings patterns. Together you're fine.

One last piece of advice from a clumsy beginner to another. Commit your code to git as soon as something works. Before the next change. Before the exciting refactor. The command is git init, git add ., git commit -m "first working version". That's your save point in the video game. You can always go back. If you ever find yourself scared to try something, it's usually because you haven't committed recently. Commit, and the fear goes away.

Okay, back to Sofia.

Memory, Routines, and other 2026 features worth knowing from day one

Thanks Omar. Let me cover the 2026 additions, because beginners who start today get to skip a whole chapter of friction that people like me had to live through.

Memory. Claude Code now remembers things across sessions. There's a file in your project folder called CLAUDE.md and another in your home directory at ~/.claude/projects/<project-name>/memory/MEMORY.md. These are just markdown files. You can read them. You can edit them. Claude reads them at the start of every session and uses them as context.

What do you put in them? Start simple. "This is a beginner project. Explain things. Use plain HTML, no frameworks. I prefer comments in my code." That's a useful memory. Every future session will behave like your teacher is the same teacher. No more re-explaining who you are. For a deeper look, our post on Claude Code memory and persistent context walks through the full system.

Routines. These are scheduled tasks. You can ask Claude to run something every morning, like "review my repo for any new TODO comments and summarize them in a file called today.md." Beginners rarely use Routines on day one, but knowing they exist changes how you think about Claude. It's not just a tool you talk to when you have a question. It's an agent that can work on your behalf while you're asleep. When you're ready, you will use this.

Worktrees. Imagine you want to try two different designs for your task tracker at the same time. Worktrees let Claude spin up a parallel copy of your project in another folder, work on one version there, while the original stays untouched. You explore both. You pick the one you like. It's like taste-testing two sauces from the same base recipe. Overkill for your first project. Essential for your tenth.

/ultraplan. This is a command you can type inside Claude Code when you're about to build something bigger than a single file. It forces a planning session before any code gets written. Claude thinks out loud, drafts an architecture, asks you questions, and only proceeds once there's a real plan. Beginners often skip planning and then feel lost by the third file. /ultraplan is the antidote.

Hooks and skills. Hooks are scripts that run automatically before or after Claude does something (for example, format your code every time Claude edits a file). Skills are reusable reference documents for specific tasks, like "here's how I always deploy to Vercel." Both are power-user features. You don't need them this week. You will love them by month two.

If you're ready to dive deeper on the parallel side of things, read Claude Code parallel agents and worktrees. It's honestly my favorite feature of 2026, and the one that will make you feel like you work in a studio instead of a closet.

Shipping: your first deploy in two steps

Okay. Your task tracker runs on your own machine. The next rite of passage is getting it onto the internet, where your cousin, your roommate, your mom, your weird uncle can use it.

The easiest free path in 2026 is Vercel. Two steps.

Step one. Install the Vercel CLI:

npm install -g vercel

Step two. From your project folder, run:

vercel

It will ask you a couple of questions. Is this a new project? Yes. What's the name? Whatever you want. Which folder is your app in? The current one. Vercel pushes your file to the cloud, gives you a URL, and the URL is live in about ten seconds. Click it. Your task tracker is on the internet.

If you get stuck, the Vercel docs are genuinely good. But honestly, you probably won't. The CLI walks you through it.

I want you to do something for me. Send that URL to someone you care about. A friend, a parent, a partner. Don't explain what it is. Just send the link with a sentence: "I built this today." Watch what they say. That feeling, the first person using the first thing you made, is not something an article can simulate. It's the reason people get hooked. It's the reason I'm writing this instead of working at a bank.

Next steps

You've installed Claude Code, written a useful prompt, built a working app, recovered from a first error, learned the 2026 features, and deployed something to the internet. That is not a small day.

Here's where to go next.

• Our original 2025 beginner guide is the piece that went viral when Claude Code first hit the scene. It's worth reading for the archaeology alone, and a lot of the fundamentals still hold. Treat it as a companion volume to this one.
• 50 Claude Code tips is where you go when you're hungry for more. Small tricks, keyboard shortcuts, prompt patterns, workflows. Read it in ten-tip chunks. Try one or two each session. You'll feel the compounding within a week.
• The official Claude Code docs are where you look up the real answers. They're updated constantly, which in 2026 matters, because features ship fast.

Here's a tiny assignment, if you want one. Build a second tiny thing tomorrow. Don't repeat the task tracker. Pick a problem in your own life. A daily water counter. A birthday reminder. A simple calculator for splitting rent. Fifteen minutes. One file. Ship it. If you build three tiny things in your first week, you are officially not a beginner anymore. You are someone who makes software.

One more thing

My cousin in Lisbon, the one who thought she was too late, now ships a new thing every Sunday morning. She calls them her "breakfast apps." They're small. They're sometimes ugly. They solve the problem she woke up with. Her last one was a tracker for how many sourdough loaves she had to proof that week, with a countdown for each one. Completely useless to the rest of us. Completely essential to her.

That, to me, is what this whole tool is really about. Not productivity. Not shipping velocity. Not the word scalable. It's that the distance between I have an idea and I have a thing has collapsed for anyone who can describe what they want. If you made it this far, you can describe what you want. The rest is just typing.

So tell me. What's your first breakfast app going to be? I'd love to hear it. The conversation continues, and it continues with you.