← Back to videos

🚨 BREAKING NEWS! The engineer who created Claude Code from scratch just posted a 28-minute video

Rahul Kumar

Rahul Kumar

@RahulTechX

November 18, 2026Β· 27:55

🚨 BREAKING NEWS! The engineer who created Claude Code from scratch just posted a 28-minute video that's pure gold: how to write prompts that actually deliver ridiculously good results. I've seen $300 courses that don't even come close to what he explains in the first 10 minutes. CLAUDE.md files, memory shortcuts, parallel sessions, and prompting patterns that almost no one uses… All in one video. Completely free. No fluff. Whether you're a developer, just starting out now, or already using Claude for months: this changes the game for you starting today. Save. Watch. Share.

Transcript

0:04
Hello. Hey everyone
0:08
I'm Boris. I'm a member of technical staff here at Anthropic
0:11
and I created Quadcode
0:13
And
0:14
here to talk to you a little bit
0:15
about some practical tips and tricks for using
0:17
Quadcode
0:19
it's gonna be very practical
0:20
I'm not gonna go
0:21
too much into the history or the theory
0:23
or anything like this
0:25
and yeah, before we start, actually
0:27
can we get a quick show of hands
0:28
who has used Quadcode before?
0:32
Yeah
0:33
All right, that's what we like to see
0:34
For everyone that didn't raise your hands
0:37
I know you're not supposed to do this
0:38
while people are talking
0:38
but if you can open your laptop and type this
0:46
and this will help you install Quadcode
0:48
just so you can follow along for the
0:49
rest of the talk
0:55
All you need is Node.js if
0:57
if you have it
0:57
it should work
1:04
Yeah, if you, well, you don't have to
1:06
you don't have to follow on
1:06
but if you don't have it yet
1:08
you know
1:08
this is your chance to install it so
1:10
you can follow on
1:14
So what is quadcode?
1:15
Quadcode is a new kind of AI assistant
1:19
and there's been different generations of
1:21
AI assistants for coding
1:23
Most of them have been about completing
1:24
you know, like a line at a time
1:26
completing a few lines of code at a
1:27
time
1:28
Quadcode is not for that
1:30
It's fully agentic. So it's meant for building features
1:33
for writing entire functions
1:35
entire files, fixing entire bugs at
1:38
at the same time
1:41
And what's kind of cool about Cloud Code
1:42
is it works with all of your tools
1:44
and you don't have to change out your workflow
1:46
you don't have to swap everything to start
1:47
using it. So whatever IDE you use
1:50
if you use VS Code or if you
1:52
use Xcode or if you use
1:54
JetBrains IDEs
1:56
there's some people at Anthropic that you can't
1:58
pry them from their cold
1:59
dead hands
2:00
but they use Cloud Code
2:02
because Cloud Code works with every single IDE
2:04
every terminal out there
2:06
It'll work locally
2:07
over remote SSH, over Tmux, whatever environment you're in
2:11
you can run it
2:15
It's general purpose
2:16
and this is something where if you haven't
2:18
used these kind of free-form coding assistants in the
2:21
in the past
2:22
it can be kind of hard to figure
2:23
out how to get started
2:24
because you open it up and you just
2:25
see a prompt bar
2:26
and you might wonder
2:27
like, what do I
2:27
what do I do with this?
2:28
What do I type in?
2:30
It's a power tool
2:30
so you can use it for a lot of things
2:32
but also because it can do so much
2:34
we don't try to guide you towards a particular workflow
2:36
because really you should be able to use
2:38
it however you want as an engineer
2:45
As you open up Cloud Code for the first time
2:47
there's a few things that we recommend doing
2:49
to get your environment set up
2:51
And these are pretty straightforward
2:52
So run terminal setup
2:53
this will give you shift enter for new lines
2:55
so you don't have to do
2:56
like backslashes to enter new lines
2:58
This is, you know, it
2:59
it makes it a little bit nicer to
3:00
use
3:01
Do slash theme to set light mode or
3:03
dark mode or Daltonize themes
3:07
you can do slash install GitHub app
3:09
So today when s- we
3:10
announced a GitHub app where you can at mention
3:14
cloud on any GitHub issue or pull request
3:17
So to install it
3:18
just run this command in
3:19
in your terminal
3:21
you can customize the
3:23
set of allow tools that you can use
3:24
so you're not prompted for it every time
3:25
This is pretty convenient
3:27
for stuff that I'm prompted about a bunch
3:28
I'll definitely customize it in this way
3:30
so I don't have to accept it every
3:31
time
3:32
And something that I actually do is
3:34
for a lot of my prompts
3:35
I won't hand type them into Cloud Code
3:38
If you're on macOS
3:39
you can go into your system settings under accessibility as dictation
3:42
and you can enable it
3:44
And so something I do is you just hit
3:45
like, the dictation key twice
3:47
and you can just speak your prompt
3:50
And it helps a lot to have specific prompts
3:52
so this is actually pretty awesome
3:53
You can just talk to Cloud Code and
3:55
like you would another engineer
3:56
and you don't have to type a lot
3:57
of code
4:02
So when you're starting out with Cloud Code
4:04
it's so freeform, and it can do everything
4:06
What do you start with?
4:08
The thing I recommend above everything else is
4:10
starting with code-based Q&A. So just asking your question
4:12
asking questions to your code base
4:15
This is something that we teach new hires
4:17
at Anthropic
4:18
So on the first day in technical onboarding
4:20
you learn about Cloud Code
4:21
you download it, you get it set up
4:23
and then you immediately start asking questions about
4:25
the code base
4:26
And in the past
4:27
when you were doing technical onboarding
4:28
it's something that taxes the team a lot
4:30
right? You have to ask other engineers on the team questions
4:34
you have to look around the code
4:35
and this takes a while
4:36
you have to figure out how to use the tools
4:37
this takes a long time
4:40
With Cloud Code, you can just ask Cloud Code
4:42
and it'll explore the code base
4:43
it'll answer these kind of questions
4:45
And so at Anthropic
4:46
onboarding used to take about two or three
4:47
weeks for technical hires. It's now about two
4:49
or three days
4:53
What's also kind of cool about Q&A is we
4:56
we don't do any sort of indexing
4:57
So there's no remote database with your code
4:59
we don't upload it anywhere
5:00
your code stays local
5:02
we do not train generative models on the
5:04
code
5:05
So it's there, you control it
5:07
there's no indices or anything like this
5:09
And
5:10
what that means is also there's no setup
5:11
So you start Claude
5:12
you download it, you start it, there's no indexing, you don't have to wait
5:15
you can just use it right away
5:19
This is a technical talk
5:20
so
5:20
I'm gonna show some very specific prompts and
5:22
very specific code samples that you can use
5:24
and hopefully improve and
5:25
uplevel your Claude Code experience
5:28
So some kind of questions that you can ask is
5:30
you know, like
5:31
how is this particular piece of code used?
5:33
Or how do I instantiate this thing?
5:34
And Claude Code, it won't just do
5:35
like
5:35
a text search and try to answer this
5:37
It'll often go a level deeper
5:39
and it'll try to find examples of how
5:41
is this class instantiated
5:42
how is it used?
5:44
And it'll give you a much deeper answer
5:46
so something that you would get out of
5:47
a wiki or documentation
5:48
instead of just, like, command F
5:52
Something that I do a lot also
5:53
is ask it about git history
5:55
So, for example, you know
5:57
why does this function have fifteen arguments
5:59
and why are the arguments named this weird
6:00
way?
6:01
And this is something I bet in all
6:02
of our codebases
6:03
you have some function like this or some
6:05
class like this
6:07
And Cloud Code can look through Git history
6:09
and it'll look to figure out how did
6:11
these arguments get introduced
6:12
and who introduced them
6:13
and what was the situation
6:14
what are the issues that those commits link
6:15
to
6:16
And it'll look through all this and summarize
6:18
it
6:18
And you don't have to tell it that in all these
6:20
in all this detail
6:21
You just ask it
6:22
So just say, look through Git history
6:23
and it'll know to do this
6:26
The reason it knows
6:27
by the way
6:27
is not because we prompted it to
6:29
There's nothing in the system prompt about looking
6:30
through Git history
6:32
It knows it because the model is awesome
6:34
And if you tell it to use Git
6:35
it'll know how to use Git
6:37
So
6:37
we're lucky to be building on such a
6:38
good model
6:40
I often ask about
6:42
GitHub issues, so, you know, it can use WebFetch
6:46
and it can fetch issues and look up
6:47
context on issues too
6:48
and this is pretty awesome
6:51
Yeah
6:51
and this is something that I do
6:53
every single Monday in our weekly standup is I ask
6:56
what did I ship this week?
6:57
And Cloud Code looks at the log
6:58
it knows my username
6:59
and it'll just give me a nice readout of everything I
7:02
I shipped
7:02
and I'll just copy and paste that into
7:03
a doc
7:09
So yeah, that's tip number one
7:10
For people that have not used Cloud Code before
7:12
if you're just showing it to someone for the first time
7:14
onboarding your team
7:16
the thing we definitely recommend is start with
7:17
code-based Q&A. Don't start by using fancy tools
7:20
don't start by editing code
7:21
just start by asking questions about the code base
7:23
and that'll teach people how to prompt
7:25
And it'll start teaching them this boundary of
7:27
like, what can Cloud Code do
7:28
what is it capable of
7:29
versus
7:30
what do you need to hold its hand
7:31
with a little bit more?
7:32
What can be one-shotted
7:33
what can be two-shotted
7:34
three-shotted
7:35
what do you need to use interactive mode
7:36
for in a REPL?
7:40
Once you're pretty comfortable with Q&A
7:42
you can dive into editing code
7:44
This is the next thing
7:46
And the cool thing about
7:48
any sort of agentic
7:50
you know, like
7:51
using a
7:51
LM in a agentic way is you give it tools
7:53
and it, it's just, like, magical
7:54
It figures out how to use the tools
7:56
And with Cloud Code
7:57
we give it a pretty small set of tools
7:58
it's not a lot
8:00
And so it has a tool to edit files
8:02
it has a tool to run bash commands
8:04
it has a tool to search files
8:05
and it'll string these together to explore the code
8:08
brainstorm, and then finally make edits
8:12
And you don't have to prompt it specifically
8:14
to use this tool and this tool and this tool
8:15
you just say
8:16
you know, do this thing
8:16
and it'll figure out how to do it
8:18
It'll string it together in the right way
8:19
that makes sense for cloud code
8:25
There's a lot of ways to use this
8:26
Something I like to do sometimes is before
8:29
having cloud jump in to write code
8:32
I'll ask it to brainstorm a little bit
8:33
or make a plan
8:35
This is something we highly recommend
8:37
and something I see sometimes is people
8:38
you know, they take cloud code and they ask it
8:41
hey, implement this enormous, like, three thousand line, feature
8:45
and sometimes it gets this right on the
8:46
first shot
8:47
But sometimes what happens is
8:49
the thing that it built is not at
8:50
all the thing that you wanted
8:52
And the easiest way to get the result
8:53
you want Is ask it to think first
8:56
So brainstorm ideas, make a plan, run it by me
8:58
ask for approval before you write code
9:01
And you don't have to use plan mode
9:03
you don't have to use any special tools
9:04
to do this. All you have to do is ask Claude
9:06
and it'll know to do this
9:08
So just say, before you write code
9:09
make a plan. That's it
9:13
This is also
9:14
I want to include this on this commit
9:15
push here. This is a really common incantation
9:17
that I use. There's nothing special about it
9:19
but Claude is kind of smart enough to interpret this
9:21
so it'll make a commit
9:22
it'll push it to the branch
9:23
make a branch
9:23
and then make a pull request from Yon
9:24
GitHub
9:25
You don't have to explain anything
9:26
It'll look through the code
9:27
it'll look through the history
9:29
it'll look through the Git log by itself
9:30
to figure out the commit format and all the stuff
9:32
and it'll make the commit and push it
9:34
the right way
9:36
Again, we're not system prompting it to do this
9:39
it just knows how to do this
9:40
The model is good
9:44
As you get a little bit more advanced
9:46
you're going to want to start to plug
9:47
in your team's tools
9:48
and this is where Claude Code starts to
9:50
really shine
9:51
And there's generally two kinds of tools
9:53
So one is batch tools
9:54
and an example of this
9:55
I just made up this like Burley CLI
9:57
this isn't a real thing
9:59
but you can say
9:59
use this CLI to do something
10:01
And you can tell Cloud Code about this
10:03
and you can tell it to use
10:04
for example
10:05
like dash dash help to figure out how
10:06
to use it
10:07
And this is efficient
10:09
If you find yourself using it a lot
10:10
you can also dump this into your CloudMD
10:12
which we'll talk about in a bit
10:13
so Cloud can remember this across sessions
10:15
But this is a common pattern we follow at Anthropic
10:18
and we see external customers use too
10:21
And same thing with MCP
10:23
Cloud Code can use batch tools
10:24
it can use MCP tools
10:25
so, you know, just tell it about the tools
10:27
and you can add the MCP tool
10:29
and you can tell it how to use it
10:30
and it'll, it'll just start using it
10:33
And this is extremely powerful
10:34
cause
10:35
when you start to use code on a new code base
10:38
you can just give it all of your tools
10:40
all the tools your team already uses for this code base
10:43
and Cloud Code can use it on your
10:44
behalf
10:50
There's a few common workflows
10:53
and this is the one that I talked about already
10:55
so kind of do a little bit of exploration
10:57
do a little bit of planning
10:58
and ask
10:59
ask me for confirmation before you start to
11:01
write code
11:02
These other two on the right are extremely
11:04
powerful
11:05
When Claude has some way to check its work
11:07
so for example
11:08
by writing
11:09
unit tests or screenshotting in Puppeteer or screenshotting the iOS simulator
11:14
then it can iterate
11:16
And this is incredible
11:16
because if you give it
11:17
for example, a mock, and you say, build this web UI
11:20
it'll get it pretty good
11:22
but if you let it iterate two or three times
11:24
often it gets it almost perfect
11:26
So
11:26
the trick is give it some sort of
11:28
tool that it can use for feedback to check its work
11:31
and then based on that
11:32
it will iterate by itself
11:33
and you're gonna get a much better result
11:35
So whatever your domain is
11:36
if it's unit test or integration test or
11:38
screenshots for apps or web or anything
11:41
just give it a way to see its result
11:42
and it'll iterate and get better
11:49
So these are the next steps
11:50
Teach Quad how to use your tools
11:51
and figure out the right workflow
11:53
if you want Quad to jump into code
11:55
if you want it to brainstorm a little bit
11:56
make a plan, if you want it to iterate
11:58
kind of have some sense of that
11:59
so you know how to prompt Quad
12:01
to do what you want
12:06
As you go deeper
12:07
beyond tools
12:08
you want to start to give Quad more
12:09
context
12:10
And the more context
12:11
the smarter the decisions will be
12:12
because as an engineer working in a codebase
12:14
you have a ton of context in your
12:15
head about your systems and all the history and
12:18
and everything else, so you can
12:20
there's different ways to give this to Quad
12:22
And as you give Quad more context
12:23
it'll do better
12:25
There's different ways to do this
12:27
The simplest one is what we call QuadMD
12:30
And Quad.md is the special file name
12:33
The simplest place to put it is in
12:35
the project root
12:36
So the same director you start Quad in
12:38
Put a QuantumD in there
12:40
and
12:40
that'll get automatically read into context at the
12:42
start of every session
12:43
and essentially the first user turn will include
12:45
the QuantumD
12:48
You can also have a local QuantumD
12:50
and, this one you don't usually check into source control
12:53
so QuantumD you should check into source control
12:56
share with your team so that you can
12:57
write it once and share it with your
12:59
team
13:00
This one you don't check in
13:01
it's just for you
13:03
The kinds of things you put in QuantumD
13:05
it's like common bash commands
13:06
common MCP tools, architectural decisions, important files
13:11
anything that you would
13:12
kind of typically need to know in order
13:14
to work in this codebase
13:15
Try to keep it pretty short
13:16
because if it gets too long
13:18
it's just going to use up a bunch of context
13:20
and it's usually not that useful
13:21
so just try to keep it as short
13:22
as you can
13:23
And for, for example, in our codebase we have
13:27
common bash commands, we have a style guide
13:29
we have a few core files
13:30
kind of things like that
13:32
All the other QuantumDs
13:33
you can put them in other nested shell directories
13:36
and Cloud will pull them in on demand
13:39
So these are the quad MDs that will
13:40
get pulled in automatically
13:42
but then also you can put in
13:43
put quad MDs in nested directories
13:45
and those will get put
13:46
those will get automatically pulled
13:48
when quad works in those directories
13:51
and of course, if you're, you know, a company
13:53
maybe you want a quad MD that's shared
13:55
across all the different code bases
13:56
and you want to manage it on behalf of your users
13:58
and you can put in your enterprise root
14:00
and that'll get pulled in automatically
14:05
There's a ton of ways to pull in
14:07
context. I actually had a lot of trouble
14:08
putting this slide together
14:10
just to communicate the breadth of ways you
14:11
can do this
14:12
But quad MD is pulled in automatically
14:15
You can also use slash commands
14:16
So this is dot quad slash commands
14:18
and this can be in your home directory
14:20
or it can be checked into your project
14:21
and this is for slash commands
14:24
And over here
14:26
we have a few examples of
14:28
the slash commands that we have in quad
14:30
code itself
14:32
And so, for example
14:32
if you're in the Cloud Code repo
14:34
and you see issues getting labeled
14:36
that's actually this workflow running here
14:38
It's labeled GitHub issues
14:40
And we have a GitHub action running
14:41
the same one we talked about this morning
14:44
where Cloud Code will run this command
14:46
and it's just a slash command
14:47
It'll run and it'll label the issues so
14:49
humans don't have to
14:50
It just saves us a bunch of time
14:53
And of course
14:53
you can add mention files to pull them into context
14:56
and like I said before
14:58
CloudMD's in a nested directory
15:00
get pulled in when Cloud works in that
15:01
directory
15:06
So give Cloud more context
15:08
and
15:09
it's definitely worth taking the time to tune
15:11
context. You can run it through a prompt improver
15:13
consider who the context is for
15:15
if you want to pull it in every time
15:17
if you want to pull it in on demand
15:18
if you want to share it with a team
15:19
if it's a personal preference
15:21
definitely take the time to tune it
15:22
This will improve performance dramatically
15:25
if you do it right
15:30
As you get more advanced
15:32
you're gonna wanna think about this a little bit more
15:34
this kind of hierarchy of different ways to
15:35
pull in everything. So like
15:37
not just QuantumD, but also config and
15:41
kind of everything about quad you can pull
15:43
in in this hierarchical way
15:45
So projects, are specific to your Git repo
15:48
and this you can check in
15:49
or you can make it just for you
15:51
You can also have global configs that are
15:53
for across all your projects
15:54
or you can have enterprise policies
15:56
and this is essentially a global config that
15:58
you roll out for all of your employees
15:59
everyone on your team automatically
16:02
And this slide is like pretty information dense
16:04
but
16:05
the point is this applies to a lot
16:06
of stuff. So you can do this for slash commands
16:08
you can do it for permissions
16:10
So for example
16:10
if you have a bash command that you
16:12
would run for all your employees
16:14
like all your employees use this like test command
16:16
for example
16:17
you can actually just check it into this enterprise policies file
16:21
and then any employee
16:22
when they run this command
16:23
it will be auto-approved
16:24
which is pretty convenient
16:26
And you can also use this to block
16:27
commands. So for example
16:28
let's say there's a URL that should never be fetched
16:31
just add it to this config
16:32
and that'll make it so an employee cannot override it
16:35
and that, that URL can never be fetched
16:38
So pretty convenient both to unblock people and
16:40
also just to keep your code base safe
16:43
And then same thing for MCP servers
16:45
Have a MCP JSON file
16:46
check it into the code base
16:47
That way
16:47
any time someone runs quad code in your code base
16:50
they'll be prompted to install the MCP servers
16:52
and share it with the team
16:58
If you're not sure which of these to use
16:59
this is like a kind of an insane matrix
17:01
because we support a lot of stuff
17:03
and engineer workflows are very flexible
17:04
and every company is different
17:06
so we kind of want to support everything
17:07
So if you're not sure how to get started
17:09
I would recommend start with shared project context
17:12
You write this once
17:13
and then you share it with everyone on the team
17:15
and you get this kind of network effect where
17:16
you know, someone does a little bit of work
17:18
and everyone on the team benefits
17:23
There's a lot of tools built into Quad
17:25
to manage this
17:26
so as an example
17:27
if you run slash memory
17:28
you can see all the different memory files
17:30
that are getting pulled in
17:31
So maybe I have an enterprise policy
17:33
I have my user memory
17:35
I have project QuadMD
17:36
and then maybe there's a nested QuadMD
17:38
that's only pulled in for certain directories
17:42
And then similarly, when you do slash memory
17:44
you can edit particular memory files
17:46
when you type pound sign to remember something
17:48
you can pick which memory you want it
17:49
to go to
17:54
So yeah, that's the next step
17:55
Take the time to configure QuadMD
17:59
MCP servers, all the stuff that your team uses
18:01
so that you can use it once
18:02
configure it once
18:03
and then share it with everyone
18:07
an example of this is
18:09
in our apps repo
18:11
for Anthropic
18:11
this is like the repo that we have all of our
18:14
web and apps code in
18:16
There's a puppeteer MCP server
18:17
and we share this with the team
18:19
and there's a MCP JSON checked in
18:21
so any engineer working in that repo
18:23
can use Puppeteer
18:24
in order to pilot end-to-end tests and to
18:25
screenshot automatically and iterate
18:27
so that every engineer doesn't have to install
18:29
it themselves
18:34
This is a talk about pro tips
18:35
I
18:35
I just want to take a quick interview
18:37
to
18:37
talk about some common key bindings that people
18:39
may not know. It's a
18:40
it's very hard to build for terminal
18:42
It's also very fun
18:43
It feels like rediscovering this new design language
18:46
But something about terminals
18:47
it's, it's, it's extremely minimal
18:49
And so
18:50
sometimes it's hard to discover these key bindings
18:52
And here's just a quick reference sheet
18:54
So anytime you can hit shift tab to accept edits
18:58
and this switches you into auto accept edits
19:00
mode. So bash commands still need approval
19:02
but edits are auto accepted
19:03
And you can always ask quad to undo
19:04
them later
19:06
for example
19:07
I'll do this if I know quad's on the right track
19:09
or if it's writing unit tests and iterating on tests
19:11
I'll usually just switch into auto accept mode
19:13
so I don't have to okay every single
19:14
edit
19:17
Anytime you want Cloud to remember something
19:19
so for example
19:20
if it's not using a tool correctly
19:21
and you want it to use it correctly from then on
19:23
just type
19:24
the pound sign and then tell it what to remember
19:26
and it'll remember it. It'll incorporate it into
19:27
CloudMD automatically
19:30
If you ever want to drop down to batch mode
19:32
so just run a batch command
19:33
you can
19:34
hit the exclamation mark and type in your
19:35
command. That'll run locally
19:36
but that also goes into the context window
19:39
so
19:40
Cloud will see it on the next turn
19:42
and this is pretty good for long-running commands
19:44
if you know exactly what you want to do
19:45
or any command that you want to get into context
19:47
and Cloud will see the command and the
19:49
output
19:51
You can add mention files and folders
19:53
anytime you can hit escape to stop what
19:55
Cloud is doing
19:57
no matter what Cloud is doing
19:58
you can always safely hit escape
19:59
It's not going to corrupt the session
20:00
It's not going to mess anything up
20:02
So maybe Claude is doing a file edit
20:04
I'll hit escape, I'll tell it what to do differently
20:06
or maybe it suggested a 20-line edit
20:08
and I'm like, actually, 19 of these lines look perfect
20:10
but one line you should change
20:12
I'll hit escape, I'll tell it that
20:13
and then I'll tell it to redo the
20:14
edit
20:17
you can hit escape twice to jump back in history
20:20
and then after you're done with the session
20:22
you can start Claude with a resume to
20:23
resume that session if you want
20:25
or dash dash continue
20:28
And then anytime if you want to see more output
20:30
hit control R, and that'll show you the entire output
20:33
the same thing that Claude sees in its
20:35
context window
20:42
The next thing I want to talk about
20:43
is the Cloud Code SDK
20:44
So we talked about this at the top
20:46
right after this, Sid is doing a session
20:48
I think just across the hallway
20:50
and he's going to go super deep on
20:51
the SDK
20:52
If you hadn't played around with this
20:54
if you used the dash P flag in Cloud
20:57
this is what the SDK is
20:58
And we've been waiting a bunch of features
21:00
over the last few weeks to make it even
21:01
even better
21:03
so yeah, you can
21:04
you can build on top of this
21:05
You can do cool stuff
21:06
This is exactly the thing that Cloud Code
21:07
uses. It's exactly the same SDK
21:11
And so, for example
21:12
something you can do is cloud dash P
21:13
so this is the
21:14
the CLI SDK. You can pass a
21:16
you can pass a prompt
21:18
you can pass some allowed tools
21:19
which could include specific batch commands
21:22
and you can tell it which format you
21:23
want. So you might want JSON
21:25
or you might want streaming JSON
21:27
if you want to process this somehow
21:29
So this is awesome for
21:30
for building on. We use this in CI
21:32
all the time
21:33
We use this for incident response
21:35
We use this in all sorts of pipelines
21:37
So
21:37
really convenient. Just think of it as like
21:38
a Unix utility. You give it a prompt
21:40
it gives you JSON
21:41
You can use this in any way
21:42
You can pipe into it
21:43
you can pipe out of it
21:48
The piping is also pretty cool
21:50
So you can use like
21:51
for example, git status and pipe this in and
21:54
you know, use jq to select the result
21:57
The combinations are endless. And it's sort of
21:59
this new idea. It's like a super intelligent
22:01
Unix utility
22:02
And I think we've barely scratched the surface
22:03
of how to use this
22:04
We're just figuring this out
22:07
You can read from like a GCP bucket
22:09
read, you know
22:09
like a giant log and pipe it in
22:11
and tell Claude to figure out what's interesting
22:13
about this log
22:14
you can fetch data from like the sentry
22:17
CLI
22:18
You can also pipe it in and have
22:19
Claude do something with it
22:26
The final thing
22:27
and this is probably like the most advanced
22:29
use cases we see
22:30
I'm sort of a quad normie
22:31
so I'll have usually like one quad running at a time
22:34
and
22:34
maybe I'll have like a few terminal tabs
22:36
for a few different repos running at a
22:37
time
22:38
When I look at power users in and out of Anthropic
22:41
almost always they're gonna have like SSH sessions
22:44
they'll have
22:44
like tmux tunnels into their quad sessions
22:47
They're gonna have a bunch of checkouts of the same repo
22:50
so that they can run a bunch of
22:51
quads in parallel in that repo
22:53
or they're using Git work trees to have
22:54
some kind of isolation as they do this
22:56
And we're actively working on making this easier to use
22:59
but, for now, like, these
23:02
these are some ideas for how to do
23:03
more work in parallel with quad
23:05
You can run as many sessions as you want
23:08
and there's a lot that you can get
23:09
done in parallel
23:13
So, yeah
23:14
that's it. I wanted to
23:15
also leave some time for Q&A
23:17
So I think this is the last slide
23:18
that I have
23:20
And yeah, if folks have questions
23:21
there's mics on both sides
23:24
And yeah, would love to answer any questions
23:42
I did
23:49
Hey, Boris
23:50
thanks for building at CloudCode
23:51
And I was wondering
23:52
what was the hardest implementation
23:54
like part of the implementation for you
23:57
of building it?
23:59
I think there's a lot of tricky parts
24:03
I think one
24:04
part that is especially tricky
24:06
is the things that we do to make
24:08
batch commands safe
24:10
batch is inherently pretty dangerous
24:11
and it can change system state in unexpected
24:13
ways
24:14
But at the same time
24:15
if
24:17
You
24:17
have to manually approve every single batch command
24:20
It's super annoying as an engineer
24:22
and you can't really be productive because you're
24:23
just constantly approving every command
24:25
And just kind of navigating how to do
24:27
this safely in a way that
24:28
that scales across the different kinds of code bases people have
24:31
because not everyone runs their code in a Docker container
24:34
was, was pretty tricky
24:36
And essentially the thing we landed on is
24:37
there's some commands that are read-only
24:39
there's some static analysis that we do
24:41
in order to figure out which commands can
24:42
be combined in safe ways
24:44
and then we have this pretty complex
24:46
tiered permission system
24:48
so that you can allow list and block
24:49
list commands at different levels
24:53
Hi, Boris
24:54
You mentioned, giving an image to Cloud Code
24:57
which
24:58
made me wonder if there's some sort of
24:59
multimodal functionality that I'm not aware of
25:02
Is that
25:02
are you just pointing it at an image
25:04
on the file system or something?
25:05
Yeah, so Cloud Code is fully multimodal
25:08
it has been from the start
25:09
it's in a terminal
25:10
so it's a little
25:11
hard to discover
25:12
but yeah
25:13
you can take an image and just drag
25:14
and drop it in. That'll work
25:16
you can give it a file path
25:17
That'll work
25:18
you can copy and paste the image in
25:20
and that works too
25:23
so I'll use this pretty often for
25:25
if I have like a mock of something
25:26
I'll just drag and drop
25:27
drop in the mock
25:28
I'll tell it to implement it
25:29
I'll give it a Puppeteer server so it
25:30
can iterate against it
25:32
And yeah, it's just fully automated
25:37
hey
25:38
why did you build a
25:39
CLI tool instead of an IDE?
25:41
Yeah, it's a, it's a good question
25:44
I think there's probably two reasons
25:45
One is, we started this at Anthropic
25:49
and at Anthropic people use a broad range of IDEs
25:51
and some people use VS Code
25:53
other people use Z or Xcode or Vim or Emacs
25:58
and it was just hard to build something
25:59
that works for everyone
26:00
and so Terminal is just the common denominator
26:03
The second thing is at Anthropic
26:05
we're
26:07
we see up close how fast the model
26:09
is getting better
26:11
And so I think there's a good chance
26:12
that by the end of the year
26:13
people aren't using IDEs anymore
26:16
And so we want to get ready for this future
26:17
and we want to avoid over-investing in UI
26:19
and other layers on top
26:21
given that the, the way the models are progressing
26:24
it just
26:24
it may not be useful work pretty soon
26:26
Yeah
26:32
How much have you
26:33
Oh, this is... Is this on?
26:35
How much have you used Cloud Code for
26:37
machine learning modeling and almost that auto-ML experience?
26:40
I was curious
26:42
what the experience has been so far with that
26:44
Yeah, I think, I think the question was
26:46
how much are we using Cloud Code for machine learning and
26:49
and modeling?
26:50
We actually use it for this event
26:51
so
26:52
both engineers and researchers at Anthropic use Cloud
26:55
Code every day
26:56
I think about eighty percent of
26:58
people at Anthropic that are technical use Cloud
27:00
Code every day
27:01
And hopefully you can see that in the
27:03
product and kind of the amount of love
27:04
and dogfooding we've put into it
27:06
but this includes researchers who use tools like the notebook
27:09
notebook tool to edit and run notebooks
27:12
Okay, very cool. Thank you
27:14
All right, I think
27:36
that's it
27:49
Thanks

Watch these videos on your TV

XTTV brings video content from X to your living room. Download now and start watching on the big screen.