站长原创 · 全文公开

如何学习Claude Code?跟着Claude Code 创始人Boris 学就够了，这是最权威的学习资料

书情

2026-09-18 · 约 35490 字 · Claude Code / AI产品开发 / AI / AI编程 / 工具推荐 / 风向标

赞3藏0评1读381

这篇是我本人写的，所以全文放在这里，你不用领体验卡也能读完。文末有生财原帖链接，评论区的讨论在那边。

这篇文章与算是抛砖引玉，最近身边有朋友问我怎么学AI编程，我的答案非常简单，直接跟 Claude Code 创始人Boris 学就够了，如果说这个视频

ClaudeCode的创始人发布了一段28分钟的视频，讲解如何编写提示词

https://www.youtube.com/watch?v=XFYUKBPfUMw

学东西，学一手信息，这是信息含量最高的了，直接跟 Claude Code 创始人Boris，你就不可能走弯路，如果你的主要开发语言是ChatGPT,其实是一通百通，你就盯着最懂ChatGPT的人，比如说 Tibo。

大家眼里的大佬也是学的一手信息，如果你不想花钱，就得花时间，同时如果你在深圳，也欢迎参加我的局，不过已经满了，等我再开新局。

好了，接下来是视频的中英文双语版本

Hello. Everyone, uh I'm Boris. I'm a member of technical staff here at Anthropic, and I created Claude Code. And here to talk to you a little bit about some practical tips and tricks for using Claude Code. Um it's going to be very practical. I'm not going to go too much into the history or the theory or anything like this.

大家好，我是 Boris，Anthropic 的技术团队成员（Member of Technical Staff），也是 Claude Code 的创建者。今天想和大家聊聊使用 Claude Code 的一些实用技巧。内容会非常偏实战，我不会过多涉及历史、理论之类的东西。

Uh and yeah, before we start, actually, can we get a quick show of hands, who has used Claude Code before? Yeah. All right, that's what we like to see. For everyone that didn't raise your hands, uh 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 Claude Code, uh just so you can follow along for the rest of the talk. All you need is Node.js. If If you have it, it should work. Yeah, if you Well, you don't have to you don't have to follow along, but if you don't have it yet, yeah, this is your chance to install it so you can follow along.

在开始之前，先请大家举手示意一下：谁之前用过 Claude Code？好，很好，这正是我们想看到的。没举手的朋友——我知道别人讲话的时候不该干这个——但如果方便，请打开笔记本电脑，输入这条命令。

它会帮你安装 Claude Code，这样接下来的内容你就能跟着操作。只需要有 Node.js 就行，装了的话应该就能运行。当然，你不一定非要跟着做；但如果还没装，现在正是安装的好机会。

So, what is Claude Code? Claude Code is a new kind of AI assistant, and there's been different generations of AI assistants for coding. Most of them have been about completing, you know, like a line at a time, completing a few lines of code at a time. Claude Code is not for that. It's fully agentic. So, it's meant for building features, for writing entire functions, entire files, fixing entire bugs at at the same time.

那么，Claude Code 是什么？Claude Code 是一种新型的 AI 助手。编程领域的 AI 助手已经历了好几代，其中大多数做的是补全——一次补全一行，或者一次补全几行代码。

Claude Code 不是干这个的，它是完全 agentic（智能体式）的。也就是说，它面向的是构建完整功能、编写整个函数、整个文件、一次性修复整个 bug 这类任务。

And 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. You don't have to swap everything to start using it. So, whatever IDE you use, if you use VS Code or if you use Xcode, or if you use uh 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. It'll work locally, over remote SSH, over tmux, whatever environment you're in, you can run it.

Claude Code 很酷的一点是，它能与你现有的所有工具协同工作，你不必改变工作流，也不用把一切都换掉才能上手。不管你用什么 IDE——VS Code、Xcode，还是 JetBrains 系列 IDE（Anthropic 有些人，你休想从他们手里把 JetBrains 夺走）——他们照样在用 Claude Code，因为 Claude Code 适配每一种 IDE、每一种终端。

它可以在本地运行，也可以通过远程 SSH、通过 tmux 运行；无论你处在什么环境，都能跑起来。

It's general purpose, and this is something where if you haven't used these kind of free-form coding assistance in the in the past, it can be kind of hard to figure out how to get started cuz you open it up and you just see a prompt bar, and you might wonder like what do I 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.

它是通用型的。如果你以前没用过这类自由形式的编程助手，可能会不太清楚该如何入手：打开之后只看到一个提示输入栏，你也许会想：我拿它干什么？该输入什么？它是一件强力工具（power tool），能做的事情很多；也正因为它能做的太多，我们不会刻意把你引向某种特定的工作流。说到底，作为工程师，你应该能按自己想要的方式去使用它。

As you open up Claude 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. So, run terminal setup. This will give you shift enter for new lines, so you don't have to do like backslashes to enter new lines. This is, you know, it it makes it a little bit nicer to use. Do /theme to set light mode or dark mode or Daltonize themes. Um you can do /install GitHub app. So, today when we announced a GitHub app, where you can at-mention uh Claude on any GitHub issue or pull request. So, to install it, just run this command in in your terminal.

第一次打开 Claude Code 时，我们建议先做几件事把环境配置好，都很简单。首先，运行 terminal setup（即 /terminal-setup），它会让你可以用 Shift+Enter 换行，而不必用反斜杠来输入新行，用起来会顺手一些。用 /theme 设置浅色模式、深色模式或 Daltonized（色觉友好）主题。

还可以运行 /install GitHub app（即 /install-github-app）——我们今天刚发布了一个 GitHub app，你可以在任意 GitHub issue 或 pull request 里 @ 提及 Claude；要安装它，只需在终端里运行这条命令。

Um you can customize the set of allowed tools that you can use, so you're not prompted for it every time. This is pretty convenient um for 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. And something that I actually do is for a lot of my prompts, I won't hand type them into a Claude Code. If you're on macOS, you can go into your system settings under accessibility is dictation, and you can enable it. And so, something I do is you just hit like that dictation key twice, and you can just speak your prompt. And it helps a lot to have specific prompts. So, this is actually pretty be You can just talk to Claude Code and like you would another engineer and you don't have to type a lot of code.

你可以自定义允许使用的工具集合，这样就不会每次都被询问授权。这很方便——对于那些反复弹出确认的操作，我一定会这样配置，免得每次都要点同意。另外，我自己的一个习惯是：很多提示词我并不是手打进 Claude Code 的。如果你用的是 macOS，可以到系统设置的"辅助功能"下找到"听写"并启用它。

我的做法是连按两下听写键，然后直接把提示词说出来。提示词越具体，帮助越大。所以这其实相当……你可以像跟另一位工程师交谈那样跟 Claude Code 说话，而不必敲一大堆代码。

So, when you're starting out with Claude Code, it's so free form and it can do everything. What do you start with? The thing I recommend above everything else is starting with code base Q&A. So, just asking your question asking questions to your code base. This is something that we teach new hires at Anthropic. So, 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.

刚开始用 Claude Code 时，它如此自由、什么都能做，该从哪里入手？我最推荐的一件事，就是从代码库问答（codebase Q&A）开始，也就是直接向你的代码库提问。

这也是我们教给 Anthropic 新员工的做法：入职第一天的技术培训上，你会了解 Claude Code，下载它、配置好，然后马上开始就代码库提问。

And in the past when you're doing technical onboarding, it's something that taxes the team a lot. Right? You have to ask other engineers on the team questions. You have to look around the code and this takes a while. You have to figure out how to use the tools. This This takes a long time. With Claude Code, you can just ask Claude Code and it'll explore the code base, it'll answer these kind of questions. And so, at Anthropic, onboarding used to take about two or three weeks for technical hires, it's now about two or three days.

过去做技术入职培训，对团队是很大的负担，对吧？你得去问团队里其他工程师，得自己翻代码，这很花时间；还得摸索各种工具怎么用，同样耗时很久。有了 Claude Code，你直接问它就行，它会去探索代码库并回答这类问题。在 Anthropic，技术岗新人的入职上手过去大约需要两到三周，现在大约只要两到三天。

What's also kind of cool about Q&A is we uh we don't do any sort of indexing. So, there's no remote database with your code. We don't upload it anywhere. Your code stays local. We do not train generative models on the code. So, it's there, you control it, there's no indices or anything like this. And what that means is also there's no setup. So, you start Claude, you download it, you start it, there's no indexing, you don't have to wait, you can just use it right away.

问答还有一个很酷的地方：我们不做任何形式的索引。所以不存在存放你代码的远程数据库，我们不会把代码上传到任何地方，你的代码始终留在本地。我们也不会用这些代码训练生成式模型。代码就在那里，由你掌控，没有任何索引之类的东西。这同时意味着无需任何前期配置：下载 Claude，启动它，没有索引过程，不用等待，马上就能用。

This is a technical talk. So, um 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 Claude Code experience. So, some kind of questions that you can ask is uh you know, like how is this particular piece of code used or how do I instantiate this thing? And Claude Code, it won't just do like a text search and try to answer this. It'll often go a level deeper and it'll try to find examples of how is this class instantiated? How is it used? And it'll give you a much deeper answer. So, something that you would get out of a wiki or documentation instead of just like command F.

这是一场技术分享，所以我会展示一些非常具体的提示词和代码示例，大家可以直接拿去用，希望能改善并提升你使用 Claude Code 的体验。你可以问的问题比如：这段代码是怎么被使用的？或者，我该如何实例化这个东西？

Claude Code 不会只做一次文本搜索就来回答，它往往会再深入一层，去找这个类是如何被实例化、如何被使用的示例，给你一个深入得多的答案——相当于你从 wiki 或文档里才能得到的内容，而不只是 Command+F 的结果。

Something that I do a lot also is ask about Git history. So, 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 code bases, you have some function like this or some class like this. And Claude 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 link to? And it'll look through all this and summarize it. And you don't have to tell it that in all these in all this detail. You just ask it. So, just say look through Git history and it'll know to do this.

我还经常让它查 Git 历史。比如：这个函数为什么有 15 个参数？这些参数为什么起了这么奇怪的名字？我敢说在座各位的代码库里，都有这样的函数或这样的类。

Claude Code 可以翻阅 Git 历史，弄清这些参数是怎么引入的、谁引入的、当时是什么情况、那些 commit 关联了哪些 issue；它会把这些都看一遍，然后给出总结。你不需要把这些细节一一交代，直接问就行——只要说"查一下 Git 历史"，它就知道该怎么做。

The reason it knows it, by the way, is not because we prompted it to. There's nothing in the system prompt about looking through Git history. It knows it because the model was awesome. And if you tell it to use Git, it'll know how to use Git. So, we're lucky to be building on such a good model.

顺便说一下，它之所以知道这么做，并不是因为我们在提示词里要求了——系统提示词（system prompt）里没有任何关于查阅 Git 历史的内容。它知道，是因为模型本身足够出色；你让它用 Git，它就知道怎么用 Git。能在这么好的模型之上做产品，我们很幸运。

I often ask about GitHub issues. So, you know, it can use web fetch and it can fetch issues and look up context on issues, too, and this is pretty awesome. And 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 readout of everything I I shipped. And I'll just copy and paste that into a doc somewhere.

我也经常问 GitHub issue 相关的问题。它可以使用 web fetch 抓取 issue，并查找 issue 的相关上下文，这非常好用。还有一件事，我每周一的周例会（stand-up）都会做：我会问"我这周交付了什么？"Claude Code 会去看 log，它知道我的用户名，然后给我一份清晰的清单，列出我交付的所有内容，我直接复制粘贴到某个文档里就行。

So, yeah, that's tip number one for people that have not used Claude Code before. If you're just showing it to someone for the first time, onboarding your team, the thing we definitely recommend is start with code base Q&A. Don'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. And 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?

这就是给没用过 Claude Code 的人的第一条建议。如果你是第一次向别人展示它、带团队上手，我们明确建议从代码库问答开始。不要一上来就用花哨的工具，不要一上来就改代码，先就代码库提问，这会教会大家如何写提示词。

同时也会让他们逐渐摸清这条边界：Claude Code 能做什么、能力到哪里，哪些地方需要你多扶它一把；哪些任务可以一次完成（one-shot），哪些需要两次、三次；哪些需要在 REPL 里用交互模式来做。

Once you're pretty comfortable with Q&A, you can dive into editing code. This is the next thing. And the cool thing about uh any sort of agentic, you know, like using a LLM in a agentic way is you give it tools and it is just like magical. It figures out how to use the tools. And with Claude Code, we give it 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 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. And you don't have to prompt it specifically to use this tool and this tool and this tool. You just say, you know, do this thing and it'll figure out how to do it. It'll string it together in the right way that makes sense for Claude Code.

当你对问答已经比较熟悉了，就可以进入代码编辑，这是下一步。以 agentic 方式使用 LLM 最妙的地方在于：你给它工具，它就像有魔法一样，自己就能弄明白怎么用这些工具。

在 Claude Code 里，我们给它的工具集相当小，并不多：一个编辑文件的工具，一个运行 bash 命令的工具，一个搜索文件的工具。它会把这些工具串联起来，去探索代码、进行构思，最后完成修改。

你不需要专门提示它"用这个工具、再用这个工具、再用那个工具"，只要说"把这件事做了"，它就会自己想办法，以对 Claude Code 而言合理的方式把工具串起来。

There's a lot of ways to use this. Something 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. This 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. You don't have to use any special tools to do this. All you have to do is ask Claude. And it'll know what to do this. So, just say, "Before you write code, make a plan." That's it.

用法有很多。我有时喜欢这样做：在让 Claude 直接动手写代码之前，先让它做一点头脑风暴，或者制定一个计划。这是我们强烈推荐的做法。我有时看到有人拿到 Claude Code 就说："嘿，把这个 3000 行的庞大功能实现出来。"有时它第一次就能做对；

但有时它做出来的东西完全不是你想要的。要得到想要的结果，最简单的办法就是让它先思考：先头脑风暴出几个思路，制定计划，拿给我过目，在写代码之前征得我的同意。你不必使用 plan mode，也不必使用任何特殊工具，只需要跟 Claude 说一声，它就知道该怎么做。所以只要说："写代码之前，先制定一个计划。"就这么简单。

This is also I want to think with this one this commit push here. This is a really common incantation that I use. There's nothing special about it, but Claude is kind of smart enough to interpret this. So, it'll make a commit. It'll push it to the branch, make a branch, and then make a pull request for me on GitHub. You don't have to explain anything. It'll look through the code. It'll look through the history. It'll look through 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. Again, we're not system prompting it to do this. It just knows how to do this. The model was good.

另外我想说一下这里的 "commit, push, PR"。这是我非常常用的一句"咒语"。它本身没什么特别之处，但 Claude 足够聪明，能理解它的意思：它会创建一个 commit，新建分支并 push 上去，然后在 GitHub 上替我创建一个 pull request。

你什么都不用解释。它会自己查看代码、查看历史、查看 git log，弄清 commit 的格式等等，然后以正确的方式完成 commit 和 push。同样，这不是我们通过系统提示词让它做的，它本来就会。模型确实很好。

As you get a little bit more advanced, you're going to want to start to plug in your team's tools. And this is where Claude Code starts to really shine. And there's generally two kinds of tools. So, one is bash tools. And an example of this, I just made up this like barley CLI. This isn't a real thing. Um but you can say use this CLI to do something. And you can tell Claude Code about this. And you can tell it to use, for example, like --help to figure out how to use it. And this is efficient. If you find yourself using it a lot, you can also dump this into your CLAUDE.md, which we'll talk about in a bit. So, Claude can remember this across sessions. But this is a common pattern we follow at Anthropic. And we see external customers use, too.

再进阶一些，你会想把团队的工具接进来，这正是 Claude Code 真正大放异彩的地方。工具大致分两类。一类是 bash 工具。举个例子——这个 barley CLI 是我随口编的，并不真实存在——你可以说"用这个 CLI 去做某件事"。你可以把这个工具告诉 Claude Code，也可以让它用比如 --help 来弄清楚用法。

这样很高效。如果你发现自己经常用到它，也可以把这些信息写进 CLAUDE.md（稍后会讲到），这样 Claude 就能跨会话记住它。这是我们在 Anthropic 遵循的常见模式，我们也看到外部客户在这样用。

And same thing with MCP. Um Claude Code can use bash tools. They can use MCP tools. So, you know, just tell it about the tools. And you can add MCP tool, and you can tell it how to use it, and it'll it'll just start using it. And this is extremely powerful cuz 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.

MCP 也是同样的道理。Claude Code 可以使用 bash 工具，也可以使用 MCP 工具。所以只要把工具告诉它就行：添加一个 MCP 工具，告诉它怎么用，它就会直接用起来。这非常强大，因为当你在一个新的代码库上开始使用 Claude Code 时，可以把你所有的工具——团队在这个代码库上已经在用的全部工具——都交给它，Claude Code 就能代你使用它们。

There'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 ask me for confirmation before you start to write code. These other two on the right are extremely powerful. When Claude has some way to check its work, so for example, by writing unit tests or screenshotting in Puppeteer or screenshotting the iOS simulator, 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'll get it pretty good. But if you let it iterate two or three times, often it gets it almost perfect.

有几种常见的工作流。这一个我前面已经讲过：先做一点探索，做一点规划，在开始写代码之前先向我确认。右边另外两种则极其强大。

当 Claude 有办法检查自己的工作成果时——比如编写单元测试、在 Puppeteer 里截图，或者对 iOS 模拟器截图——它就能迭代。这一点非常惊人：比如你给它一份设计稿（mock），让它构建这个 Web UI，它第一次就能做得不错；但如果让它迭代两三次，往往能做到近乎完美。

So, 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. So, for whatever your domain is, if it's unit test or integration test or screenshots for apps or web or anything, just give it a way to see its result and it'll iterate and get better.

所以诀窍在于：给它某种可以获取反馈、用来检查自身工作的工具。在此基础上它会自行迭代，你会得到好得多的结果。无论你的领域是什么——单元测试、集成测试、应用或网页的截图，任何形式都行——只要给它一种看到自己产出结果的方式，它就会不断迭代、越做越好。

So, these are the next steps. Teach Claude how to use your tools and figure out the right workflow. If you want Claude to jump in a 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.

这些就是接下来的步骤：教会 Claude 使用你的工具，并找到合适的工作流。你是想让 Claude 直接上手写代码，还是先头脑风暴、制定计划，还是让它迭代——心里要大致有数，这样你才知道该怎样提示 Claude 去做你想要的事。

As 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 and everything else. So, you can there's different ways to give this to Claude. And as you give Claude more context, it'll do better.

再往深处走，在工具之外，你会想给 Claude 更多上下文。上下文越多，它做出的决策就越明智——因为作为在某个代码库里工作的工程师，你脑子里装着大量关于系统、历史等等的上下文。把这些交给 Claude 有不同的方式；你给 Claude 的上下文越多，它的表现就越好。

There's different ways to do this. The simplest one is what we call CLAUDE.md. And CLAUDE.md is the special file name. The simplest place to put it is in the project root. So, the same directory you start Claude in, put a CLAUDE.md in there and that'll get automatically read into context at the start of every session. And essentially, the first user turn will include the CLAUDE.md. You can also have a local CLAUDE.md and this one you don't usually check into source control. So, CLAUDE.md you should check into source control, share with your team so that you can write it once and share it with your team. This one you don't check in. It's just for you.

方式有好几种，最简单的一种我们称为 CLAUDE.md。CLAUDE.md 是一个特殊的文件名。最简单的放置位置是项目根目录：在你启动 Claude 的那个目录里放一个 CLAUDE.md，它就会在每次会话开始时被自动读入上下文。本质上，第一个 user turn 会包含 CLAUDE.md 的内容。

你还可以有一个本地的 CLAUDE.md（即 CLAUDE.local.md），这个通常不提交到版本控制。也就是说，CLAUDE.md 应该提交到版本控制、与团队共享，这样写一次就能全队共用；而本地的这个不提交，只给你自己用。

The kinds of things you put in CLAUDE.md, 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 code base. Try to keep it pretty short cuz 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. And for for example, in our code base, we have uh common bash commands, we have a style guide, we have a few core files, kind of things like that.

CLAUDE.md 里放的内容大致是：常用的 bash 命令、常用的 MCP 工具、架构决策、重要文件——凡是在这个代码库里工作通常需要了解的东西。尽量保持简短，因为太长的话只会占用大量上下文，而且通常也没多大用处，所以能多短就多短。

比如在我们自己的代码库里，有常用 bash 命令、一份代码风格指南（style guide）、几个核心文件，诸如此类。

All the other CLAUDE.md files, you can put them in other nested child directories, and Claude will pull them in on demand. So, these are the CLAUDE.md files that will get pulled in automatically. Um but then also you can put in put CLAUDE.md files in nested directories, and those will get put those will get automatically pulled when Claude works in those directories. Um and of course, if you're, you know, a company, maybe you want a CLAUDE.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.

其他的 CLAUDE.md 可以放在嵌套的子目录里，Claude 会按需加载。也就是说，前面这些是会被自动加载的 CLAUDE.md；此外你也可以把 CLAUDE.md 放进嵌套目录，当 Claude 在那些目录里工作时，它们会被自动加载进来。

当然，如果你是一家公司，也许希望有一个在所有代码库之间共享的 CLAUDE.md，并代用户统一管理它；你可以把它放在企业级根目录（enterprise root）下，它同样会被自动加载。

There's a ton of ways to pull in context. I actually had a lot of trouble putting this slide together just to communicate the breadth of ways you can do this. But, CLAUDE.md is pulled in automatically. You can also use slash commands. So, this is .claude/commands, and this can be in your home directory, or it can be checked into your project. And this is for slash commands. And over here, we have a few examples of the slash commands that we have in Claude Code itself. And so, for example, if you're in the Claude Code repo, and you see issues getting labeled, that's actually this workflow running here. It's label GitHub issues. And we have a GitHub action running, the same one we talked about this morning, where Claude Code will run this command, and it's just a slash command. It'll run, and it'll label the issues, so humans don't have to. It just saves us a bunch of time.

引入上下文的方式非常多，这张幻灯片我其实费了很大劲才做出来，就是为了说明途径之广。CLAUDE.md 是自动加载的。你还可以使用 slash command，对应 .claude/commands 目录，它可以放在你的 home 目录下，也可以提交到项目里，用来定义 slash command。这里列了几个 Claude Code 自身仓库里的 slash command 示例。

比如，如果你在 Claude Code 的仓库里看到 issue 被打上了标签，那其实就是这个工作流在运行——label GitHub issues。我们有一个 GitHub Action 在跑，就是今天上午讲到的那个，由 Claude Code 来执行这条命令，而它只是一个 slash command。它运行起来给 issue 打标签，这样就不用人来做了，为我们省下了大量时间。

And of course, you can @-mention files to pull them into context. Um and like I said before, CLAUDE.md files 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. You can run it through a prompt improver consider who the context is for, if you want to pull it in every time, if you want to pull it in on demand, if you want to share it with a team, if it's a personal preference. Definitely take the time to tune it. This will improve performance dramatically uh if you do it right.

当然，你也可以用 @ 提及文件，把它们引入上下文。还有我前面说过的，嵌套目录里的 CLAUDE.md 会在 Claude 进入该目录工作时被加载。所以，多给 Claude 一些上下文，而且花时间调优上下文绝对值得。

你可以用 prompt improver 把它过一遍；想清楚这份上下文是给谁用的：是每次都加载，还是按需加载；是与团队共享，还是个人偏好。一定要花时间去调优——做得好的话，效果会有显著提升。

As you get more advanced, you're going to want to think about this a little bit more of this kind of hierarchy of different ways to pull in everything. So like not just CLAUDE.md, but also config and uh kind of everything about Claude you can pull in in this hierarchical way. So projects uh are specific to your Git repo, and this you can check in or you can make it just for you. You can also have global configs that are for across all your projects, 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.

再进阶一些，你需要更多地思考这种分层结构，也就是以不同层级引入各种内容的方式。不只是 CLAUDE.md，还有配置，以及 Claude 的几乎一切，都可以用这种分层方式引入。

项目级（project）配置针对你的 Git 仓库，可以提交进去，也可以只给自己用；还可以有适用于你所有项目的全局（global）配置；或者是企业策略（enterprise policies）——它本质上是一份全局配置，会自动下发给你所有的员工、团队里的每个人。

And 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. So for example, if you have a bash command that you would run for all your employees, uh 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-approved, which is pretty convenient. And you can also use this to block commands. So for example, let's say there's a URL that should never be fetched, um just add it to this config, and that'll make it so an employee cannot override it. And that that URL can never be fetched. So pretty convenient both to unblock people and also just to keep your code base safe.

这张幻灯片信息密度挺高，但重点是：这套机制适用于很多东西。slash command 可以这样配，权限也可以这样配。举个例子，如果有一条 bash 命令是所有员工都会运行的——比如大家都用某条 test 命令——你可以直接把它写进企业策略文件，之后任何员工运行这条命令时都会被自动批准，非常方便。

你也可以用它来屏蔽命令。比如有某个 URL 绝不应该被抓取，只要把它加到这份配置里，员工就无法覆盖这项设置，那个 URL 永远不会被抓取。所以无论是为大家扫清障碍，还是保障代码库安全，这都很方便。

And then same thing for MCP servers. Have a MCP JSON file, check it into the code base, that way anytime someone runs Claude Code in your code base, they'll be prompted to install the MCP servers. And share it with the team.

MCP server 也是一样：准备一个 MCP JSON 文件（.mcp.json），提交到代码库，这样任何人在你的代码库里运行 Claude Code 时，都会被提示安装这些 MCP server，从而与团队共享。

If you're not sure which of these to use, this is like a kind of an insane matrix cuz 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. So if you're not sure how to get started, I would recommend start with shared project context. You write this once, and then you share it with everyone on the team, and you get this kind of network effect where, you know, someone does a little bit of work, and everyone on the team benefits.

如果你不确定该用哪一种——这确实是个有点夸张的矩阵，因为我们支持的东西很多，工程师的工作流非常灵活，每家公司又各不相同，所以我们希望尽量都支持——如果不知道从哪里开始，我建议从共享的项目上下文入手。写一次，然后与团队里每个人共享，你会得到一种网络效应：某个人做了一点工作，团队里所有人都受益。

There's a lot of tools built into Claude to manage this. Uh so, as an example, if you run /memory, you can see all the different memory files that are getting pulled in. So, maybe I have an enterprise policy, I have my user memory, I have project CLAUDE.md, and then maybe there's a nested CLAUDE.md. That's only pulled in for certain directories. And then, similarly, when you do /memory, you can edit particular memory files. When you type pound sign to remember something, you can pick which memory you want it to go to.

Claude 内置了很多工具来管理这些。比如运行 /memory，你可以看到所有正在被加载的 memory 文件：也许有一份企业策略，有我的用户级 memory，有项目的 CLAUDE.md，可能还有一个嵌套的 CLAUDE.md——它只在特定目录下才会被加载。

同样，运行 /memory 时，你可以编辑某个具体的 memory 文件。当你输入井号（#）让它记住某件事时，可以选择要写入哪一份 memory。

So, yeah, that's the next tip. Take the time to configure CLAUDE.md, 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. Um an example of this is uh in our apps repo uh for Anthropic, this is like the repo that we have all of our web and apps code in. There's a Puppeteer MCP server, and we share this with the team. Um and there's an MCP JSON checked in, so any engineer working in 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.

这就是下一条建议：花时间配置好 CLAUDE.md、MCP server，以及你团队使用的所有东西，这样只需配置一次，就能与所有人共享。举个例子，在 Anthropic 的 apps 仓库里——我们所有 Web 和应用端代码都在这个仓库——有一个 Puppeteer MCP server，我们把它共享给整个团队。

仓库里提交了一份 MCP JSON，因此任何在该仓库工作的工程师都可以用 Puppeteer 来驱动端到端测试、自动截图并迭代，而不需要每位工程师自己去安装。

This is a talk about pro tips, so I I just want to take a quick interlude to talk about some common key bindings that people may not know. It's a It's very hard to build for a terminal. It's also very fun. It feels like rediscovering this new design language. But, something about terminals is is It's extremely minimal. And so, sometimes it's hard to discover these key bindings. And here's just a quick reference sheet.

这是一场关于进阶技巧（pro tips）的分享，所以我想插播一小段，讲讲一些大家可能不知道的常用快捷键。为终端做产品非常难，但也非常有趣，感觉像是在重新发现一种新的设计语言。不过终端的特点是极度简约，所以这些快捷键有时不容易被发现。这里是一份速查表。

So, anytime, you can hit shift tab to accept edits. Uh and this switches you into auto accept edits mode. So, bash commands still need approval, but edits are auto accepted. And you can always ask Claude to undo them later. Um for example, I'll do this if I know Claude'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 okay every single edit.

任何时候，你都可以按 Shift+Tab 来接受编辑，这会切换到自动接受编辑（auto-accept edits）模式。此时 bash 命令仍然需要批准，但文件编辑会被自动接受，而且你之后随时可以让 Claude 撤销。

比如，当我知道 Claude 的方向是对的，或者它正在编写单元测试并围绕测试迭代时，我通常会直接切到自动接受模式，免得每一次编辑都要点确认。

Anytime you want Claude 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. It'll incorporate it into CLAUDE.md automatically.

任何时候你想让 Claude 记住某件事——比如它没有正确使用某个工具，而你希望它从此以后都正确使用——只要输入井号（#），然后告诉它要记住什么，它就会记住，并自动写入 CLAUDE.md。

If 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. That'll run locally, but that also goes into the context window. So, Claude will see it on the next turn. Um and 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. And Claude will see the command and the output.

如果你想切到 bash 模式、直接运行一条 bash 命令，可以输入感叹号（!）再键入命令。命令会在本地执行，同时也会进入上下文窗口，因此 Claude 在下一轮就能看到。

这很适合耗时较长的命令（如果你确切知道要做什么），或者任何你希望放进上下文的命令。Claude 会同时看到命令及其输出。

You can @ mention files and folders. Uh anytime you can hit escape to stop what Claude is doing. Um no matter what Claude is doing, you can always save if we hit escape. It's not going to corrupt the session. It's not going to mess anything up. So, maybe Claude is doing a file edit. I'll hit escape. I'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." I'll hit escape. I'll tell it that and then I'll tell it to redo that edit.

你可以 @ 提及文件和文件夹。任何时候都可以按 Escape 停止 Claude 正在做的事。无论 Claude 在做什么，你都可以放心地按 Escape——这不会损坏会话，也不会搞乱任何东西。比如 Claude 正在编辑文件，我按下 Escape，告诉它换个做法。

又或者它给出了一处 20 行的修改建议，而我觉得"其实这里面 19 行都很完美，只有一行需要改"，我就按 Escape，把这一点告诉它，然后让它重做这次编辑。

Uh you can hit escape twice to jump back in history. Um and then after you're done with the session, you can start Claude with --resume to resume that session if you want. Um or --continue. And then anytime if you want to see more output, hit control R and that'll show you the entire output, the same thing that Claude sees in its context window.

连按两次 Escape 可以回跳到历史记录。会话结束之后，如果需要，可以用 --resume 启动 Claude 来恢复那次会话，或者用 --continue。另外，任何时候想看到更多输出，按 Ctrl+R，就会显示完整输出——与 Claude 在其上下文窗口中看到的内容完全一致。

The next thing I want to talk about is the Claude Code SDK. So, we talked about this at the top. Uh right after this, Sid is doing a session, I think just across the hallway and he's going to go super deep on the SDK. If you hadn't played around with this, if you use the -p flag in Claude, this is what the SDK is. And we've been adding a bunch of features over the last few weeks to make it even even better. Um so yeah, you can you can build on top of this. You can do cool stuff. This is exactly the thing that Claude Code uses. It's exactly the same SDK.

接下来我想讲讲 Claude Code SDK。我们在开场时提到过它。这场结束之后，Sid 马上有一场分享，好像就在走廊对面，他会非常深入地讲解 SDK。

如果你还没玩过：在 Claude 里使用 -p 这个 flag，用到的就是 SDK。过去几周我们一直在添加大量功能，让它变得更好。所以，你可以在它之上进行构建，做出很酷的东西。这正是 Claude Code 自身所使用的东西，是完全相同的 SDK。

And so for example, something you can do is claude -p. So this is the the CLI SDK. You can pass up you 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. So you might want JSON or you might want streaming JSON if you want to process this somehow. So this is awesome for for building on. We use this in CI all the time. We use this for incident response. We use this in all sorts of pipelines. So really convenient. Just think of it as like a Unix utility. You give it a prompt, it gives you JSON. You can use this in any way. You can pipe into it, you can pipe out of it.

举个例子，你可以使用 claude -p，这就是 CLI 形式的 SDK。你可以传入一段提示词，可以传入一组允许使用的工具（其中可以包含特定的 bash 命令），还可以指定想要的输出格式：可以是 JSON；如果需要对输出做进一步处理，也可以用流式 JSON（streaming JSON）。

所以它非常适合作为构建的基础。我们在 CI 里一直在用，在事故响应（incident response）里用，在各种各样的流水线（pipeline）里用，非常方便。把它当成一个 Unix 工具就行：你给它提示词，它给你 JSON，怎么用都可以——可以把数据 pipe 给它，也可以把它的输出 pipe 出去。

The piping is also pretty cool. So you can use like for example git status and pipe this in and you know use jq to select the result. It The combinations are endless and it's sort of this new idea. It's like a super intelligent Unix utility. And I think we've barely scratched the surface of how to use this. We're just figuring this out. You can read from like a GCP bucket, read you know like a giant log and pipe it in and tell Claude to figure out what's interesting about this log. Um you can fetch data from like the Sentry uh CLI. You can also pipe it in and have Claude do something with it.

管道的玩法也很酷。比如你可以把 git status 的结果 pipe 进去，再用 jq 筛选结果。组合方式无穷无尽，这算是一种全新的理念：它就像一个超级智能的 Unix 工具。

我认为我们对它用法的探索才刚刚触及皮毛，大家都还在摸索。你可以从 GCP bucket 里读取数据，比如读一份巨大的日志，pipe 进去，让 Claude 找出这份日志里值得关注的地方。你也可以从 Sentry CLI 之类的工具拉取数据，同样 pipe 进去，让 Claude 对其做处理。

The final thing and this is probably like the most advanced use cases we see. I'm sort of a Claude normie. So I'll have usually like one Claude running at a time and maybe I'll have like a few terminal tabs for a few different repos running at a time. When I look at power users in and out of Anthropic, almost always they're going to have like SSH sessions. They'll have uh like tmux tunnels into their Claude sessions. They're going to have a bunch of checkouts of the same repo so that they can run a bunch of Claudes in parallel in that repo. Or they're using Git worktrees to have some kind of isolation as they do this. And we're actively working on making this easier to use, but uh for now like these these are some ideas for for to do more work in parallel with Claude. You can run as many sessions as you want. Uh and there's a lot that you can get done in parallel.

最后一点，这大概是我们见到的最高阶的用法。我自己算是个 Claude"普通用户"（normie），通常同时只跑一个 Claude，顶多开几个终端标签页，分别对应几个不同的仓库。

而当我观察 Anthropic 内外的重度用户（power user）时，他们几乎无一例外都开着 SSH 会话，通过 tmux 连进自己的 Claude 会话；他们会把同一个仓库 checkout 出好几份，以便在该仓库上并行运行多个 Claude；或者用 Git worktrees 来获得某种隔离。

我们正在积极改进，让这些更容易上手；但就目前而言，这些是借助 Claude 并行完成更多工作的几个思路。你想开多少个会话都行，并行能完成的事情非常多。

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 have. And yeah, if folks have questions, there's mics on both sides. And yeah, would love to answer any questions. [applause]

好，就这些。我也想留一些时间做问答，这应该是我的最后一张幻灯片了。如果大家有问题，两侧都有麦克风，我很乐意解答。[掌声]

Skip the file command. [laughter] I did. Slide five. [laughter]

你跳过了 file 命令那部分。[笑声] 确实跳过了。在第五张幻灯片。[笑声]

Hey Boris. Um thanks for building a Claude Code. And I was wondering what was the hardest implementation like part of the implementation for you of building it?

嗨 Boris，感谢你打造了 Claude Code。我想知道，在构建它的过程中，对你来说实现上最难的部分是什么？

I think there's a lot of tricky parts. Um I think one part that is especially tricky is the things that we do to make bash commands safe. Um bash is inherently pretty dangerous and it can change system state in unexpected ways. But at the same time, if you have to manually approve every single bash command, it's super annoying as an engineer and you can't really be productive cuz you're just constantly approving every command. And just kind of navigating how to do this safely in a way that that scales across the different kinds of code bases people have cuz not everyone runs their code in a Docker container. Um was was pretty tricky. And essentially the thing we landed on is there's some commands that are read-only. 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.

我觉得棘手的部分有很多。其中尤其棘手的一块，是我们为保证 bash 命令安全所做的工作。bash 本质上相当危险，它可能以意想不到的方式改变系统状态。但与此同时，如果每一条 bash 命令都要手动批准，对工程师来说非常烦人，你也没法真正高效工作，因为你一直在不停地批准命令。

如何安全地做到这一点，并且能适配大家各种各样的代码库——毕竟不是每个人都在 Docker 容器里跑代码——这确实相当棘手。我们最终落地的方案大致是：有一部分命令是只读的；

我们会做一些静态分析，判断哪些命令可以安全地组合使用；此外还有一套相当复杂的分层权限系统，让你可以在不同层级上对命令设置允许列表（allowlist）和阻止列表（blocklist）。

Hi Boris. You mentioned uh giving an image to Claude Code which made me wonder if there's some sort of multimodal functionality that I'm not aware of. Is that Are you just pointing it at an image on the file system or something?

嗨 Boris。你提到把图片交给 Claude Code，这让我想到，是不是有某种我不知道的多模态功能？你只是让它指向文件系统上的一张图片，还是别的方式？

Yeah, so Claude Code is fully multimodal. Um it has been from the start. It's in a terminal, so it's a little uh hard to discover. Uh but yeah, you can take a image and just drag and drop it in. That'll work. Uh you can give it a file path. That'll work. Um you can copy and paste the image in and that works, too. Um so I'll use this pretty often for if I have like a mock of something, I'll just drag and drop drop in the mock. I'll tell it to implement it. I'll give it a puppeteer server so it can iterate against it. And yeah, it's just fully automated.

是的，Claude Code 是完全多模态的，从一开始就是。只是它在终端里，所以不太容易被发现。

你可以直接把图片拖放进去，可以；给它一个文件路径，也可以；把图片复制粘贴进去，同样可以。我经常这么用：如果手头有某个东西的设计稿（mock），我就直接把它拖进去，让它照着实现，再给它一个 Puppeteer server，让它对照着迭代。整个过程完全自动化。

Um hey, uh why did you build a CLI tool instead of an IDE?

嗨，你们为什么做的是 CLI 工具，而不是 IDE？

Yeah, it's a it's a good question. I think there's probably two reasons. One is uh 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 was just the common denominator. The second thing is at Anthropic, we're uh 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 want to avoid over-investing in UI and other layers on top given that the way the models are progressing, it just it might not be useful work pretty soon.

这是个好问题。我想大概有两个原因。

第一，这个项目始于 Anthropic 内部，而 Anthropic 的同事使用的 IDE 五花八门：有人用 VS Code，有人用 Zed、Xcode、Vim 或 Emacs，很难做出一个适合所有人的东西，而终端恰好是最大公约数。

第二，在 Anthropic，我们近距离看到模型进步的速度有多快。所以我认为，到今年年底，人们很有可能已经不再使用 IDE 了。我们想为这样的未来做好准备，也想避免在 UI 以及其上的其他层面过度投入——按照模型目前的进展速度，这些工作可能很快就不再有价值。

Yeah. How much have you I don't know if this is Is this on? How much have you Claude Code for machine learning modeling and almost that auto ML experience? I was curious what the experience has been so far with that.

好。你们在多大程度上……我不确定这个——麦克风开着吗？你们在多大程度上把 Claude Code 用于机器学习建模，以及那种近似 AutoML 的体验？我很好奇目前这方面的体验如何。

Yeah, I think I think the question was how much are we using Claude Code for machine learning and and modeling. We actually use it for this a bunch, so both engineers and researchers at Anthropic use Claude Code every day. Um I think about 80% of people at Anthropic that are technical use Claude Code 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. Um but this includes researchers who use tools like the notebook notebook tool to edit and run notebooks.

我想这个问题是：我们在多大程度上把 Claude Code 用于机器学习和建模。实际上我们在这方面用得很多，Anthropic 的工程师和研究员每天都在使用 Claude Code。

我估计 Anthropic 大约 80% 的技术人员每天都在用 Claude Code。希望大家能从产品中感受到这一点，感受到我们倾注其中的热爱和 dogfooding（自己使用自家产品）。这其中也包括研究员，他们会使用 notebook 工具之类的工具来编辑和运行 notebook。

Okay, very cool. Thank you.

好的，很棒，谢谢。

All right, I think that's it. Thanks. [applause] [music] [music]

好，我想就到这里。谢谢大家。[掌声] [音乐] [音乐]

这篇文章做为一个引子，更多的一手信息视频得靠自己去看，去学习了，欢迎链接交流，如你在深圳就更好了，可以时不时组局。

来参加组局，我会分享我编程的一手信息，这里指的一手信息是指我看的信息源是英文的，你在国内看的东西，可能是二手，三手，甚至四五手也说不好。

最后帖上关于AI编程相关的帖子

微信聊天记录解密从此方便制作自己的微信群日报

https://scys.com/articleDetail/xq_topic/45548548218248818

从 0 到 1 搭建一个自己的 MCP 服务 · 全流程保姆级教程