00:30Thank you

01:00Thank you

01:30Thank you

01:58Thank you

02:26Hello

02:36Hey, everyone

02:46I'm Boris

02:56I'm a member of technical staff here at Anthropic, and I created Claude Code, and I'm here to talk to you a little bit about some practical tips and tricks for using Claude Code

03:01It's going to be very practical

03:06I'm not going to go too much into the history or the theory or anything like this

03:12And, yeah, before we start, actually, can we get a quick show of hands, who has used Claude Code before? Yeah

03:15All right

03:19That's what we like to see

03:23For everyone that didn't raise your hand, I know you're not supposed to do this while people are Talking, but if you can open your laptop and type this, and this will help you install Quad Code, just so you can follow along for the rest of the talk

03:36All you need is Node.js, if you have it

03:45This should work

03:54You don't have to follow along, but if you don't have it yet, this is your chance to install it so you can follow along

04:00So what is Quadcode? Quadcode is a new kind of AI assistant

04:05There's been different generations of AI assistance for coding

04:10Most of them have been about completing a line at a time, completing a few lines of code at a time

04:16Quad Code is not for that

04:21It's fully agentic, so it's meant For building features, for writing entire functions, entire files, fixing entire bugs at the same time

04:27And what's kind of cool about Claude Code is it works with all of your tools, and you don't have to change out your workflow

04:33You don't have to swap everything to start using it

04:36So whatever IDE you use, if you use VS Code, or if you use Xcode, or if you use JetBrains IDEs, there's some people at Anthropic that you can't pry them from their cold dead hands, but they use Claude Code because Claude Code works with every single IDE, every terminal out there

04:51It will work locally, over remote SSH, over Tmux, whatever

05:05environment you're in, you can run it

05:20It's general purpose, and this is something where if you haven't used these kind of free coding assistants in the past, it can be kind of hard to figure out how to get started, because you open it up and you just see a prompt bar, and you might wonder, like, what do I do with this? What do I type in? It's a power tool, so you can use it for a lot of things, but also because it can do so much, we don't try to guide you towards a particular workflow, because really, you should be able to use it however you want as an engineer

05:34As you open up quad code for the first time, there's a few things that we recommend doing to get your environment set up, and these are pretty straightforward

05:39So run terminal setup

05:43This will give you shift enter for new lines, so you don't have to do like backslashes to enter new lines

05:47This is, you know, it makes it a little bit nicer to use

05:51Do slash theme to set light mode or dark mode or daltonize themes

05:54You can do slash install GitHub app

05:57Today, we announced a GitHub app where you can add mention Claude on any GitHub issue or pull request

06:03To install it, just run this command in your terminal

06:09You can customize the set of allowed tools that you can use, so you're not Prompted for it every time

06:12This is pretty convenient

06:15For stuff that I'm prompted about a bunch, I'll definitely customize it in this way so I don't have to accept it every time

06:18And something that I actually do is, for a lot of my prompts, I won't hand type them into Cloud Code

06:22If you're on Mac OS, you can go into your system settings under accessibility as dictation, and you can enable it

06:32And so something I do is, you just hit like the dictation key twice and you can just speak your prompt

06:36And it helps a lot to have specific prompts, so this is actually pretty awesome

06:42You can just talk to Cloud Code and like You would another engineer, and you don't have to type a lot of code

06:52So when you're starting out with Claude Code, it's so freeform and it can do everything

06:56What do you start with? The thing I recommend above everything else is starting with code-based Q&A, so just asking questions to your code base

07:05This is something that we teach new hires at Anthropic

07:08So on the first day in technical onboarding, you learn about Claude Code, you download it, you get it set up, and then you immediately start asking questions about the code base

07:16And in the past when you were doing technical onboarding, it's Something that taxes the team a lot

07:20You have to ask other engineers on the team questions, you have to look around the code, and this takes a while

07:23You have to figure out how to use the tools, this takes a long time

07:27With Claude Code, you can just ask Claude Code, and it explores the code base

07:31It answers these kind of questions

07:35And so, at Anthropic, onboarding used to take about two or three weeks for technical hires

07:38It's now about two or three days

07:43What's also kind of cool about Q&A is we don't do any sort of indexing

07:47So there's no remote database with your code

07:49We don't upload it anywhere

07:50Your code stays local

07:53We do not

07:56Train generative models on the code, so it's there, you control it, there are no indices or anything like this

07:58And what that means is also there's no setup

08:01So you start Clod, you download it, you start it, there's no indexing, you don't have to wait, you can just use it right away

08:08This is a technical talk, so I'm going to show some very specific prompts and very specific code samples that you can use and hopefully improve and up-level your Clod code experience

08:17So some kind of questions that you can ask is, you know, like, how is this particular piece of code used, or how do I instantiate this thing? And Cloud Code, it won't just do like a text search and try to answer this

08:27It will often go a level deeper, and it will try to find examples of how is this class instantiated, how is it used, and it will give you a much deeper answer, so something that you would get out of a wiki or documentation instead of just like command F

08:39Something that I do a lot also is ask it about Git history

08:45So for example, you know, why does this function have 15 arguments, and why are the arguments named this weird way? And this is something I bet in all of our codebases, you have some function like this or some class like this

08:57And Cloud Code can look through Git history, and it'll look to figure out how did these arguments get introduced, and who introduced them, and what was the situation, what are the issues that those commits linked to

09:06And it'll look through all this and summarize it, and you don't have to tell it that in all this detail, you just ask it

09:12So just say, look through Git history, and it'll know to do this

09:16The reason it knows, by the way, is not because we prompted it to

09:18There's nothing in the system prompt about looking through Git history

09:21It knows it because the model is awesome, and if you tell it to use Git, it'll

09:23Know how to use Git, so we're lucky to be building on such a good model

09:30I often ask about GitHub issues, so it can use WebFetch, and it can fetch issues and look up context on issues too, and this is pretty awesome

09:41And this is something that I do every single Monday in our weekly stand up is I ask, what did I ship this week? And Claude Code looks at the log, it knows my username, and it'll just give me a nice read out of everything I shipped, and I'll just copy and paste that into a doc somewhere

09:58So yeah, that's tip number one

10:00One, for people that have not used Cloud Code before, if you're just showing it to someone

10:02For the first time onboarding your team, the thing we definitely recommend is start with code-based Q&A

10:08Don't start by using fancy tools, don't start by editing code, just start by asking questions about the code base, and that'll teach people how to prompt

10:15And it'll start teaching them this boundary of like, what can Claude Code do, what is it capable of, versus what do you need to hold its hand with a little bit more? What can be one-shotted, what can be two-shotted, three-shotted, what do you need to use interactive mode for in a REPL? Once you're pretty comfortable with Q&A, you can dive into

10:31editing code

10:34This is the next thing, and the cool thing about any sort of agentic, like using an LM in an agentic way, is you give it tools, and it's just magical

10:44It figures out how to use the tools

10:46And with Cloud Code, we give it a pretty small set of tools

10:48It's not a lot, and so it has a tool to edit files, it has a tool to run bash commands, it has a tool to search files, and it'll string these together to explore the code, brainstorm, and then finally make edits

11:02And you don't have to prompt it specifically to use this tool and this tool and this tool

11:06You just say, do this thing, and it'll figure out how to do

11:10It'll string it together in the right way that makes sense for Claude Code

11:15There's a lot of ways to use this

11:16Something I like to do sometimes is, before having Claude jump in to write code, I'll ask it to brainstorm a little bit or make a plan

11:25This is something we highly recommend, and something I see sometimes is people, you know, they take Claude Code and they ask it, "Hey, implement this enormous, like, 3,000-line feature." And sometimes it gets this right on the first shot, but sometimes what happens is the thing that it builds is not at all the thing that you wanted, and the easiest way to get the result you want is ask it to think first, so brainstorm ideas, make a plan, run it by me, ask for approval before you write code, and you don't have to use plan mode

11:52You don't have to use any special tools to do this

11:54All you have to do is ask Cloud GitHub, and it will know to do this, so just say, before you write code, make a plan

11:55That's it

12:02This is also, I want to think with this one, this commit push PR, this is a really common incantation that I use

12:06There's nothing special about it, but Quad is kind of smart enough to interpret this, so it will make a commit, push it to the branch, make a branch, and make a pull

12:10Request from GitHub

12:14You don't have to explain anything

12:17It will look through the code, the history, the Git log by itself to figure out the commit format and all the stuff, and it'll make the commit and push it the right way

12:23Again, we're not system prompting it to do this, it just knows how to do this

12:28The model is good

12:33As you get a little bit more advanced, you're going to want to start to plug in your team tools

12:39This is where Claude Code starts to really shine

12:41There's generally two kinds of tools

12:43One is bash tools

12:44An example of this I just made up, this like barley CLI

12:47This isn't a real thing, but you can say, use this CLI to

12:48Do something

12:51You can tell Cloud Code about this

12:53You can tell it to use, for example, like dash dash help to figure out how to use it, and this is efficient

12:58If you find yourself using it a lot, you can also dump this into your CloudMD, which we'll talk about in a bit, so Cloud can remember this across sessions

13:05But this is a common pattern we follow at Anthropic, and we see external customers use too

13:11And same thing with MCP

13:12Cloud Code can use bash tools, it can use MCP tools, so just tell it about the tools, and you can add the MCP tool, and you can tell it how to use it, and it'll just start using it, and this is

13:23Extremely powerful because when you start to use code on a new code base, you can just give it all of your tools, all the tools your team already uses for this code base, and Claude Code can use it on your behalf

13:40There's a few common workflows, and this is the one that I talked about already, so kind of do a little bit of exploration, do a little bit of planning, and ask me for confirmation before you start to write code

13:52These other two on the right are extremely powerful

13:55When Claude has some way to check its work, so for example by writing unit tests or screenshotting in Puppeteer or screenshotting the iOS

14:00Simulator, then it can iterate, and this is incredible because if you give it, for example, a mock and you say build this web UI, it will get it pretty good, but if you had to iterate two or three times, often it gets it almost perfect

14:16So the trick is, give it some sort of tool that it can use for feedback to check its work, and then based on that, it will iterate by itself, and you're going to get a much better result

14:25So whatever your domain is, if it's unit test or integration test or screenshots for apps or web or anything, just give it away to see its result, and it'll iterate and get better

14:38So these are the Next steps: teach Claude how to use your tools and figure out the right workflow

14:43If you want Claude to jump in and code, if you want it to brainstorm a little bit, make a plan, if you want it to iterate, kind of have some sense of that so you know how to prompt Claude to do what you want

14:55As you go deeper beyond tools, you want to start to give Claude more context, and the more context, the smarter the decisions will be, because as an engineer working in a code base, you have a ton of context in your head about your systems and all the history and everything else

15:09So there's different ways to give this to Claude, and as you give Claude, more context, it'll do better

15:15There's different ways to do this

15:17The simplest one is what we call ClaudeMD, and Claude.md is the special file name

15:22The simplest place to put it is in the project root, so the same directory you start Quad in, put a QuadMD in there, and that will get automatically read into context at the start of every session

15:32And essentially, the first user turn will include the QuadMD

15:35You can also have a local QuadMD, and this one you don't usually check into source control

15:43So QuadMD you should check into source control, share with your team, so that you can write it once and Share it with your team

15:48This one you don't check in

15:51It's just for you

15:52The kinds of things you put in QuadMD, it's like common bash commands, common MCP tools, architectural decisions, important files, anything that you would kind of typically need to know in order to work in this codebase

16:03Try to keep it pretty short, because if it gets too long, it's just going to use up a bunch of context, and it's usually not that useful, so just try to keep it as short as you can

16:11And for example, in our codebase, we have common bash commands, we have a style guide, we have a few core files, kind of things like that

16:21All The other quantum DS, you can put them in other nested child directories and Quad will pull them in on-demand

16:28So these are the Quad MDs that will get pulled in automatically, but then also you can put in, put quantum DS in nested directories and those will get put, those will get automatically pulled when Quad works in those directories

16:41And of course, if you're, you know, a company, maybe you want a Quad MD that's shared across all the different code bases and you want to manage it on behalf of your users, and you can put it in your enterprise root and that'll get pulled in automatically

16:48There's a ton of ways to pull

16:55In context, I actually had a lot of trouble putting this fight together, just to communicate the breadth of ways you can do this

17:02But Quad MD is pulled in automatically

17:04You can also use slash commands, so this is dot quad slash commands, and this can be in your home directory, or it can be checked into your project, and this is for slash commands

17:13And over here, we have a few examples of the slash commands that we have in Cloud Code itself

17:21And so, for example, if you're in the Cloud Code repo, and you see issues getting labeled, that actually this workflow running here, it labeled GitHub issues, and we have a GitHub

17:23Action running, the same one we talked about this morning, where Quad Code will run this command, and it's just a slash command

17:35It'll run, and it'll label the issues, so humans don't have to

17:38It just saves us a bunch of time, and of course, you can add mention files to pull them into context

17:43And like I said before, quadMDs in a nested directory get pulled in when Claude works in that directory, so give Claude more context, and it's definitely worth taking the time to tune context

18:01You can run it through a prompt improver

18:02Consider who the context is for, if you want to pull it in every time, if you want to pull it

18:06In on demand, if you want to share it with a team, if it's a personal preference, definitely take the time to tune it

18:12This will improve performance dramatically if you do it right

18:19As you get more advanced, you're going to want to think about this a little bit more, this kind of hierarchy of different ways to pull in everything

18:26So like not just Claude MD, but also config and kind of everything about Claude, you can pull in in this hierarchical way

18:34So projects are specific to your Git repo, and this you can check in or you can make it just for you

18:40You can also have global configs that are across all your

18:46projects, or you can have enterprise policies, and this is essentially a global config that you roll out for all of your employees, everyone on your team automatically

18:52And this slide is like pretty information dense, but the point is this applies to a lot of stuff, so you can do this for slash commands, you can do it for permissions

18:58So for example, if you have a bash command that you would run for all your employees, like all your employees use this like test command, for example, you can actually just check it into this enterprise policies file, and then any employee when they run this command, it will be auto

19:12approved, which is pretty convenient

19:15And you can also use this to block commands

19:17So, for example, let's say there's a URL that should never be fetched, just add it to this config and that'll make it so an employee cannot override it and that URL can never be fetched

19:28So pretty convenient both to unblock people and also just to keep your code base safe

19:33And then same thing for MCP servers

19:34Have an MCP JSON file, check it into the code base

19:37That way any time someone runs Cloud Code in your code base, they'll be prompted to install the MCP servers and share it with the team

19:48If you're not sure which of these to Use, this is like kind of an insane matrix because we support a lot of stuff, and engineer workflows are very flexible, and every company is different, so we kind of want to support everything

19:57So if you're not sure how to get started, I would recommend start with shared project context

20:02You write this once, and then you share it with everyone on the team, and you get this kind of network effect where someone does a little bit of work and everyone on the team benefits

20:13There's a lot of tools built into quad to manage this

20:16So as an example, if you run slash memory, you can see all the different memory files that are getting pulled in

20:21So maybe I have an enterprise policy, I have my user memory, I have project Quad MD, and then maybe there's a nested Quad MD that's only pulled in for certain directories

20:32And then similarly, when you do slash memory, you can edit particular memory files

20:36When you type pound sign to remember something, you can pick which memory you want it to go to

20:44So yeah, that's the next step

20:45Take the time to configure QuadMD, MCP servers, all the stuff that your team uses, so that you can use it once, configure it once, and then share it with everyone

20:52An example of this is in our apps repo for

20:59Anthropic, this is the repo that we have all of our web and apps code in

21:06There's a Puppeteer MCP server, and we share this with the team, and there's an MCP JSON checked in, so any engineer working that repo can use Puppeteer in order to pilot end-to-end tests and to screenshot automatically and iterate so that every engineer doesn't have to install it themselves

21:24This is a talk about pro tips, so I just want to take a quick interview to talk about some common key bindings that people may not know

21:30It's very hard to build for terminal, it's also very fun

21:34It feels like rediscovering this new design

21:38language, but something about terminals, it's extremely minimal, and so sometimes it's hard to discover these key bindings

21:42And here's just a quick reference sheet, so anytime you can hit shift tab to accept edits, and this switches you into auto accept edits mode

21:49So bash commands still need approval, but edits are auto accepted, and you can always ask Quad to undo them later

21:56For example, I'll do this if I know Quad's on the right track, or if it's writing unit tests and iterating on tests, I'll usually just switch into auto accept mode so I don't have to OK every single edit

22:07Any time you want Quad to Remember something, so for example, if it's not using a tool correctly and you want it to use it correctly from then on, just type the pound sign and then tell it what to remember, and it'll remember it

22:16It'll incorporate it into QuadMD automatically

22:20If you ever want to drop down to Bash mode, so just run a Bash command, you can hit the exclamation mark and type in your command

22:26That'll run locally, but that also goes into the context window, so Claude will see it on the next turn

22:31And this is pretty good for long running commands if you know exactly what you want to do, or any command that you want to get into context

22:34And Claude will see the command and the output

22:37You can add mention files and folders

22:40Any time you can hit escape to stop what Claude is doing

22:43No matter what Claude is doing, you can always safely hit escape

22:47It's not going to corrupt the session, it's not going to mess anything up

22:50So maybe Claude is doing a file edit

22:53I'll hit escape

22:56I'll tell it what to do differently, or maybe it suggested a 20-line edit, and I'm like, actually, 19 of these lines look perfect, but one line you should change

22:59I'll hit escape, I'll tell it that, and then I'll tell it to redo that edit

23:02You can hit escape twice to jump back in

23:08History, and then after you're done with the session, you can start Claude with a resume to resume that session if you want, or dash dash continue

23:13And then any time if you want to see more output, hit control R, and that will show you the entire output, the same thing that Claude sees in its context window

23:23The next thing I want to talk about is the Claude Code SDK

23:28So we talked about this at the top

23:33Right after this, Sid is doing a session, I think just across the hallway, and he's going to go super deep on the SDK

23:37If you hadn't played around with this, if you use the dash P flag in Claude, this is what the SDK is

23:47And we've been landing a bunch of features over the last few weeks to make it even better

23:50So yeah, you can build on top of this, you can do cool stuff

23:53This is exactly the thing that Claude Code uses, it's exactly the same SDK

23:56And so, for example, something you can do is Claude-P

24:01So this is the CLI SDK

24:07You can pass a prompt, you can pass some allowed tools, which could include specific bash commands, and you can tell it which format you want

24:12So you might want JSON, or you might want streaming JSON if you want to process this somehow

24:15So this is awesome for building on

24:19We use this in CI all the time

24:21We use this

24:24For incident response, we use this in all sorts of pipelines, so really convenient

24:26Just think of it as like a Unix utility

24:28You give it a prompt, it gives you JSON

24:33You can use this in any way

24:38You can pipe into it, you can pipe out of it

24:43The piping is also pretty cool, so you can use, like, for example, git status and pipe this and use jq to select the result, the combinations are endless

24:47And it's sort of this new idea

24:49It's like a super intelligent Unix utility, and I think we barely scratched the surface of how to use this

24:52We're just figuring this out

24:55You can read from a GCP bucket, read a giant log, and pipe it in

24:59And tell Claude to figure out what's interesting about this log

25:02You can fetch data from the Sentry CLI

25:06You can also pipe it in and have Claude do something with it

25:16The final thing, and this is probably the most advanced use case we see, I'm sort of a Claude normie, so I'll have usually one Claude running at a time, and maybe I'll have a few terminal tabs for a few different repos running at a time

25:24When I look at power users in and out of Anthropic, almost always they're going to have SSH sessions, they'll have Tmux tunnels into their quad sessions

25:35They're going to have a bunch of checkouts of the same repo, so They can run a bunch of quads in parallel in that repo, or they're using Git work trees to have some kind of isolation as they do this

25:43We're actively working on making this easier to use, but for now, these are some ideas for how to do more work in parallel with quad

25:55You can run as many sessions as you want, and there's a lot that you can get done in parallel

26:03So yeah, that's it

26:04I wanted to also leave some time for Q&A, so I think this is the last slide that I have

26:09And yeah, if folks have questions, there's mics on both sides, and yeah, we'd love to answer any questions

26:23I did

26:33Hey, Boris, thanks for building a Cloud Code

26:43And I was wondering, what was the hardest implementation, like part of the implementation for you of building it? I think there's a lot of tricky parts

26:53I think one part that is especially tricky is the things that we do to make bash commands safe

27:00Bash is inherently pretty dangerous, and it can change system state in unexpected ways

27:04But at the same time, if you have to manually approve every single bash command, it's super annoying as an engineer

27:11And you can't really be productive because you're just constantly approving every command, and just kind of navigating how to do this safely

27:17In a way that scales across the different kinds of code bases people have, because not everyone runs their code in a Docker container, was pretty tricky

27:24And essentially, the thing we landed on is, there are some commands that are read, there's some static analysis that we do in order to figure out which commands can be combined in safe ways, and then we have this pretty complex tiered permission system so that you can allow list and block list commands at different levels

27:33Hi, Boris

27:41You mentioned giving an image to Cloud Code, which made me wonder if there's some sort of multimodal functionality that I'm not aware of

27:50Are you just pointing it at an image on the file system or something? Yeah, so Claude Code is fully multimodal

27:57It has been from the start

27:59It's in a terminal, so it's a little hard to discover, but yeah, you can take an image and just drag and drop it in

28:04That'll work

28:05You can give it a file path

28:07That'll work

28:08You can copy and paste the image in, and that works too

28:13So I'll use this pretty often for if I have a mock of something

28:16I'll just drag and drop in the mock

28:17I'll tell it to implement it

28:19I'll give it a tier server so it can iterate against it, and yeah, it's just fully automated

28:27Hey, why did you Build a CLI tool instead of an IDE? Yeah, it's a good question

28:33I think there's probably two reasons

28:35One is, we started this at Anthropic, and at Anthropic, people use a broad range of IDEs, and some people use VS Code, other people use Zed or Xcode or Vim or Emacs, and it was just hard to build something that works for everyone, and so terminal is just the common denominator

28:53The second thing is, at Anthropic, we see up close how fast the model is getting better, and so I think there's a good chance that by the end of the year, people aren't using IDEs anymore, and so we want to get ready for this future, and we

29:07Want to avoid over-investing in UI and other layers on top, given that the way the models are progressing, it may not be useful work pretty soon

29:20Yeah, how much of you, I don't know if this is, is this on, how much you use code for machine learning modeling and almost that AutoML experience

29:24I was curious what the experience has been so far with that

29:33Yeah, I think, I think the question was, how much are we using quad code for machine learning and modeling? We actually use it for this a bunch

29:39So both engineers and researchers at Anthropic use quad code every day

29:45I think about 80% of people at Anthropic that are Technical use quadcode every day, and hopefully you can see that in the product and kind of the amount of love and dogfooding we've put into it

29:54But this includes researchers who use tools like the notebook tool to edit and run notebooks

30:01Okay, very cool, thank you

30:05All right, I think that's it

30:07Thanks, thanks, thanks.