β Back to videos
π¨ BREAKING NEWS! The engineer who created Claude Code from scratch just posted a 28-minute video

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.