02-What is Claude Code?

In this first lesson, we'll go through

the agentic workflow of cloud code, the

tools it uses to navigate your codebase,

and the memory it keeps across sessions.

Let's dive in. So, let's talk a little

bit about what cloud code actually is.

When we talk about agentic systems, we

think a lot about a model, a set of

tools, and some environment to run those

tools. Models are great at handling

input and returning output. But in many

situations, those models don't know

about your codebase, how to find files,

and how to handle multiple tasks. So

instead of just talking directly to a

model, we're going to provide a very

lightweight harness for that model. And

through the command line, we're going to

use that harness to leverage the model's

intelligence to perform complex coding

tasks. So instead of giving a task

directly to the model and trying to find

all kinds of information in a codebase,

we're going to provide a set of tools.

We're going to provide an environment

and a couple other pieces of

functionality to enable the model to

comb through code bases and solve much

more complex problems. What are those

pieces of functionality that we're

talking about here? Enabling the model

to have memory. enabling our model here

to remember preferences of the user and

the codebase we're going through or the

task at hand. We're also going to give

the model an environment where it can

figure out what data it needs, formulate

a plan, and then take action. With just

a small amount of code, we can leverage

the model's intelligence to achieve

quite remarkable results. With cloud

code, your options are opus or sonnet

depending on the complexity, the kind of

task you're handling, and your

subscription. When we talk about what

claude code can do, it's very tempting

to just think this is the tool for

writing lots of code. But as we progress

in this course, we're actually going to

start with one of the most powerful

features of cloud code, which is its

ability to discover, explain, and

design. Before you start writing code

with cloud code, use it as a way to get

up to speed on a codebase. We'll talk

quite a bit about writing code with

cloud code, but we'll also talk about

ways in which you can use it outside of

the terminal in environments like

GitHub. We'll talk a bit about

refactoring, debugging errors, and where

this tool really shines. Not only is

this useful for coding, but also across

data analysis and any environment where

the model's intelligence can create

compelling visualizations, assets or

deliverables for you. We mentioned that

we give the model a harness. We give the

model an environment to gather context

and take an action. We talked a bit

about the memory that we provide to the

model and in a little bit we'll talk

about what that underlying memory looks

like. Now let's talk about the tools or

additional functionality that we let the

model know about. To give an

illustration of tool use, you can

imagine that the user asks what code is

written in a particular file. The model

does not know how to navigate or find

files and that's where tool use comes

into play. Out of the box, Claude Code

provides a relatively small list of

tools. One of those being the ability to

read a file. Now that the model knows

what to do, it can go ahead and read

that file, get the contents of that

file, and return the data to a user.

This ability of tool use allows the

model to go from a simple assistant to

an extremely sophisticated agentic tool.

We mentioned some of the tools that

claude code comes built-in with. Here is

a list of the tools that we have. Some

of those for editing across different

kinds of files, some of those for

reading across different files, and some

for doing additional actions like

finding patterns, searching things

across the web, and even creating or

running sub aents to handle very

difficult and challenging tasks.

Finally, since we're in the command

line, we're going to need a tool to

execute bash or shell commands. Tool use

is what allows cloud code to gather the

context and information that it needs.

This allows cloud code to tackle harder

problems. It also allows cloud code to

not have to index your entire codebase

and lead into potential security

concerns. Finally, cloud code is quite

extensible. While you just saw the list

of tools that cloud code comes built-in

with, you can also add additional tools

by connecting to MCP servers. MCP or the

model context protocol is an open-source

model agnostic protocol that allows for

data and AI systems to communicate

easily. These MCP servers can add

functionality to cloud code for a

variety of different tasks and we'll

explore a few of them over this course.

I want to take a little more time to

talk about what we mean by not indexing

a codebase. Instead of creating a

structured representation of the

codebase and constantly analyzing that,

cloud code instead uses a feature called

agentic search. Instead of requiring

that that codebase is sent to a server

and potentially leaving the ecosystem

that you're in, cloud code instead uses

one or many different agents and sets of

tools to find what it's looking for in

your codebase. This allows your code to

not have to be completely added to

context or to have to leave the

ecosystem that it's in which can create

certain security considerations. When we

talk about the memory of claude or its

ability to remember what has happened in

previous conversations or across all

kinds of actions, this is done using a

markdown file called claude.md. In your

Claude MD file, you can define common

configurations or style guidelines.

These files get automatically loaded

into context when launched. The

conversation that you have with cloud

code is stored locally on your machine.

You can clear that over the course of a

conversation. So you can start with a

new context window. But if for some

reason you need to continue that

previous one or resume the earlier

conversation, you can do so easily. I'm

going to head over to the terminal that

I have inside of VS Code. And we can see

I have a folder here called demo with

nothing in it. So let's start by opening

up claude code using the cloud command.

Depending on where this file is, and

especially the first time, it may ask if

I trust the files in this folder, which

I do. We've got a couple nice tips here

for getting started, but I'm just going

to start with a very simple prompt. Make

a cool visualization for me. I'm just

getting started. What we're going to see

here is Claude Code start to make a

to-do list of actions to take. You can

imagine this task might be to search

across a codebase, to edit files, to

write tests, to deliver insights, or in

our case to create a visualization.

Depending on how Claude is feeling, this

might be particles or fireworks or

something else. But I just want to show

you how quickly out of the box you can

start to see changes with Claude Code.

Since we're doing this inside of Visual

Studio Code and Claude Code has an

integration with that editor, we're

going to see visually the changes that

are being made. I'll accept those and in

future editions I'll let Claude Code do

that without requesting permission from

me. We can see here we have a

visualization that's built. Let's go

ahead and open it in the browser. I'll

ask Cloud Code to do that for me. It

will confirm this is the command. Let's

go see what it looks like. And here we

are with our visualization. Can add some

particles. It's looking a bit better. We

can toggle the animation, see what's

going on, and clear what we have here.

We can expand on this as much as we

want. We can change the functionality.

We can add whatever we want right here,

but I just want to show you out of the

box how seamless it is to get up and

running with this particular tool. In

the next lesson, we'll explore how to

use cloud code across a larger codebase

and take a step back and see just how

powerful it is for explaining larger and

more complex code bases.