A beginner's guide to
Claude Code

Before we get started, it's worth explaining what Claude Code actually is - as it's different from the Claude chatbot you might have used before.

Claude Code is a tool from Anthropic that runs inside your terminal, which is a text-based interface on your computer. Unlike the Claude chatbot, which can only give you advice in a browser window, Claude Code works directly with the files on your computer.

It can create new files, edit existing ones, install software, and build entire projects from scratch. All you do is describe what you want, and Claude Code figures out how to make it happen.

This is what makes it so powerful for people, especially if you're not a developer and have never written code before. Instead of writing the code yourself, you simply describe what you want and Claude Code does it for you. And if you find that your software doesn't work the way you expected, just describe the problem and Claude will try to fix it.

This is where things get exciting. Claude Code can build a surprisingly wide range of things, and many of them are genuinely useful for people who don't code. Here are some of the most common things I've seen people build:

Personal websites & portfolios

A clean multi-page site Claude can build in minutes — and host for free on Vercel or Netlify.

Show more

Simple web apps

Budget trackers, habit trackers, recipe collections — anything that displays and organises information.

Show more

Automations & scripts

Small programs that handle repetitive computer tasks — renaming files, processing data, converting images.

Show more

Chrome extensions

Browser widgets that do one thing well — text highlighters, time-zone helpers, page utilities.

Show more

Landing pages

A quick page to test an idea — headline, features, sign-up form, all without spending on a designer.

Show more

Internal tools for work

Dashboards, forms, calculators — practical software your team can actually use.

Show more

Before we dive in and get setup, it's worth explaining the different ways that you can interact with Claude Code. There are three options for you to choose from:

They're all running the same AI tool underneath, so the only difference is the interface. Your paid Anthropic plan covers all three and you can easily switch between them.

For this guide, I'm going to focus on the VS Code extension as I think it's the best option for most people, especially if you're new to all this. The skills carry across all three, so you can switch later without having to relearn anything.

The terminal

The terminal is the original way to use Claude Code, and it's still what a lot of developers prefer. There's no real UI - you just type your messages and Claude responds. It's very lightweight, fast, and runs anywhere. The downside is that the terminal can feel intimidating if you've never used one before, and you don't see your files unless you open them in another window.

VS Code extension (recommended)

This is what I'd recommend for most people. VS Code is a free code editor from Microsoft, and the Claude Code extension runs the same AI you'd get in the terminal - but inside a much friendlier interface.

You can paste screenshots and see them in the chat window, scroll back through your conversation, and adjust settings without having to remember any commands. But the most important thing is that your files sit right next to the chat - so when Claude creates or edits something, you can see exactly what was changed.

It's really easy to get set up and I'll walk you through the entire process in the next section - but this view will really pay off the moment something goes wrong. I find it much easier to keep track of what Claude is doing when I can see the files alongside the conversation.

Claude desktop app

Anthropic also has a desktop app that you can download, where Claude will work either on files on your computer or in a connected GitHub repo through a cloud environment. The interface looks great, so it's probably the most welcoming option if the idea of code makes you nervous.

The trade-off is that everything happens at a higher level of abstraction. You'll see whatever Claude has just edited in the chat, but there's no easy way to step back and browse through all of your project's files in one place. Over time, that means you have less of a feel for the wider picture - what files exist, how they fit together, and what's changed since you started - and less of a sense of control over the project as a whole.

If you have no coding experience at all, I'd still pick the extension over the app for this reason. Seeing all of your files alongside the conversation makes it much easier to catch mistakes before they become real problems.

There's also a web version that mirrors the desktop app - if you've used either, the experience is essentially the same. Whichever interface you choose, the prompts and habits in this guide will work the same way.

This is the part that puts most people off, but it's incredibly straightforward and I'll walk you through the entire process.

Before you start, here's what you'll need:

• A Mac or Windows computer - Claude Code works on both, and on Linux too
• An internet connection - Claude Code needs to connect to Anthropic's servers
• A paid Anthropic account - either a Pro ($20/month), Max, Teams, or Enterprise plan. The free Claude.ai plan doesn't include access to Claude Code

That's it. You don't need to install anything else in advance - the installer handles everything for you.

Open the terminal

The terminal is where you type commands and install software packages. It might feel unfamiliar if you've never used one before, but don't worry - you'll only need a handful of commands to get started.

Press Cmd + Space to open Spotlight, type "Terminal", and press Enter. You should see a window appear with a blinking cursor, which is where you'll type your commands.

Install Claude Code

Paste the following command into your terminal and press Enter:

Installation command

Copy

curl -fsSL https://claude.ai/install.sh | bash

You'll see some text scroll past as it downloads and installs - this is normal. Once it's finished, you should see a message confirming that the installation was successful.

Sign in

Once the installation is complete, type claude and press Enter. You'll be asked to sign in with your Anthropic account - follow the on-screen instructions, and after a few seconds you should see Claude's interface appear in your terminal. It looks like a chat window with a text area at the bottom where you can type your messages. If you see that, you're ready to go.

If you run into any issues during this process, don't panic. Simply open your browser and describe the error to Claude's chatbot, which will help you troubleshoot the issue. Most installation problems are pretty straightforward and can be fixed quickly.

View your files

As you start building, Claude will create real files on your computer - and you'll want a way to see them. You can always open your project folder in Finder (Mac) or File Explorer (Windows) to browse what's been created, and that works fine for simple projects.

But if you want a better view, I'd recommend installing VS Code - it's a free code editor from Microsoft. It gives you a sidebar where you can see all of your project files, open them with a click, and see the code that Claude has written. You don't need to understand the code, but being able to see the file structure helps you keep track of what's been built.

Use the VS Code plugin

VS Code also has a Claude Code extension, which lets you run the tool directly inside the editor instead of the terminal. It gives you a friendly chat interface that a lot of people prefer - and you can see your files, your code, and your conversation with Claude all in one place.

To set it up, open the Extensions tab in VS Code (the icon with four squares on the left sidebar), search for "Claude Code", and click Install.

Once it's installed, you'll see an orange Claude icon in the app - which can be found at the top right of the screen. Simply click it to open the chat panel and you're ready to go. It's the exact same version of Claude Code running underneath, so everything you learn in this guide applies to both the VS Code Plugin and the Terminal interface.

Now that you've got Claude Code installed and a project folder ready, let's build something. The best way to learn is by doing, so we're going to start with a small project and work through it together.

Make sure you're inside your project folder in the terminal, then type claude and press Enter to start Claude Code.

When Claude Code starts working on a task, it will ask for your permission before it creates any files or runs commands on your computer. You'll see a prompt asking you to "Allow" or "Deny" each action. This is a good safety feature, as it means that Claude can't make changes without your approval.

For now, you can safely allow Claude to create and edit files. Just read what it's asking to do before you hit accept. If you're ever unsure, you can deny the action and ask Claude to explain what it's trying to do.

Let's start with something simple and create a personal website. Here's what you might type:

After you send this, Claude will start creating files on your computer. You'll see it working in real time - creating HTML files, writing CSS for the design, and setting up the structure of your website. It might ask you some questions along the way, like what colours you prefer or how you'd like the navigation to work.

Once it's done, you'll want to see the result. The easiest way is to ask Claude directly:

You should now see your website appear in your browser - with your name, a bio section, and the pages you asked for. It won't be perfect, but it'll be a real website that you built in a few minutes.

Now that you've got a decent starting point, you can change the website's design and improve it over time. Try changing the colours, swapping the layout, or adding a new section - just tell Claude what you'd like to do and it'll handle the rest.

Whether you're building from scratch or refining what's already there, the process is always the same:

It's a conversation, not a one-shot command. You can keep going back and forth, and Claude will build on what it's already created - so you don't need to get everything right in your first message.

When you're done for the day, type /exit to leave Claude Code. Your files are saved on your computer, so closing Claude Code won't delete anything. To pick up where you left off, just open the terminal, navigate back to your project folder cd ~/Desktop/my-first-project and type claude again.

This is where you'll see the biggest improvement in your results, as the quality of what Claude builds depends on how well you describe what you need. And the good news is that you don't have to use any technical jargon, you just need to be specific.

The number one mistake people make is being too vague. Here's the same idea written two ways:

The first one gives Claude almost nothing to work with - it'll make dozens of decisions you might disagree with. The second one paints a clear picture, and you'll get something close to what you actually wanted on the first try.

Here are four techniques that consistently make prompts more specific:

Here's what a prompt looks like when all four techniques come together:

The more specific you are from the start, the less time you'll spend going back-and-forth trying to correct things afterwards. It's worth spending an extra minute on your prompt to save yourself ten minutes of revisions.

You don't need to understand every line of code that Claude writes - but you should understand the general decisions that it's making. Claude can choose an approach that seems reasonable, but isn't what you had in mind - so you need to be able to spot this before it goes too far.

Start with plan mode

The single best habit you can build as a beginner is to use plan mode. Instead of jumping straight into writing code, plan mode forces Claude to think through its approach and present it to you before it makes any changes.

You can switch to plan mode by pressing Shift+Tab - it works the same way whether you're in the terminal or the VS Code extension. Alternatively, you can click on the Mode button in the bottom right of the chat window and choose Plan mode.

This means you get to review the plan and say "actually, I'd prefer it to work like this" before Claude has written hundreds of lines of code that you'll need to undo. It's really valuable when you're building something complex, and I'd recommend using it for anything beyond simple changes.

Of course, it adds a bit of time upfront - but it means you catch misunderstandings early, rather than discovering them after Claude has already built the wrong thing.

Claude will then give you a summary of the files it's created, what each one does, and why it made certain decisions. If something doesn't sound right, you can always ask a follow-up question or tell Claude to take a different approach.

In most cases, Claude will clearly explain the idea and it might even suggest a simpler alternative. This back-and-forth is how you'll gradually build your understanding of what's happening with the code - and it will make you better at describing what you want in future conversations.

It's inevitable that things will go wrong at some point. This is completely normal and to be expected - even experienced developers run into issues and have to debug them. So don't take it as a sign that you're doing something wrong.

The most common issue you'll face is that Claude will build something that doesn't look or behave the way you expected. When this happens, the best approach is to describe what you're seeing and how it differs from what you wanted.

You'll notice that some of these techniques - like describing things visually and using screenshots - are the same ones from earlier in this guide. That's because the skills that help you get great results in the first place are also the ones that help you fix problems when they come up.

Use screenshots

This is your best friend when things go wrong. Take a screenshot of what you're seeing and paste it directly into Claude Code. This gives Claude the same view that you have and removes any ambiguity about what the problem is.

Make sure that you also include a description of the problem and be specific about what the issue is - a screenshot on its own isn't always enough.

That way, if something goes wrong later, you can just say "undo the last set of changes" and Claude will take you back to a clean starting point. It's one of those things that takes ten seconds to set up and can save you hours of frustration.

This is the section that I want you to read carefully, because it covers the biggest risk for non-coders using Claude Code - which isn't building the wrong thing. It's not knowing what questions to ask.

Claude Code can build apps with databases, user accounts, payment processing, and then deploy them to AWS, Azure, or Vercel. It can do really impressive things and create software in seconds.

But there's a huge gap between "it works" and "it's safe" - and if you don't have a technical background, you might not even realise this gap exists. Building software involves hundreds of small decisions that experienced developers have learned to make almost without thinking - they've seen things break, they've read the horror stories, and they've picked up good practices that shape how they work.

Without that context, the gap is less about making worse decisions and more about not realising certain decisions need to be made in the first place. So here are some of the things that experienced developers know instinctively, but beginners probably don't know:

The tricky part is that Claude can catch some of these issues - but you can't rely on it 100%. It might flag an exposed API key in one file and miss another. Telling it to "search my code for security issues" won't always spot everything. Claude Code is an incredibly powerful tool, but it can make mistakes - subtle issues can slip past even when you've explicitly asked it to look for them, so a thumbs up from Claude doesn't always that mean your code is actually secure.

This is the huge gap between developers and those with no technical background. The experienced developers know what they should be looking for and can verify Claude's work. But beginners are relying on Claude to catch problems that it might have introduced itself.

There's a simple rule of thumb here. If your app handles other people's data, processes payments, or is publicly accessible on the internet - you should get a developer to review your code before you launch it. This isn't a failure on your part - it's just the sensible thing to do, and it's exactly what I'd recommend to anyone in this situation.

For personal projects that only you use - like a budget tracker on your own laptop, a script that renames your photos, or a website that doesn't collect any data - the risk is much lower and you don't need to worry as much.

This is useful if you're worried about Claude making changes to important files on your computer. It gives you a fully disposable environment, with extra peace of mind built in.

The easiest way to do this is with GitHub Codespaces. It gives you a temporary computer in the cloud and lets Claude create, edit, and delete files without touching anything on your real machine.

If something goes wrong, you can just delete the environment and start again. GitHub gives you a generous amount of free Codespaces usage each month, so you don't need to worry about unexpected bills.

To get started, you'll need to push your project to GitHub. If you haven't done this before, just ask Claude to help - it can walk you through the entire process.

After a few seconds, you'll see a full VS Code editor running in your browser - with your project files on the left, the code in the middle, and Claude Code ready to go in the terminal at the bottom. Everything runs in the cloud, so nothing touches your actual computer.

Once that's enabled, go back to the chat panel and click the mode selector at the bottom. You'll see "Auto mode" as a new option. Select it, and Claude will be able to create files, run commands, and make changes without stopping to ask - while still being held back from anything genuinely dangerous.

You don't need to become a developer to keep using Claude Code effectively. But if you want to go further, understanding a few basic concepts will make a noticeable difference to the quality of what you build.

Here are the things I'd recommend learning first:

What files and folders do. Understanding how a project is structured - where the code lives, where the styles are, where the images go - will help you give Claude better instructions. You don't need to read the code, but knowing that "the homepage is in index.html" or "the styles are in styles.css" means that you can point Claude to specific places.

What HTML, CSS, and JavaScript do. You don't need to write any of these, but understanding what each one is responsible for will help you communicate with Claude. HTML is the content and structure, CSS is the design and layout, and JavaScript is the behaviour and interactivity. When Claude asks "should I add this as a CSS animation or a JavaScript animation?", you'll have enough context to make a decision.

How to use Git and GitHub. Git is a version control system that saves snapshots of your project, so that you can go back to a previous version if something breaks. GitHub is a popular platform, which allows you to store these projects online. Naturally, Claude Code will work with both of these, and understanding the basics will help you manage your projects more confidently. If you're unsure, just ask Claude.

What deployment means. Deployment is the process of making your project available on the internet, so that other people can access it. Platforms like Vercel make this surprisingly easy, and Claude can walk you through the entire process. Understanding the basics of deployment will help you take your projects from "it only works on my computer" to "anyone can visit it."

If you've built something with Claude Code and you're hungry to learn more, I'd recommend picking up a free beginner's course on HTML and CSS. freeCodeCamp is a great place to start - it's completely free, self-paced, and walks you through the basics interactively. You don't need to master any of it - but even a surface-level understanding will improve how you communicate with Claude and allow you to spot issues more quickly.

And if you're an experienced developer looking for more advanced strategies, I've written a separate guide that covers the techniques I use daily in my professional work - including MCP servers, custom slash commands, context window management, and more.

This guide covered a lot of ground - from understanding what Claude Code is and getting it installed, through writing your first prompts, debugging when things go wrong, and the risks that aren't always obvious when you're starting out. The most important thing now is to keep using it - these habits get easier the more you practice them, and the more you build, the better you'll get at describing what you want. Below is a quick summary of the key lessons to keep handy as you go.

Claude Code has genuinely lowered the barrier to building software. You don't need to have a computer science degree, years of experience, or be able to write a single line of code - you just need a clear idea of what you want and describe how it should look.

But it's important to be honest about the limitations. Claude Code is a powerful tool, not a magic wand. It will make mistakes, it won't always catch security issues, and there are things that still require a developer's expertise to get right. The key is knowing where that line is and being comfortable with asking for help when you need it.

If you found this guide useful, you'll enjoy my weekly newsletter - every week I analyse the latest AI advances and how you can use them. It's free and you can unsubscribe at any time.

Loop Newsletter

Get weekly AI insights delivered
to your inbox

Subscribe for free

Read by executives at: