back to index

Mastering Claude Code in 30 minutes


Whisper Transcript | Transcript Only Page

00:00:00.000 | - Hello, everyone, I'm Boris, I'm a member of technical staff here at Anthropic, and I
00:00:23.920 | created QuadCode, and here to talk to you a little bit about some practical tips and
00:00:28.420 | tricks for using QuadCode. It's going to be very practical, I'm not going to go too much into
00:00:33.380 | the history or the theory or anything like this. And yeah, before we start, actually, can
00:00:39.320 | we get a quick show of hands, who has used QuadCode before? Yeah, all right, that's what
00:00:45.040 | we like to see. For everyone that didn't raise your hands, I know you're not supposed to do
00:00:49.400 | this while people are talking, but if you can open your laptop and type this, and this will
00:00:56.840 | help you install QuadCode just so you can follow along for the rest of the talk. All you need
00:01:07.520 | is Node.js if you have it, this should work.
00:01:11.800 | Do you want us all to open the QuadCode? Yeah, well, you don't have to follow along, but if
00:01:18.760 | you don't have it yet, yeah, this is your chance to install it so you can follow along.
00:01:25.940 | So what is QuadCode? QuadCode is a new kind of AI assistant, and there's been different generations
00:01:32.280 | of AI assistants for coding. Most of them have been about completing, you know, like a line
00:01:37.040 | at a time, completing a few lines of code at a time. QuadCode is not for that, it's fully
00:01:42.280 | agentic. So it's meant for building features, for writing entire functions, entire files,
00:01:48.720 | fixing entire bugs at the same time. And what's kind of cool about QuadCode is it works with
00:01:54.800 | all of your tools, and you don't have to change out your workflow, you don't have to swap everything
00:01:59.040 | to start using it. So whatever IDE you use, if you use VS code, or if you use Xcode, or if
00:02:05.520 | you use JetBrains IDEs, there's some people at Anthropic that you can't pry them from their
00:02:10.960 | cold, dead hands, but they use QuadCode. Because QuadCode works with every single IDE, every terminal
00:02:16.160 | out there. It will work locally, over remote SSH, over Tmux, whatever environment you're in,
00:02:23.040 | you can run it. It's general purpose, and this is something where if you haven't used these kind of
00:02:30.880 | free-form coding assistants in the past, it can be kind of hard to figure out how to get started,
00:02:35.840 | because you open it up, and you just see a prompt bar, and you might wonder, like, what do I do with
00:02:39.600 | 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
00:02:45.200 | can do so much, we don't try to guide you towards a particular workflow. Because really, you should be able
00:02:49.440 | to use it however you want as an engineer. As you open up QuadCode for the first time, there's a few
00:02:58.960 | things that we recommend doing to get your environment set up, and these are pretty straightforward. So,
00:03:04.320 | run Terminal Setup, this will give you Shift+Enter for new lines, so you don't have to do, like,
00:03:08.320 | backslashes to enter new lines. This is, you know, it makes it a little bit nicer to use.
00:03:13.040 | Do /theme to set light mode, or dark mode, or Daltonize themes. You can do /install GitHub app. So,
00:03:20.880 | today, we announced a GitHub app where you can add, mention, Claude on any GitHub issue or pull request.
00:03:28.800 | So, to install it, just run this command in your terminal. You can customize the set of allowed tools
00:03:35.360 | that you can use, so you're not prompted for it every time. This is pretty convenient. For stuff that I'm
00:03:39.040 | prompted about a bunch, I'll definitely customize it in this way, so I don't have to accept it every
00:03:43.200 | time. And something that I actually do is, for a lot of my prompts, I won't hand-type them into QuadCode.
00:03:48.800 | If you're on macOS, you can go into your system settings under accessibility as dictation,
00:03:54.160 | and you can enable it. And so, something I do is you just hit, like, that dictation key twice,
00:03:59.040 | and you can just speak your prompt. And it helps a lot to have specific prompts. So, this is actually
00:04:04.240 | pretty awesome. You can just talk to QuadCode, like you would another engineer, and you don't have to
00:04:08.880 | type a lot of code. So, when you're starting out with QuadCode, it's so freeform, and it can do
00:04:17.520 | everything. What do you start with? The thing I recommend above everything else is starting with
00:04:21.920 | CodeBase Q&A. So, just asking questions to your CodeBase. This is something that we teach new hires at
00:04:28.560 | Anthropic. So, on the first day, in technical onboarding, you learn about QuadCode, you download
00:04:33.200 | it, you get it set up, and then you immediately start asking questions about the CodeBase. And in the
00:04:38.480 | past, when you were doing technical onboarding, it's something that taxes the team a lot, right? You have
00:04:42.720 | to ask other engineers on the team questions. You have to look around the code, and this takes a while. You
00:04:47.600 | have to figure out how to use the tools. This takes a long time. With QuadCode, you can just ask QuadCode,
00:04:53.600 | and it'll explore the code base. It'll answer these kind of questions. And so, at Anthropic,
00:04:57.840 | onboarding used to take about two or three weeks for technical hires. It's now about two or three days.
00:05:01.680 | What's also kind of cool about Q&A is we don't do any sort of indexing. So, there's no remote
00:05:10.000 | database with your code. We don't upload it anywhere. Your code stays vocal. We do not train generative
00:05:14.880 | models on the code. So, it's there. You control it. There's no indices or anything like this.
00:05:20.640 | And what that means is also there's no setup. So, you start Quad, you download it. You start it.
00:05:25.120 | There's no indexing. You don't have to wait. You can just use it right away.
00:05:27.440 | This is a technical talk. So, I'm going to show some very specific prompts and very specific code
00:05:34.720 | samples that you can use and hopefully improve and up-level your QuadCode experience.
00:05:38.640 | So, some kind of questions that you can ask is, you know, like, how is this particular piece of code
00:05:44.160 | used? Or, how do I instantiate this thing? And the QuadCode, it won't just do like a text search and try to answer
00:05:48.560 | this. It'll often go a level deeper and it'll try to find examples of how is this class instantiated.
00:05:54.000 | How is it used? And it'll give you a much deeper answer. So, something that you would get out of a
00:05:58.560 | wiki or documentation instead of just like command F. Something that I do a lot also is ask it about
00:06:05.920 | git history. So, for example, you know, why does this function have 15 arguments? And why are the
00:06:11.280 | arguments named this weird way? And this is something I bet in all of our code bases, you have some function
00:06:16.240 | like this or some class like this. And CloudCode can look through git history and it'll look to
00:06:21.760 | figure out how did these arguments get introduced and who introduced them and what was the situation?
00:06:25.680 | What are the issues that those commits linked to? And it'll look through all this and summarize it.
00:06:29.840 | And you don't have to tell it that in all these, in all this detail. You just ask it. So, just say,
00:06:34.640 | look through git history and it'll know to do this. The reason it knows, by the way, is not because we
00:06:39.840 | prompted it to. There's nothing in the system prompt about looking through git history. It knows it because the
00:06:44.160 | model is awesome. And if you tell it to use git, it'll know how to use git. So, we're lucky to be
00:06:49.520 | building on such a good model. I often ask about GitHub issues. So, you know, it can use web fetch and
00:06:57.920 | it can fetch issues and look up context on issues too. And this is pretty awesome. And this is something
00:07:03.840 | that I do every single Monday in our weekly stand up. I ask what did I ship this week? And QuadCode looks
00:07:09.600 | the log. It knows my username. And it'll just give me a nice readout of everything I shipped. And I'll
00:07:14.400 | just copy and paste that into a doc. So, yeah, that's tip number one. For people that have not
00:07:22.960 | used QuadCode before, if you're just showing it to someone for the first time, onboarding your team,
00:07:27.360 | the thing we definitely recommend is start with CodeBase Q&A. Don't start by using fancy
00:07:30.960 | tools. Don't start by editing code. Just start by asking questions about the CodeBase. And that'll teach
00:07:35.280 | people how to prompt. And it'll start teaching them this boundary of like what can CloudCode do?
00:07:40.080 | What is it capable of versus what do you need to hold its hand with a little bit more? What can be
00:07:44.320 | one-shotted? What can be two-shotted, three-shotted? What do you need to use interactive mode for in a
00:07:48.560 | REPL? Once you're pretty comfortable with Q&A, you can dive into editing code. This is the next thing.
00:07:57.680 | And the cool thing about any sort of agentic, you know, like using LLM in an agentic way is you give
00:08:04.240 | it tools and it's just like magical. It figures out how to use the tools. And with CloudCode, we give it
00:08:09.040 | a pretty small set of tools. It's not a lot. And so it has a tool to edit files. It has a tool to run
00:08:14.400 | bash commands. It has a tool to search files. And it'll string these together to explore the code,
00:08:19.440 | brainstorm, and then finally make edits. And you don't have to prompt it specifically to use this tool and
00:08:26.160 | this tool and this tool. You just say, you know, do this thing, and it'll figure out how to do it. It'll
00:08:29.600 | string it together in the right way. That makes sense for CloudCode.
00:08:32.160 | There's a lot of ways to use this. Something I like to do sometimes is before having Cloud
00:08:41.920 | jump in to write code, I'll ask it to brainstorm a little bit or make a plan. This is something we
00:08:47.680 | highly recommend. And something I see sometimes is people, you know, they take CloudCode and they ask it,
00:08:53.040 | hey, implement this enormous like 3000 line feature. And sometimes it gets this right on
00:08:57.840 | the first shot. But sometimes what happens is the thing that it builds is not at all the thing that
00:09:02.160 | you wanted. And the easiest way to get the result you want is ask it to think first. So brainstorm ideas,
00:09:08.880 | make a plan, run it by me, ask for approval before you write code. And you don't have to use plan mode,
00:09:14.640 | you don't have to use any special tools to do this. All you have to do is ask Cloud. And it'll know to do this.
00:09:19.440 | So just say, before you write code, make a plan. That's it.
00:09:22.240 | This is also, I want to think with this one, this commit push VR, this is a really common
00:09:28.400 | incantation that I use. There's nothing special about it, but Cloud is kind of smart enough to
00:09:32.080 | interpret this. So it'll make a commit, it'll push it to the branch, make a branch, and then make a pull
00:09:35.680 | request from you on GitHub. You don't have to explain anything. It'll look through the code, it'll look
00:09:39.520 | through the history, it'll look through the Git log by itself to figure out the commit format and all the stuff.
00:09:43.920 | It'll make the commit and push it the right way. Again, we're not system prompting it to do this.
00:09:50.960 | It just knows how to do this. The model is good.
00:09:52.640 | As you get a little bit more advanced, you're going to want to start to plug in your team's tools. And
00:10:00.400 | this is where Cloud Code starts to really shine. And there's generally two kinds of tools. So one is
00:10:05.120 | bash tools. And an example of this, I just made up this like Burley CLI. This isn't a real thing.
00:10:09.840 | But you can say use the CLI to do something. And you can tell Cloud Code about this. And you can tell
00:10:15.680 | it to use, for example, like dash dash help to figure out how to use it. And this is efficient. If you find
00:10:21.120 | yourself using it a lot, you can also dump this into your Cloud MD, which we'll talk about in a bit,
00:10:25.040 | so Cloud can remember this across sessions. But this is a common pattern we follow at Anthropic and we see
00:10:30.160 | external customers use too. And same thing with MCP. Cloud Code can use bash tools. It can use MCP
00:10:36.880 | tools. So, you know, just tell it about the tools. And you can add the MCP tool and you can tell it how
00:10:41.520 | to use it. And it'll just start using it. And this is extremely powerful because when you start to use
00:10:47.920 | code on a new code base, you can just give it all of your tools, all the tools your team already uses
00:10:53.360 | for this code base. And Cloud Code can use it on your behalf.
00:10:56.400 | There's a few common workflows. And this is the one that I talked about already. So kind of do a little
00:11:07.680 | bit of exploration, do a little bit of planning, and ask me for confirmation before you start to write
00:11:13.040 | code. These other two on the right are extremely powerful. When Cloud has some way to check its work,
00:11:19.280 | so for example, by writing unit tests or screenshotting in Puppeteer or screenshotting the iOS
00:11:24.480 | simulator, then it can iterate. And this is incredible because if you give it, for example,
00:11:29.760 | a mock and you say build this web UI, it'll get it pretty good. But if you let it iterate two or three
00:11:35.120 | times, often it gets it almost perfect. So the trick is give it some sort of tool that it can use for
00:11:40.960 | feedback to check its work. And then based on that, it will iterate by itself and you're going to get a much
00:11:45.600 | better result. So whatever your domain is, if it's unit test or integration test or screenshots for
00:11:50.880 | apps or web or anything, just give it a way to see its result and it'll iterate and get better.
00:11:55.600 | So these are the next steps. Teach Cloud how to use your tools and figure out the right workflow. If you
00:12:05.520 | want Cloud to jump into code, if you want it to brainstorm a little bit, make a plan, if you want it to
00:12:09.440 | iterate, kind of have some sense of that so you know how to prompt Cloud to do what you want.
00:12:13.600 | As you go deeper, beyond tools, you want to start to give Cloud more context. And the more context,
00:12:22.880 | the smarter the decisions will be. Because as an engineer working in a code base, you have a ton
00:12:26.480 | of context in your head about your systems and all the history and everything else. So there's different
00:12:31.920 | ways to give this to Cloud. And as you give Cloud more context, it'll do better.
00:12:35.360 | There's different ways to do this. The simplest one is what we call Cloud.MD. And Cloud.MD is the
00:12:43.200 | special file name. The simplest place to put it is in the project root. So the same directory you start
00:12:49.120 | Cloud in, put a Cloud.MD in there. And that'll get automatically read into context at the start of
00:12:54.160 | every session. And essentially, the first user turn will include the Cloud.MD. You can also have a local
00:13:01.200 | Cloud.MD. And this one, you don't usually check into source control. So Cloud.MD, you should check into
00:13:06.880 | source control, share with your team so that you can write it once and share it with your team. This one,
00:13:12.160 | you don't check in. It's just for you. The kinds of things you put in Cloud.MD, it's like common bash commands,
00:13:18.240 | common MCP tools, architectural decisions, important files, anything that you would kind of typically
00:13:24.720 | need to know in order to work in this codebase. Try to keep it pretty short, because if it gets too long,
00:13:29.520 | 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
00:13:34.000 | short as you can. And for example, in our codebase, we have common bash commands, we have a style guide,
00:13:40.640 | we have a few core files, kind of things like that. All the other Cloud.MDs, you can put them in other
00:13:45.600 | nested child directories, and Cloud will pull them in on demand. So these are the Cloud.MDs that will
00:13:52.080 | get pulled in automatically. But then also, you can put Cloud.MDs in nested directories,
00:13:57.200 | and those will get put, those will get automatically pulled when Cloud works in those directories.
00:14:00.880 | And of course, if you're, you know, a company, maybe you want a Cloud.MD that's shared across all
00:14:07.040 | the different codebases, and you want to manage it on behalf of your users, and you can put in your
00:14:10.960 | enterprise route, and that'll get pulled in automatically.
00:14:13.360 | There's a ton of ways to pull in context. I actually had a lot of trouble putting this slide
00:14:20.800 | together just to communicate the breadth of ways you can do this. But Cloud.MD is pulled in
00:14:25.600 | automatically. You can also use slash commands. So this is .quad slash commands, and this can be in
00:14:30.480 | your home directory, or it can be checked into your project. And this is for slash commands. And over here,
00:14:37.440 | we have a few examples of the slash commands that we have in Cloud Code itself. And so, for example,
00:14:44.080 | if you're in the Cloud Code repo, and you see issues getting labeled, that's actually this workflow
00:14:48.960 | running here. It's labeled GitHub issues. And we have a GitHub action running, the same one we talked
00:14:54.080 | about this morning, where Cloud Code will run this command, and it's just a slash command. It'll run,
00:14:59.680 | and it'll label the issues so humans don't have to. It just saves us a bunch of time. And of course,
00:15:05.120 | you can add mention files to pull them into context. And like I said before, Quad.MDs in a nested
00:15:10.960 | directory get pulled in when Quad works in that directory.
00:15:13.280 | So give Quad more context, and it's definitely worth taking the time to tune context. You can run it
00:15:23.280 | through a prompt improver. Consider who the context is for. If you want to pull it in every time, if you
00:15:28.720 | want to pull it in on demand, if you want to share it with a team, if it's a personal preference,
00:15:32.880 | definitely take the time to tune it. This will improve performance dramatically, if you do it right.
00:15:37.120 | As you get more advanced, you're going to want to think about this a little bit more, this kind of
00:15:46.080 | hierarchy of different ways to pull in everything. So like not just Quad.MD, but also config and
00:15:51.840 | kind of everything about Quad you can pull in in this hierarchical way. So projects are specific to your Git repo,
00:15:59.840 | and this you can check in, or you can make it just for you. You can also have global configs that are
00:16:04.640 | across all your projects, or you can have enterprise policies. And this is essentially a global config
00:16:09.280 | that you roll out for all of your employees, everyone on your team automatically.
00:16:14.240 | And this slide is like pretty information dense, but the point is this applies to a lot of stuff. So you
00:16:19.040 | can do this for slash commands, you can do it for permissions. So for example, if you have a bash command
00:16:23.520 | that you would run for all your employees, like all your employees use this like test command, for example,
00:16:28.240 | you can actually just check it into this enterprise policies file. And then any employee, when they run
00:16:34.320 | this command, it will be auto approved, which is pretty convenient. And you can also use this to block
00:16:38.720 | commands. So for example, let's say there's a URL that should never be fetched. Just add it to this
00:16:43.280 | config, and that will make it so an employee cannot override it. And that URL can never be fetched. So
00:16:49.920 | pretty convenient both to unblock people and also just to keep your code base safe. And then same thing for
00:16:55.520 | MCP servers, have a MCP JSON file, check it into the code base. That way, anytime someone runs quad
00:17:01.280 | code in your code base, they'll be prompted to install the MCP servers and share it with the team.
00:17:05.120 | If you're not sure which of these to use, this is like a kind of an insane matrix because we support a
00:17:13.920 | lot of stuff and engineer workflows are very flexible and every company is different. So we kind of want to
00:17:18.000 | support everything. So if you're not sure how to get started, I would recommend start with shared
00:17:22.080 | project context. You write this once and then you share it with everyone on the team, and you get
00:17:26.800 | this kind of network effect where someone does a little bit of work and everyone on the team benefits.
00:17:30.800 | There's a lot of tools built into Quad to manage this. So as an example, if you run slash memory,
00:17:40.080 | you can see all the different memory files that are getting pulled in. So maybe I have an enterprise
00:17:44.240 | policy, I have my user memory, I have project Quad MD, and then maybe there's a nested Quad MD that's only
00:17:50.400 | pulled in for certain directories. And then similarly, when you do slash memory, you can edit particular
00:17:56.880 | memory files. When you type pound sign to remember something, you can pick which memory you wanted to go to.
00:18:01.120 | So yeah, that's the next step. Take the time to configure Quad MD, MCP servers, all the stuff that
00:18:12.240 | your team uses so that you can use it once, configure it once, and then share it with everyone.
00:18:19.120 | An example of this is in our apps repo for Anthropic. This is like the repo that we have all of our
00:18:25.600 | web and apps code in. There's a Puppeteer MCP server, and we share this with the team.
00:18:30.240 | And there's an MCP JSON checked in, so any engineer working in that repo can use Puppeteer in order to
00:18:35.600 | pilot end-to-end tests and to screenshot automatically and iterate so that every engineer doesn't have to
00:18:39.600 | install it themselves. This is a talk about pro tips. I just want to take a quick interlude to talk about
00:18:49.280 | some common key bindings that people may not know. It's very hard to build for terminal. It's also very
00:18:54.080 | fun. It feels like rediscovering this new design language. But something about terminals, it's extremely
00:19:00.080 | minimal. And so sometimes it's hard to discover these key bindings. And here's just a quick reference
00:19:05.440 | sheet. So anytime, you can hit shift tab to accept edits. And this switches you into auto accept edits
00:19:11.440 | mode. So bash commands still need approval, but edits are auto accepted. And you can always ask Quad to
00:19:16.000 | undo them later. For example, I'll do this if I know Quad's on the right track or if it's writing unit tests and
00:19:21.760 | iterating on tests. I'll usually just switch into auto accept mode so I don't have to okay every single edit.
00:19:26.640 | Any time you want Cloud to remember something, so for example, if it's not using a tool correctly
00:19:33.280 | and you wanted to use it correctly from then on, just type the pound sign and then tell it what to
00:19:37.120 | remember and it'll remember it. It'll incorporate it into QuadMD automatically. If you ever want to drop
00:19:43.040 | down to bash mode, so just run a bash command, you can hit the exclamation mark and type in your command.
00:19:47.360 | That'll run locally, but that also goes into the context window. So Cloud will see it on the next turn.
00:19:53.840 | And this is pretty good for long running commands if you know exactly what you want to do or any
00:19:57.360 | command that you want to get into context. And Quad will see the command and the output.
00:20:00.880 | You can add mention files and folders. Anytime you can hit escape to stop what Quad is doing.
00:20:08.480 | No matter what Quad is doing, you can always safely hit escape. It's not going to corrupt the session.
00:20:12.240 | It's not going to mess anything up. So maybe Quad is doing a file edit. I'll hit escape. I'll tell it
00:20:16.560 | what to do differently. Or maybe it suggested a 20 line edit and I'm like, actually 19 of these lines look perfect,
00:20:22.000 | but one line you should change. I'll hit escape. I'll tell it that. And then I'll tell it to redo that.
00:20:26.240 | You can hit escape twice to jump back in history. And then after you're done with the session,
00:20:33.680 | you can start Quad with a resume to resume that session if you want. Or dash dash continue.
00:20:38.160 | And then anytime if you want to see more output, hit control R. And that'll show you the entire output,
00:20:44.800 | the same thing that Quad sees in its context window.
00:20:47.040 | The next thing I want to talk about is the Quad code SDK. So we talked about this at the top.
00:20:57.520 | Right after this, Sid is doing a session, I think, just across the hallway. And he's going to go super
00:21:02.560 | deep on the SDK. If you hadn't played around with this, if you use the dash P flag in Quad, this is what the SDK is.
00:21:10.000 | And we've been planning a bunch of features over the last few weeks to make it even better. So yeah,
00:21:15.600 | you can build on top of this. You can do cool stuff. This is exactly the thing that Quad code uses.
00:21:19.760 | It's exactly the same SDK. And so, for example, something you can do is Quad dash P. So this is
00:21:25.680 | the CLI SDK. You can pass a prompt. You can pass some allowed tools, which could include specific
00:21:32.720 | batch commands. And you can tell it which format you want. So you might want JSON or you might want
00:21:37.680 | streaming JSON if you want to process this somehow. So this is awesome for building on. We use this in
00:21:43.360 | CI all the time. We use this for incident response. We use this in all sorts of pipelines. So really
00:21:49.040 | convenient. Just think of it as like a Unix utility. You give it a prompt. It gives you JSON. You can use
00:21:53.280 | this in any way. You can pipe into it. You can pipe out of it. The piping is also pretty cool. So you can
00:22:02.240 | use, like, for example, git status and pipe this in and, you know, use JQ to select the result. The
00:22:08.720 | combinations are endless. And it's sort of this new idea. It's like a super intelligent Unix utility.
00:22:13.680 | And I think we've barely scratched the surface of how to use this. We're just figuring this out.
00:22:17.280 | You can read from, like, a GCP bucket. Read, you know, like, a giant log and pipe it in and tell
00:22:23.360 | Claude to figure out what's interesting about this log. You can fetch data from, like, the Sentry CLI.
00:22:29.760 | You can also pipe it in and have Claude do something with it.
00:22:32.160 | The final thing, and this is probably, like, the most advanced use case as we see, I'm sort of a Claude
00:22:42.160 | normie. So I'll have usually, like, one Claude running at a time. And maybe I'll have, like,
00:22:46.560 | a few terminal tabs for a few different repos running at a time. When I look at power users
00:22:50.880 | in and out of Anthropic, almost always they're going to have, like, SSH sessions. They'll have,
00:22:56.320 | like, Tmux tunnels into their Claude sessions. They're going to have a bunch of checkouts of the
00:23:00.800 | same repo so that they can run a bunch of Claude in parallel in that repo. Or they're using Git work
00:23:05.360 | trees to have some kind of isolation as they do this. And we're actively working on making this easier to use.
00:23:10.640 | But for now, like, these are some ideas for how to do more work in parallel with Claude. You can run
00:23:17.040 | as many sessions as you want. And there's a lot that you can get done in parallel.
00:23:21.520 | So, yeah, that's it. I wanted to also leave some time for Q&A. So I think this is the last slide that I
00:23:30.640 | have. And, yeah, if folks have questions, there's mics on both sides. And, yeah, we'd love to answer any
00:23:37.040 | questions.
00:23:43.440 | .
00:23:49.840 | .
00:23:53.840 | I did.
00:23:54.240 | .
00:23:59.840 | I think there's a lot of tricky parts. I think one part that is especially tricky is the things
00:24:18.640 | that we do to make Bash commands safe. Bash is inherently pretty dangerous and it can change system
00:24:24.000 | state in unexpected ways. But at the same time, if you have to manually approve every single Bash command,
00:24:31.840 | it's super annoying as an engineer. And you can't really be productive because you're just constantly
00:24:35.280 | approving every command. And just kind of navigating how to do this safely in a way that that scales
00:24:40.640 | across the different kinds of code bases people have, because not everyone runs their code in a
00:24:44.320 | Docker container was pretty tricky. And essentially the thing we landed on is there's some commands that
00:24:50.000 | are read-only. There's some static analysis that we do in order to figure out which commands can be
00:24:54.320 | combined in safe ways. And then we have this pretty complex tiered permission system so that you can
00:24:59.920 | allow list and block list commands at different levels.
00:25:01.840 | Hi, Boris. You mentioned giving an image to cloud code, which made me wonder if there's some sort of
00:25:10.960 | multimodal functionality that I'm not aware of. Are you just pointing it at an image on the file system
00:25:16.320 | or something? Yeah, so cloud code is fully multimodal. It has been from the start. It's in a terminal,
00:25:21.440 | so it's a little hard to discover. But yeah, you can take an image and just drag and drop it in. That'll work.
00:25:26.960 | You can give it a file path. That'll work. You can copy and paste the image in and that works too.
00:25:32.800 | So I'll use this pretty often for if I have like a mock of something, I'll just drag and drop in the mock.
00:25:39.520 | I'll tell it to implement it. I'll give it up to your server so it can iterate against it.
00:25:43.440 | And yeah, it's just fully automated.
00:25:45.040 | Um, hey, uh, why did you build a CLI tool instead of an IDE?
00:25:52.800 | Yeah, it's a good question. I think there's probably two reasons. One is, uh, we started this
00:25:59.600 | at Anthropic. And at Anthropic, people use a broad range of IDEs. And some people use VS Code,
00:26:05.040 | other people use Z, or Xcode, or Vim, or Emacs. And it was just hard to build something that works for
00:26:11.600 | everyone. And so terminal is just the common denominator. The second thing is at Anthropic,
00:26:17.360 | we're, uh, we see up close how fast the model is getting better. And so I think there's a good
00:26:23.200 | chance that by the end of the year, people aren't using IDEs anymore. And so we want to get ready for
00:26:28.480 | this future. And we want to avoid over-investing in UI and other layers on top, given that the way the
00:26:34.800 | models are progressing, it just, it may not be useful work pretty soon.
00:26:38.400 | Yeah, how much have you, I don't know if this is, is this on? How much have you used
00:26:47.840 | cloud code for machine learning modeling and almost that AutoML experience? I was curious
00:26:52.720 | what the experience has been so far with that. Yeah, I think, I think the question was how much are we
00:26:58.080 | using cloud code for machine learning and modeling? We actually use it for this a bunch. So both engineers
00:27:04.560 | and researchers at Anthropic use cloud code every day. I think about 80% of people at Anthropic that
00:27:11.200 | are technical use cloud code every day. And hopefully you can see that in the product and kind of the
00:27:15.360 | amount of love and dog fooding we've put into it. But this includes researchers who use tools like the
00:27:20.240 | notebook, notebook tool to edit and run notebooks. Okay, very cool. Thank you.
00:27:24.800 | All right, I think that's it. Thanks.
00:27:32.560 | All right. Thanks.
00:27:34.560 | All right. Thanks.
00:27:36.560 | All right.
00:27:38.560 | All right. Thanks.
00:27:40.560 | All right.
00:27:42.560 | All right.
00:27:44.560 | All right.
00:27:45.560 | All right.
00:27:46.560 | All right.
00:27:48.560 | All right.
00:27:50.560 | All right.
00:27:50.560 | All right.
00:27:52.560 | All right.
00:27:54.560 | All right.
00:27:56.560 | All right.
00:27:58.560 | All right.
00:28:00.560 | All right.
00:28:00.560 | All right.
00:28:02.560 | you
00:28:04.620 | .