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 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://cli.anthropic.com/install.sh | sh

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 Claude Code 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 safety feature and a good 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:

1. Describe what you want
2. Let Claude build it
3. Review the result
4. Ask for changes

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. Saying "build me a website" gives Claude almost nothing to work with, and it'll make dozens of decisions that you might disagree with. But saying "build me a website with a dark background, my name in large white text at the top, and three sections below for my work experience, skills, and contact details" gives Claude a clearer picture of what you need.

Here are a few approaches that work really well:

Include screenshots

If you have a screenshot of something you like - whether it's a design mockup, another website, or even a rough sketch on paper - you can paste it directly into Claude Code.

In the last few years, AI models have become incredibly good at analysing images. Claude can carefuly analyse a screenshot, identifying the layouts, colours, spacing, and individual components, then build towards it.

This removes a lot of ambiguity, as Claude can see exactly what you're after rather than having to interpret your description. You can paste these images directly into the Claude Code terminal or chat interface.

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.

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:

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 do this by typing /plan or pressing Shift+Tab.

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 are 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 - and it's not what you'd expect.

The biggest risk 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.

Here are some things that experienced developers know instinctively, but beginners often don't:

API keys and secrets should never be in your code. When you connect your app to a service - like a payment provider, a database, or an AI model - you'll need to use a secret key. If that key ends up in your code and you push it to a public GitHub repo, it's visible to everyone. Anyone can find it, use it, and potentially run up charges on your account. Claude can sometimes store your keys directly in the code and won't always flag it as a problem, so you need to be aware of this.

User data needs to be handled properly. If your app collects any personal information - names, email addresses, anything - there are legal requirements around how you store and process that data. GDPR applies if you have any users in Europe, and getting this wrong can have real consequences. This isn't something that Claude will always flag unprompted.

Cloud costs can spiral quickly. Deploying an app to AWS or Azure is really straightforward with Claude's help, but if you don't understand the pricing model - you can run up a serious bill. I've seen stories of people getting unexpected invoices, as they didn't realise that a specific setting was costing them money.

Security isn't optional. Things like authentication, input validation, and HTTPS are the minimum for any app that's publicly accessible. Claude will often implement these for you, but the implementations aren't always robust - and you might not have the knowledge to tell the difference between a solid implementation and one that has gaps.

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. Asking "search my code for security issues" won't always spot everything, because Claude doesn't have a checklist it's working through - it's pattern matching, and patterns get missed.

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.

After watching quite a few non-developers use Claude Code, I've noticed some patterns in what separates a good experience from a frustrating one. Here are the things that consistently make the biggest difference.

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.

To enable it, open VS Code's settings, navigate to Extensions, and find the Claude Code section. Tick the "Allow Dangerously Skip Permissions" checkbox - it sounds dramatic, but it's perfectly safe inside a disposable Codespace.

Once that's enabled, go back to the mode selector and you'll see "Bypass permissions" as a new option. Select it, and Claude will be able to create files, run commands, and make changes without asking you each time.

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 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.

I've seen a growing number of non-developers start using Claude Code, and the results have been genuinely impressive. Here's a summary of the key lessons from this guide.

Claude Code has genuinely lowered the barrier to building software. You don't need a computer science degree, years of experience, or even a single line of code - you just need a clear idea of what you want and the willingness to describe it precisely.

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 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: