01-Introduction

Welcome to Cloud Code, the highly agentic coding assistant. This short

course is built in partnership with Enthropic and Enthropics Eddie Show is back to share with us best practices for how to use cloud code. I'm really

excited about this short course. Cl is

my personal favorite coding assistant right now and it has boosted my and many other developers productivity by a large margin and it is a tool with a lot of

depth to it and so we want to get together with anthropic to teach hopefully the definitive course on all of the most important ideas behind how to use it in a systematic way.

>> Thanks Andrew. I'm excited to be back here and start like you mentioned from explaining what the tool is, how it works all the way towards using it in parallel with many different tools including git work trees and MCP

servers.

>> What I've seen over the last couple years is AI assisted coding has evolved rapidly. It started from maybe people

rapidly. It started from maybe people asking OM's occasional coding questions to then GitHub autocomplete to then you know various tools that became more and

more autonomous and clarico when it was released was definitely a step up in terms of the degree of agency or the amount of stuff that the coding assistant could do by itself. And so I

think many people are surprised that you could set a task that cla work on for many minutes or sometimes even more than a few minutes. And now there are developers that are orchestrating not

just a single cloud instance but even several of them working in parallel on different parts of a codebase. But

coordinating all this has a set of best practices that is not widely known. And

if you have not worked with people close to best practices I think there could be a big uplift still for mastering these best practices and knowing how they drive that amazing productivity that I'm

seeing many developers have using cloud code. So, as we start to talk about

code. So, as we start to talk about those best practices, a key tip for working with cloud code is providing clear context to help cloud code achieve the task you want efficiently. This

means pointing cloud code to the relevant files, clearly describing the features and functionality that you want and making sure that you're properly extending the capabilities of cloud code

with MCP servers and other tools in that ecosystem. In this course, you'll apply

ecosystem. In this course, you'll apply those best practices to three different examples. We'll start with a rag chatbot

examples. We'll start with a rag chatbot and you'll implement the features from the front end to the back end including refactoring code, writing tests, and then using the GitHub integration to work with pull requests and fixing

issues. You'll make use of many cloud

issues. You'll make use of many cloud code features like planning, thinking modes, creating parallel sessions, and managing cloud's memory. For the second example, we'll shift gears and work with

Jupyter notebooks to explore e-commerce data. We'll refactor notebooks using

data. We'll refactor notebooks using cloud code, remove redundant code, and create powerful dashboards with web applications. Finally, we'll move to

applications. Finally, we'll move to create a visual mockup based in Figma and use cloud code, the Figma MCP server, and a different MCP server to import the design, iterate, test, and

build aically a powerful front-end application. If you're not currently a

application. If you're not currently a cloud code user, I think learning this set of ideas will give you a meaningful acceleration in the rate at which you can engineer systems. And even if you

are a current cloud code user, I think having Ellie share these best practices with you in a comprehensive and systematic way will I hope leave you with quite a few new things you try that

will be useful for your work. I'd like

to thank from DL.AI Haras Salami who had contributed to this course. In the next video, Ellie will share Quo's underlying architecture. And you might be surprised

architecture. And you might be surprised by how simple the architecture is. Cloud

code relies on just a small number of tools to search for patterns within your code files to list directories, look at files, dox. It does not rely on

files, dox. It does not rely on semantically embedding your code in a codebase or transforming it into a searchable structure. And one of the

searchable structure. And one of the things that I think has made cloud code effective is how it agentically can read through your code to take notes in a file cloud.md to figure out autonomously

file cloud.md to figure out autonomously what is going on in your codebase to then drive decision- making on how to advance your code. That's right. And

because of that and not having a need to index the codebase, you can ensure the codebase stays local. We'll talk about some of the security ramifications with that. So, let's get started and I'll see

that. So, let's get started and I'll see you in the next video.