与 Matt Pocock 一起掌握 AI 技能

我教你的不只是知识，还想教你智慧。

I'm teaching you knowledge, but I'm also trying to teach you wisdom.

现在获取知识非常便宜。

Knowledge is now very cheap to acquire.

非常非常便宜。

Very, very cheap.

你直接查一下就行了。

You can just look it up.

你知道，你可以建一个教学技能，直接带你，教你需要的知识，但智慧学起来可没那么容易。

You know, you can build I have a teach skill that can just take you and just, you know, teach you the knowledge that you need, But the wisdom has gotten no easier to learn.

它还是在那儿。

It's still knocking about.

就像，你以前没有智慧时会遇到的问题，现在即使有AI，你还是会遇到同样的问题。

Like, you are still gonna run into the same issues that you ran into if you didn't have that wisdom before, even with AI.

所以，就我Total TypeScript的收入来说，显然下降了，因为我觉得人们对那些内容不再那么感兴趣了。

So in terms of, like, my revenue from Total TypeScript, that's gone down, obviously, because I think people are not so interested in that material anymore.

而且我觉得教这些内容的人会面临困难，因为这种知识真的很难获得。

And I think people teaching that material are gonna find it tricky because, again, that knowledge is really, really hard to come by.

我能够坚持下来，不是靠运气，而是花了很多时间才想清楚自己在AI领域的位置。

The only way that I've been able to, not necessarily survive, but it took me a long time to figure out where I wanted to be in the AI space.

因为我不是OpenAI的研究员。

Because I'm not a researcher from open AI.

我没有资格去谈论这些东西，尤其是在2020年底、2023年底我开始关注的时候。

I don't have the credentials to, like, talk about this stuff, really, especially in 2020 late twenty twenty three was when I started looking at it.

最初我制作的是关于如何将AI集成到应用程序中的课程。

And I was initially making courses about how you put AI into applications.

我想，好吧。

I thought, okay.

我一直在构建前端应用，已经很久了。

I've been building front end applications for a long time.

AI确实在改变一些东西，这很合理。

It makes sense that AI is changing things a bit there.

我开始意识到，我下错了赌注。

It started to be clear to me that that was the wrong bet to make.

我没有看到预期的回报，而且我不喜欢——虽然内容不错，我也为此感到自豪，但我不想再做更多了。

I wasn't seeing the returns I was expecting, and I didn't like, the material was good, and I feel proud of it, but I didn't think I wanted to make more of it.

大约在去年十二月，很多人都会提到那个时间点。

And around December last year, which is a date that many people cite

哦，是的。

Oh, yes.

我们，我们，我们知道的，或者，或者，就像我们说的，那个大家都回来后的寒假，AI英雄。

We we we know, or or as as we call the kind of the the winter break where everyone came back AI Hero.

没错。

Exactly.

彼得，彼得假期。

The Peter the Peter break.

彼得假期。

The Peter break.

对。

Yep.

Open Claw 假期，就是 Opus 4.5 发布那会儿，大家都有很多空闲时间，然后就开始拼命用，结果发现，哇。

The Open Claw break when Opus 4.5 is out, people have a lot of time off, and they just start slamming it, and they realize, wow.

好吧。

Okay.

事情真的在发生，我也有同样的感受。

Things are really happening, and that happened to me too.

我意识到，好吧，现在 AI 已经足够好了，你可以把任务交给它。

And I realized, okay, the AI is now good enough that you can delegate to it.

你确实可以围绕这些智能体搭建结构，它们能处理知识、语法，还有我所说的那些战术层面的东西。

You can actually make structures around the agents, and the agents can handle the knowledge, the syntax, the sort of, I call it, the tactical stuff.

对。

Yep.

而你则可以处理战略层面的事情，也就是长期思考。

And you can handle the strategic stuff, the long term thinking.

这个我经常用。

I use that a lot.

我知道你请过约翰·奥斯特豪特上你的播客。

I know you had John Ousterhout on this, podcast.

我自己也一直很想跟他聊聊。

I've been really wanting to chat to him myself.

他对我影响特别大，他讲的是战术性编程和战略性编程的区别。

Like, he's a huge influence on me, and he talks about the difference between tactical programming and strategic programming.

对。

Yep.

在我看来，AI已经很大程度上取代了战术性编程，剩下的战略性部分得靠我们自己来把握。

AI has largely eaten tactical programming, in my view, and it's up to us to handle the strategic.

然后我意识到，在战略层面，我可以做一门课程。

And I realized, okay, in the strategic layer, there's a course I can create there.

那时候我正在看拉尔夫·卢普斯的东西。

I was looking at Ralph Loops at the time.

有点像杰弗里·亨特利，他在做那种很酷的东西，你可以循环让代理去追求这些目标，我当时就想，好吧，这里肯定有内容可做。

Sort of Jeffrey Huntley, was building this really cool stuff where you can loop the agent and get it to follow these goals, and I thought, okay, there's definitely material here.

我只需要找到一个结构，把东西放进去，然后组织一下怎么折腾。

I just need to find a structure within which I can put it and organize how to fiddle around with

它。

it.

我记得有个叫拉尔夫循环的东西。

And I remember there was a Ralph Loops.

你还做了一个视频，在YouTube上很火，到处都有人看，你在里面基本上就是说，好吧。

You also made a video that became very popular on YouTube, everywhere, where you basically said, like, alright.

就像，这是我怎么创建拉尔夫循环的，我有一个项目，里面有很多待办事项，你做得很好，我们会在节目笔记里放那个视频的链接，你在里面说，好吧，通常我们会怎么让代理工作，比如先做计划，然后一步步执行，那种传统的自上而下的规划，你说问题在于，当你执行的时候，甚至代理在执行的时候，会发现，等等，我还需要做更多的事情，那你怎么修改计划呢？

Like, here's how I created a Ralph loop, like, here's I have a project that has a lot of, like, to dos, and you did a great job in, we'll link that video in the show notes below, where you said like, alright, here's how usually we would try to get agents to work, like, do a plan upfront and then implement each step, like, the kind of traditional top down planning, and you're saying the problem is that as you're implementing or even the agent's implementing it, realizes, hang on, I need to do more stuff, and then how do you modify the plan?

然后进入路由循环，你给出了当时用的结构，比如有一个MD文件，它一直放在那里，然后它会往里面加东西，但一直在添加。

And then enter the route loop where you gave the structures that you used at the time, there was, like, an MD file, it keeps it as as there, and it kind of, like, eats to it but but keeps adding.

这对我来说真是大开眼界，哦，我不知道还有这种思考代理的方式。

And, it was actually a pretty eye opener to me as, oh, I don't know a way to think about how to do these agents.

其实，我花了好几年时间尝试把智能体集成到应用里，这对我的帮助真的很大。

It actually, the the couple of years that I spent sort of trying to put agents into applications was really beneficial there.

因为当你试图构建一个包含智能体的应用时，你总是在考虑数据流。

Because when you try to build an app that contains an agent, you're always thinking about data flow.

你会考虑数据如何进入，会是什么形态，优先级如何，是放在系统提示词里还是用户提示词里。

You're thinking about how the data is gonna get in, what shape it's going to be, what priority, where whether you're gonna put it in the system prompt, the user prompt.

你是在比通常使用框架时更低的层面上工作。

You're working at a lower level than you usually get to with the harnesses.

所以当我开始使用这些框架时，感觉就像是，哦，这真的很熟悉。

And so when I got to working with the harnesses, it felt like, oh, this just feels very familiar.

我只需要知道，状态会存在哪里？

I just need to you know, where is the state going to live?

我该如何把状态传给智能体？

How am I gonna pass the state into the agents?

那会是什么样子？

What shape is that going to look like?

我该怎么压缩它或者清除它？

How am I going to compact it or clear it?

你明白吗？

You know?

而且那时候，Claude Code 还处于早期阶段。

And this was, you know, still pretty early days of Claude Code.

Claude Code 已经发布了，你知道，是的。

Claude Code had been out, you know Yeah.

那时候已经五六个月了，感觉非常自然。

Five, six months at that point, and it just felt very natural.

从那时起，我就对这些东西着迷了，我想我们现在会称之为循环，但实际上，它们只是流程。

And from there, I just got obsessed with these I suppose we would call them loops now, but, really, they're just processes.

它们只是把代理连接起来的不同方式。

They're sort of different ways of stringing agents together.

这就像那个图表一样。

It's just kinda like the diagram.

就像，如果你能从一件事画箭头到另一件事，那就可以叫它一个循环，特别是当有端口返回的时候，或者你也可以叫它工作流，或者流程，或者随便什么。

Like, if you can draw arrows from one thing to the other, that you can call that a loop, especially when there is a port that goes back, or you can call it a workflow or or a flow or whatever.

我会叫它有限状态机。

I would call it a finite state machine.

你知道吗？

Know?

这感觉很像我在xState里做的东西，那是基于流程的，基于状态的。

It felt very similar to the stuff I've been working on in xState, which is process based, which is state based.

有时候也是基于事件的，就是，你有一个代理在底部，它向顶部回调一个事件。

Event based sometimes as well, where, you know, you have an agent at the bottom there that's calling an event back at the top.

然后我就开始看到很好的结果。

And that's I started just to see really good results from that.

我会做这些实验，尝试构建我的流程，然后我会开发一个功能，你知道，我有几个应用在维护，用来扩展我的工作。

And I would do these experiments where I would try sort of building out my process, and I would build out a feature of you know, I have a few apps that I work on kind of to extend what I do.

比如，我有一个自定义视频编辑器。

Like, I have a custom video editor.

我有一个，你知道的，一个很大的东西，一个庞大的代码库。

I have a, you know, a huge thing that huge code base.

我还有一些开源项目，我就在构建这些小循环和小管道，有时候我会直接放弃，回到默认的设置。

I have a few open source projects as well, And I was just building these little loops and little pipelines, and I would sometimes just drop it and go back to what the default setup was.

然后我注意到一个巨大的差异。

And I just noticed a huge difference.

就像，我感觉，哇。

Like, I just felt, wow.

好的。

Okay.

我在这里做的事情真的让我为成功做好了准备。

The stuff that I'm doing here is really setting me up for success.

然后我开始思考，我怎样才能最好地传播这个？

And I started thinking, what's the best way that I can distribute that?

我怎样才能更好地和别人分享这个？

How can I share that with other people better?

所以我就开始琢磨，把技能作为分发这些东西的机制。

And that's where I sort of started landing on skills as the distribution mechanism for this stuff.

这些是给AI机器人用的技能，通常你可以定义它们，安装之后，就可以用斜杠命令来调用。

These are the the skills for AI bots harnesses where you can typically define them, and now you can once you install them, you can invoke them with a slash command.

对，就是这样。

Exactly.

技能其实就是一堆markdown文件，放在电脑的某个文件夹里，智能体可以自己调用，也就是模型调用技能，或者你也可以有一些智能体不知道的技能，自己来调用，也就是用户调用技能。

Skills, really, they're just a folder of markdown files that can sit in your computer somewhere, and the agents can either invoke them themselves, so model invoke skills, or you can have skills that, like, the agent doesn't know about, but you can invoke yourself, so user invoke skills.

然后我开始看到这些技能包到处冒出来，比如superpowers，还有Claude Code插件，可以安装，我觉得G Stack也是。

And I started seeing these skill sets pop up everywhere, like superpowers and, you know, Claude Code plugins that you can install, I think G Stack as well.

我意识到，好吧。

I realized, okay.

也许我可以把我拥有的这些东西，也就是这个流程，作为一套技能分发出去，看看大家怎么想。

Maybe I can distribute what I have, this process, as a set of skills and see what people think of it.

一开始，我只是把它放上去，然后就去忙别的事情了。

And, initially, I just put it up, and I was doing other stuff.

我当时在忙课程的事情。

I was working on the course.

后来我回来看了一眼，发现它比我以前做的任何东西星标都多。

And I checked back in, and I realized, oh, it's got more stars than anything else I've ever done.

我甚至都没怎么提过它。

I've not even really talked about it.

你知道吗？

You know?

它就自己放在那儿，靠口碑传开了，我想是这样。

It's just sat there on its own, word-of-mouth, I suppose.

我写了点文档，但真的不多，结果它就已经火起来了。

I've done a little bit of documentation, but really not much, and it's just exploded already.

所以我就想，好吧。

So I thought, okay.

也许我该在这上面多花点功夫。

Maybe I should put a little bit more work into this.

也许我该聊聊这些。

Maybe I should talk about them.

然后我在我们上次见面的地方，也就是AI工程师伦敦大会，大概四月份的时候，做了一场演讲。

And I did a talk at, I think, where we met last, which was AI Engineer London, about in April.

那场演讲的题目是《软件基础仍然重要》，现在那个演讲的观看量已经到大概120万了，我在里面提到了那个技能库。

That talk was entitled software fundamentals still matter, and that talk is now up to, I think, 1,200,000 views or something, and I mentioned the skill set.

那个技能库现在已经有13万颗星了。

The skill set is now at 130,000 stars.

它现在是全球第二多星的技能库。

It is now the second most starred skills repo in the world.

我觉得在所有仓库里，它大概排在第20到第25名左右。

I think somewhere, like, twentieth to twenty fifth of the most starred repos of all time.

哇。

Wow.

你懂我的意思吧？

You know what I mean?

这是怎么回事？

Like, what's going on?

所以显然大家对这个需求很大。

So there's obviously a hunger for this.

这是我职业生涯中第二次，就像我发布那些小型TypeScript视频时一样，我感觉到，哇，这里有一种势头。

So this was the second time in my career, just like when I was putting out the little TypeScript videos where I felt, wow, there's a momentum here.

有些东西正在发生。

There's something happening.

所以我觉得我必须加倍投入。

And so I felt I had to double down on that.

这些技能，你是怎么写的？

The the skills, how did you write them?

这是不是试图捕捉你的工作流程，你对什么对代理有效的理解，你知道，不仅仅是现在，当然，你在考虑状态，你在考虑如何将AI集成到应用程序中，这再次，并没有真正起飞，但你学到了。

Is is this trying to capture your workflow, your understanding of what works with agents, you know, not just right now, but of course, you're thinking about state, you're thinking about how you were integrating AI into application, which, again, didn't take off all all that much, but but you learned.

所以这有点像你的工作流程，你的方式，什么对我有效？

So is this kind of like math's workflow math's way of of what works for me?

对。

Yes.

就是这样。

That's what it is.

我首先会想，人们会使用这些技能，并且会去调整它们。

I try to think, first of all, people are gonna use these skills, and they're gonna tinker with them.

所以我怎么才能做出最简单的一套技能，让人们很容易就能审查呢？

So how do I make the simplest set of skills that people can audit very easily?

我在想，怎么才能最大化地让人们把这些技能用起来，带到工作中去？

I'm trying to think, how do I maximize, people picking these up and using them at work?

比如，最受欢迎的“拷问我”这个技能。

So for instance, the grill-me skill, which is the most popular one.

是的。

Yep.

你知道，我不确定你有没有用过它，

You know, I don't know if you've used it,

但我自己也在用。

but I I use it as well.

好的。

Okay.

嗯，我明白了。

Well, I get it.

它真的让我很烦，它把我问得哑口无言。

It it it's it's annoying how how damn it it grilled me.

我只是问了它一个问题。

I just asked it.

我就说，我想暴露一个API端点，能告诉持有认证令牌的人，通过基本认证，这个邮箱是不是我邮件列表的订阅者，因为我想把它和我正在做的一个活动连接起来，让付费订阅者优先。

I was like, I'd like to expose an API endpoint that can can tell whoever has the authenticated token, have some basic authentication, is this email a subscriber to my email list or not because I I wanna connect it with one of the the events that I'm I'm doing with to get priority to pay subscribers.

这很简单。

And that's very simple.

然后那个“拷问我”的功能，它就开始真的拷问我，比如，好的，那认证怎么办？

And then the grill me thing, it it starts to just really grill me like, okay, so what about authentication?

你是想要Bearer令牌，还是想用JSON格式，那样不太安全，等等？

Do you want the bearer token or do you want it in JSON, which is not as safe, etcetera?

我就想，好吧。

I'm like, okay.

嗯，这确实是个需要做的决定。

Well, that's a decision to make.

然后我们就逐一讨论这些决定，而且讨论得非常深入，比如，我们怎么实施速率限制？

And then we go through all of these decisions and it goes really low level including like, okay, like how do we enforce rate limits?

说到速率限制，你最好是在每天达到一千次时精确执行，不允许再多一次，这会更复杂。

When it comes to rate limits, you want to exactly do it when you get like a thousand per day and not allow a single more, which is more complexity.

我这才意识到，我已经很久没有和团队或工程团队进行过这么深入的讨论了，通常这种讨论需要有深厚领域知识的人参与。

And I just realized, it's been a long time since I've had such an involved design discussion with team or an engineering team, and you typically have it when someone has deep domain knowledge.

我既感到烦，因为我觉得这很简单，别担心那些，但同时也印象深刻，因为这东西，这个AI，这个LLM，通过一系列提示，就能完成所有这些。

And I I was both annoyed by, you know, this is just simple, like, no, don't worry about that, but also impressed that this thing, this AI, this LLM, through a series of prompts, is able to do all

这些。

of this.

我是说，每个人都有一个被追问的故事，我在会议上听到好多这样的例子。

It's I mean, everyone's got a grill me story, so I get so many of these at conferences.

人们会说，你知道，你有一个非常非常简单的技能，其实就是让代理不停地就这个话题采访你。

People say, you know, you've this this very, very simple skill, it's really just telling the agent to interview you relentlessly about the topic.

这是一个很小的技能。

It's a very small skill.

但它有一种奇怪的涌现行为，模型开始跳出框架思考，然后开始向你抛出各种想法。

It just has this weird emergent behavior with it where the models just start thinking a little bit outside the box, and they start throwing ideas at you.

我想我最初是从一个在Claude Code工作的叫Tarik的人那里学来的。

I think I got it originally from, like, a Tarik who works at Claude Code.

他基本上说，让代理采访你，然后你会看到更好的结果。

He's saying, basically, the get the agent to interview you, and then you'll see better results.

所以把这个编成一个小技能，然后我意识到，哇。

So encode that into a little skill, and it's I I realized, wow.

好的。

Okay.

就是比我用过的任何东西都好上十倍。

It's just sort of 10 times better than anything I've ever used.

那个“拷问我”技能是第一个。

And that grill me skill was the first one.

它让我想起了我第一份工作时和那个穿凉鞋的家伙的讨论。

That sort of reminded me of the discussions I would have at at my first job, you know, with the with the guy with the sandals.

房间里那位非常资深的工程师真的让我仔细思考我所做的一切。

This this very senior engineer in the room really getting me to think about everything that I'd done.

这对我来说最像和像安德里斯·雷克这样的人一起工作，就是Xstate的那个。

It was the most familiar thing to me to actually working with someone like, Andorist Rake, Xstate.

你知道吗？

You know?

感觉就像一位非常优秀的开发者在问我这些好问题，我当时就想，哇。

It just felt like a really high quality developer was asking me these good questions, and I thought, wow.

好的。

Okay.

然后我开始琢磨，怎么把这个agent用在更多软件基础的东西上？

And then I started sort of taking that and going, like, how do I mine this, agent for more software fundamental stuff?

怎么让它更像一个真正的开发者，一个真正的资深工程师？

How do I make it feel more like a proper developer, a real senior?

怎么去触动它合适的潜在空间，让它的行为改变，用有趣的方式挑战我？

How do I tickle the right latent space in order to get its behavior to change and challenge me in interesting way?

因为如果你能做到这一点，如果

Because if you can do that, if

你能提高和agent对话的质量，你就能提高输出的质量。

you can increase the quality of the conversation you're having with the agent, you're gonna increase the quality of the outputs.

我喜欢grill-me技能的地方在于，它逼我做出决定，我知道该做什么决定，但这是我的决定。

What I liked about the grill-me skill is it forced me to make decisions that I know what decision to make when I think about it, but it is my decision.

所以不像我使用slash goal命令时，比如让它构建这个，它就去做，然后做出所有决定，或者大部分关键决定。

So unlike when I tell the when when you do the slash goal command, like build this, and it goes off and does this and it makes all the decisions or or most key decisions.

我喜欢grill-me的地方是，我既做决定，但有时候它也会提醒我一些我没怎么想过的事情，或者提醒我该做点研究，比如它问我想要哪种认证，是Bearer token还是POST，甚至GET，然后我就想，等等，我得查查这些有什么区别，或者问另一个会话学习一下，所以它让我变得更专业，而且我确实相信，当你和AI合作时，只要我们在学习，我觉得就没问题。

What I like about grill-me is I both make the decision, but also sometimes it it reminds me about things that I didn't think too much about, or maybe reminds me that I should do a bit of a research, for example, like it asked me like which authentication would I want to do, Bare token or over post or even over GET, and then I'm like, hang on, like, I'm gonna look up like what the differences are or ask a different session to educate, so like it it makes me a better professional and I I do have this belief that when you're working with AI, like as long as we're learning, I think we're fine.

只要我们停止学习，把学习这件事外包给这个工具，麻烦可能就在几个月或几年后等着我们了。

As long as we stop learning and outsource the learning to this thing, trouble will be brewing maybe, you know, months or years down the road.

完全同意。

100%.

这里有两件事。

There's two things there.

我觉得大家都低估了智能体的一个方面，就是你和它之间其实存在沟通上的鸿沟。

I think what everybody underestimates about agents, everybody, is that there is a communication gap between you and the agent.

那里有一道屏障。

There is a barrier there.

你会觉得，因为它不是人类，而且你清楚自己的价值观优先级，所以你以为它会自动理解这些。

You feel like because the agent is not a human and because you understand your hierarchy of values, you think that the agent will just pick up on them.

会有一种感觉，就是，对，相信模型就行了，尤其是那些顶级模型。

There's this sort of feeling of, yeah, just trust the model, especially with the top tier models.

你懂吧？

You know?

就只管信任模型。

Just just trust the model.

但是，无论这个代理有多好，无论模型有多聪明，哪怕是神话级别的，它也没法读懂你的心思。

But the agent, however good it is, however smart the model is, you know, even mythos, it can't read your mind.

它没法读懂你的心思。

It can't read your mind.

所以你必须。

So you have to.

必须有一个过程，把你的价值观传达给代理。

There has to be some process of communicating your values to the agent.

因为很多时候，当你设定一个目标，你只是说，好吧，随便给我写点代码，给我点垃圾代码，代理就会产出完全不符合你期望的东西，因为它不理解你觉得什么重要。

Because often when you do it like a goal, when you just go, okay, just spam me out some code, give me some slop, the agent is gonna produce something that's totally misaligned from you because it doesn't understand what you think is important.

所以，仔细询问我不仅关乎实现细节，还关乎确立，好的。

And so grill me is not only about implementation details, it's also about establishing, okay.

做这个。

Do this.

这个在范围内。

This is in scope.

这个不在范围内。

This is not in scope.

这是我觉得重要的东西。

Here's what I think is important.

所以这就是让代理了解你的过程。

And so it's the agent getting to know you.

马特刚才描述了那个“拷问我”技能。

Matt just described the grill-me skill.

我用这个技能设计一个API端点时，它首先问的问题是关于这个端点允许做什么、不允许做什么，以及允许为谁做。

When I used this skill to design an API endpoint, the first questions it asked were about what the endpoint was and wasn't allowed to do and who it was allowed to do it for.

就我而言，我对自己想要什么有清晰的想法，但通常让代理即兴处理认证和授权是个坏主意，因为它们经常这么做。

Now in my case, I had a decent idea of what I wanted, but it's generally a terrible idea to let an agent improvise authentication and authorization as they would often do.

这就引出了我们的资深赞助商WorkOS。

This brings us to our seasoned sponsor WorkOS.

你怎么给AI代理授权？

How do you authorize AI agents?

你面临的问题是如何控制代理的权限范围。

The problem you have is how you want to control the scope of the agent.

棘手的是权限是静态的，但代理要做的事情是动态的。

The tricky part is how permissions are static, but the job of what the agent does is dynamic.

所以团队只能在两个糟糕的选项里选。

So teams pick between two bad options.

要么你读提示，然后手动批准每个工具调用，再读提示，再手动批准，直到最后你干脆不读提示了。

Either you read the prompt, then approve every tool invocation call by hand, and then read the prompt again, then approve by hand again, until you eventually just stop reading the prompt.

要么你就直接放飞自我，让它随便跑，希望代理做的事不会造成不可挽回的后果。

Or you just run-in YOLO mode, letting it rip, and hoping that whatever the agent does is not irreversible.

但其实有更好的办法。

But there's a better way.

WorkOS刚推出了Airlock，这是为代理设计的基于意图的访问控制。

WorkOS just launched Airlock, intent based access control for agents.

你用简单的英语写规则，比如读取仓库、评论PR，任何涉及认证或计费的操作都需要审批，绝不推送到主分支。

You write the rules in plain English, for example, read repos and comment on PRs, anything touching auth or billing needs sign off, Never pushed to main.

代理的每次调用都会根据这个任务来判断，允许、拒绝或转给人工处理。

Every call that the agent makes is judged against this task and allowed, denied, or sent to a human.

每次判断结果都会被Airlock记录下来。

Every verdict is logged by Airlock.

Airlock的妙处在于，没有预先授予的权限范围，也没有需要分配的规则。

The neat thing about Airlock is how there are no pre granted scopes and there are no rules to assign.

任务本身定义了代理能做什么。

The task itself is what defines what the agent can do.

WorkOS Airlock目前处于早期访问阶段。

WorkOS Airlock is in early access.

可以在workos.com/airlock申请。

Request it at workos.com/airlock.

我还想提一下我们的赞助商turbopuffer。

I'd also like to mention our presenting sponsor, turbopuffer.

我和Matt在讨论一个根本性的问题。

Matt and I are discussing a fundamental question.

怎么让智能体记住重要的事情？

How do you get agents to remember what's important?

有个想法：与其构建复杂的记忆系统，不如让智能体直接搜索它的全部历史记录？

Here's an idea: What if instead of building a complex memory system you just let the agent search its entire history?

这看起来会很贵，但用turbopuffer就不会。

This seems like it will be very expensive, but with turbopuffer it isn't.

TurboPuffer的对象存储原生架构意味着，每条源会话记录的边际成本几乎为零，因此索引整个聊天历史非常经济。

TurboPuffer's object storage native architecture means that the marginal cost of source session transcript is almost nothing, making it economical to index the entire chat history.

而且因为turbopuffer的命名空间扩展几乎没有限制，你可以为每个智能体创建专用的搜索索引。

And because turbopuffer namespaces scale virtually without limit, you can create a dedicated search index for every agent.

这里有个很好的例子。

Here's a good example of this.

Entire，这个播客的另一个资深赞助商，索引了数亿条智能体会话记录用于搜索，除非编码智能体需要检索它来回忆某个工程决策是如何以及为什么做出的。

Entire, another seasoned sponsor of the podcast, indexes hundreds of millions of agent session transfers for search and unless the coding agent retrieves what it needs to recall how and why an engineering decision was made.

Entire 展示了他们的代理在使用 turbopuffer 而不是 git 历史和命令行工具时，查找记忆更准确、消耗的令牌更少、耗时也更短。

Entire showed that their agent was more accurate, used fewer tokens, and took less time to find memories when it used turbopuffer instead of git history and a CLI.

代理记忆是一个复杂且不断演变的用例，但也许这里有一个更好的教训。

Agent memory is a complex and evolving use case, but perhaps there is a better lesson here.

也许最好的解决方案就是最简单的那个。

Maybe the best solution is the simple one.

直接搜索所有对话记录。

Just search every transcript.

使用 TurboPuffer，这实际上是可行的。

With TurboPuffer, this is actually possible.

如果你正在尝试解决代理记忆的问题，请通过 turbopuffer.com/pragmatic 联系 TurboPuffer 团队。

If agent memory is something you're trying to solve, then please reach out to the TurboPuffer team at turbopuffer dot com slash pragmatic.

你还创建了哪些其他技能？

And which other skills did you create?

所以从那里开始，我想，好吧，我该如何把那次对话变成代码呢？

So from there, I thought, okay, how do I take that conversation and turn it into code?

我当时立刻就害怕了，因为在那之前我一直在跟模型打交道，你知道，就在它们变得好用之前，在去年十二月那个冬天之前，你知道，事情突然变得特别好。

And I was immediately, scared because I'd been working with models, you know, just before they were good and before the December winter where, you know, things got really good.

所以我之前的工作经验让我感受到了很多限制。

And so I was I felt the constraints from what I'd been working with before.

我知道，比如说，你给智能体提供的上下文越多，它的表现就越差。

I knew that, for instance, the more context you put you give to the agent, the worse it performs.

我知道你请过Dex Horthy上这个播客。

I know you had Dex Horthy on this podcast.

Dex对我影响很大，尤其是他关于“聪明区”和“笨区”的想法。

And Dex, is a really big influence on me, especially his idea of the smart zone and the dumb zone.

聪明区和笨区。

Smart zone and dumb zone.

这个想法简单说一下，这样你就不用去听那期播客了，虽然你应该去听。

So idea of that just to kind of, so you don't have to go and listen to that podcast in full, although you should.

基本上，你给智能体提供的上下文越多，每个词都在争抢注意力。

You have essentially, the more context you give to the agent, every token is shouting for attention.

房间里声音越多，就越难听清重要的声音。

And the more voices you put into that room, the harder it is to hear the important ones.

所以模型开始失去事物之间的联系，并因此犯错。

And so the model starts losing the connections between things and making mistakes because of that.

你可以把这看作是一种缓慢的衰退，但在上下文窗口的某些部分，模型表现更好，某些部分表现更差。

And you can think of that as a slow decline, but there is a portion of the context window where it's better and where it's worse.

所以就有所谓的“聪明区”，目前来说，我认为是前沿模型的前15万个token。

And so you have the smart zone, which is currently, I would say, about the first 150,000 tokens of frontier models.

在100万个token的窗口中。

Of of a 1,000,000 token window.

对。

Yep.

无论窗口大小如何。

Of any any size token window.

无论窗口大小如何。

Of any size token window.

不管上下文窗口多大。

Doesn't matter the context window size.

关键就在于原始的token数量，以及原始的注意力关系数量。

It's all it's all about raw amount of tokens, raw amount of attention relationships.

然后剩下的部分会逐渐变得越来越差。

And then the rest of it will slowly degrade more and more and more.

所以我就开始想，怎么把超过15万token的工作——这其实不算大——拆分成多个上下文窗口、多个会话来完成呢？

And so I started thinking, how do I take work that's bigger than a 150 tokens, which is not very large, and portion it out over multiple context windows, multiple sessions?

这我试了很多次，也折腾了很多不同的方法。

And this took me a a lot of tries, a lot of different fiddling around with different approaches.

Ralph循环就是其中一种版本。

The Ralph loops was one version of that.

Ralph循环的设计就是为了充分利用智能区，因为它们基本上就是给Ralph循环一个目标，然后说，做最小的改动来让我们更接近那个目标，然后清空你的上下文。

Ralph loops are designed to make the most of the smart zone because they essentially just give the Ralph loop a goal, and they say, do the smallest possible change that will get us further towards that goal, and then clear your context.

然后清空上下文，重新开始。

And then clear the context, start from fresh.

没错。

Exactly.

其实你也不是完全从零开始，因为你有代码库。

And you're not technically starting from fresh because you've got the code base.

文件系统和环境里保存了一些状态，但模型本身基本上没有。

There's a little bit of state saved in the file system and in the environment, but not in the model, essentially.

所以这就是那个思路。

So that's the idea.

然后我开始想，怎么把这个RalphLoop的想法变得更稳定一点，然后把它转化成技能。

So I started thinking, how do I take that RalphLoop idea, but make it a little bit more stable and turn that into skills?

后来我意识到，我需要两种不同类型的文档。

And so what I realized I needed was two different types of documents.

你需要一个文档来指明方向，也就是目标文档。

You need a document for where you're going, which is the destination document.

对。

Yep.

我以前管那个叫产品需求文档，现在就叫规格说明。

I used to call that a product requirements document or a spec is what I call it now.

所以这个规格说明就是用来定义什么时候算完成。

So that's the specification that declares when you've reached the end.

然后你需要把那个规格说明拆分成一个个单独的任务，每个会话对应一个任务。

And then you need to break that spec down into individual tickets, one ticket per session.

所以我有一个很简单的技能，就是先写规格说明，再拆任务。

And so I have a very simple skill, just to spec and then to tickets.

然后你把之前那个反复讨论的会话，变成一份规格说明。

And so you take that grilling session that you've had, and you turn it into a spec.

这份规格说明可以覆盖，比如说，三十到四十个任务。

Now that spec can work over, you know, thirty, forty tickets, let's say.

你可以把很大块的工作都挂在这份规格说明下面。

You can have really massive, great big chunks of work that are all tied into that spec.

这就是主要的思路。

And so that's the main idea.

你只需要进行追问，把追问的结果变成规格说明，然后在这些工单上运行某种实施循环，直到完成一大块工作。

You just grill, you turn that grilling into a spec, and then you just run some kind of implementer loop over those tickets until you've got a huge chunk of work.

追问之后，你会得到用户的输入吗，

After grilling, do you get user input,

还是在整个过程中都有，还是说这取决于情况？

as well or throughout this process, or it it depends?

我设计这个主要是为了替用户运行，完全不需要用户在场。

I was mostly designing this to be run for the user, to be away from keyboard totally.

因为有一种概念，就是白班和夜班。

Because there's this idea of, like, the day shift and the night shift.

你听说过这个吗？

Have you heard of this?

没有。

No.

没有。

No.

没有。

No.

那挺好的。

It's great.

基本上，和智能体合作的最佳方式就是白天做计划，晚上让智能体干活。

Basically, the optimal way to work with agents is to plan during the day shift and then get the agents to work during the night shift.

所以，希望早上醒来的时候，你能看到干净漂亮的代码。

And so, hopefully, you wake up in the morning, and you've got beautiful clean code to look at.

这就是我试图优化流程的原因，因为我真的厌倦了以前那种，现在某种程度上还在做的，在终端之间来回切换，不停地切换上下文，就这样。

And that's what I was trying to optimize my process around because I was really sick of what I and and what I still do to an extent of just switching between terminals, context switching all the time, just going.

我想要的，也是我试图优化的，就是先把计划做好，然后让智能体工作几个小时，这样我就可以做其他工作，用大块的时间，比如十五分钟专注做一件事，做计划，然后我再去审查代码，做那些事情。

What I wanted and what I'm trying to optimize for is to just get a good chunk of planning done and then let the agent work for a couple of hours, and then I can do other work, decent chunks of time, fifteen minute chunks working on one thing, planning on stuff, and then I can review the code and do that.

所以，在我做Ralph循环的时候，我一直想优化的就是这个，而我在十二月发现的最重要的事情就是，这些家伙已经足够好，可以委派任务给他们，所以我可以在离开键盘的情况下运行它们。

So that's what I was trying to optimize for all the time when I was doing Ralph loops, and that was the big thing that I found in December is these guys are good enough to delegate to, and so I can run them AFK.

然后你还有另一个技能，叫做“引路者”技能，这个技能更有野心一些。

And then you have a different skill as well, which is a bit more ambitious called the wayfinder skill.

我们能聊聊这个吗？

Can can we talk about that?

当然可以。

Absolutely.

就像我刚才说的，实现部分需要分成多个会话来完成，有时候你在做某个项目时，会遇到瓶颈。

So in this exactly the same way that implementation, I noticed, needed to be split out over multiple sessions, sometimes you're grilling something, and you're you're hitting the limits.

比如你想做一个Stripe的克隆版之类的。

You're gonna grill something, you know, build me a Stripe clone or something.

你肯定会遇到瓶颈的。

You are gonna hit the limits there.

你不可能在15万token的上下文里规划好所有事情。

There's no way you can plan that in a 150 k tokens.

所以我就想，怎么才能把它拆开，让这些会话可以无限长呢？

And so I thought, how do I break that up so that I can run grilling sessions that can be infinite length?

怎么拆分规划，才能让它这样运作呢？

How do I split up grilling so that it can work like that?

所以我就想到了这个主意。

And so I came up with this idea.

我再次考虑信息的流动。

Again, I'm thinking about the flow of information.

基本上，就是，一场拷问会话要表现好需要什么？

Essentially, like, what what does it need to perform well in a grilling session?

它可能需要准确理解这场拷问会话的目的是什么，但也需要了解到目前为止已经决定了什么。

It probably needs to understand exactly what it's, what the purpose of that grilling session is, but it also needs to understand what's been decided so far.

它需要了解当时可能还有哪些其他的拷问会话在进行，于是我想到了一个地图的概念。

It needs to understand what other grilling sessions might be happening at that moment, and I came up with this idea of a map.

这个地图就像是所有决策所需信息的中心点，这些决策是你正在制定的。

And the map would be the sort of center point of everything that was needed for all the decisions that you were coming up with.

一旦你有了地图，你就会意识到，好的。

And once you've got a map, you realize, okay.

就像我在寻找目的地时，有些东西我知道需要决定，有些点就像是地图上的里程碑，而且还有战争迷雾。

There are certain things I can like, as I'm trying to find my way to a destination, there are certain things I know I need to decide, certain points that are kinda like milestones on the map, and there's there's a fog of war.

这个比喻特别好，就一直引导着我设计剩下的技能。

And that that lovely metaphor just sort of carried me through designing the rest of the skill.

因为你有地图，有战争迷雾，你大概知道要去哪儿，每次开一次拷问会议，地图上就会多出一些点，直到你慢慢搞清楚方向。

Because you've got your map, you've got your fog of war, you vaguely know where you're going, and every time you have a grilling session, it opens out more points on the map until you sort of figure out where you're going.

所以这就像一个有向无环图，你沿着它走，直到到达最终目的地。

And so this is kind of like a directed acyclic graph where you're walking down until you reach your final destination.

然后你有地图，每个单独的会议里，地图上都有一些任务卡。

And so you've got the map, and then each individual session in there are tickets on that map.

然后我意识到，好吧。

And I realized, okay.

拷问很好，但如果你需要做原型呢？

Grilling is good, but what if you need to prototype?

如果你需要做研究呢？

What if you need to do research?

如果你需要做一些任意的任务，比如配置一些基础设施之类的呢？

What if you need to do, like, an arbitrary task, like provision some infrastructure or something?

这些就是地图上不同类型的任务，而 Wayfinder 基本上就是引导你完成这个过程。

Well, those are different types of tickets on the map, and wayfinder basically just guides you through this process.

我遇到过一些地图，上面有 50 个、100 个任务，直到我最终到达目的地。

I've had maps that have, you know, 50, a 100 tickets or something until I finally reach my destination.

我其实也用它来做课程规划，就是非技术性的东西，这真的很棒。

I've actually been using it for course planning as well, so nontenical stuff, which is really great.

我还用它来在花园里建一个花园办公室。

I've been using it to build a garden office in my garden.

你知道，很多这些技能，我们会说，好吧。

It's it's you know, a lot of these skills, we we say, okay.

这些对工程来说很棒。

These are great for engineering.

然后你意识到，好吧，工程只是一个学科，我们在这里做什么？

Then you realize, okay, engineering is just a discipline that what are we doing here?

我们只是在讨论一些事情。

We're just discussing something.

我们在现实生活中做的事情，比如浏览网站之类的。

We are doing things in real life, like clicking around websites and stuff.

你会发现这很容易应用到其他领域。

You realize how easily that can map onto other domains.

所以这也许我们可以稍后再谈，我在想这些东西在不同学科和不同生活领域中的可移植性有多强。

So that's kind of maybe we can touch on that a bit later, which is I am thinking how transposable this stuff is into different disciplines and into different areas of life.

所以Wayfinder真的很棒。

So wayfinder has been great.

但如果我们想想工程和软件工程中一个有趣的事情，当Hillel Wayne来播客时，他采访了他认为是真正的工程师的人，化学工程师、机械工程师、土木工程师，试图找出软件工程是否真的是工程学，最后他发现可能是，但他说软件有一个非常不同于其他所有工程专业的有趣之处，就是我们使用的材料。在每个地方，机械工程、土木工程，甚至化学工程，你都有一种材料，它有某种阈值，你不太清楚它具体是什么样，但你知道它大概能承受多少负荷等等。

But if if if we think one interesting thing about engineering and software engineering, when Hillel Wayne was on the podcast, he interviewed, engineers, like, who he thought are real engineers, chemical engineers, mechanical engineers, civil engineers, and to try to find out is software engineering real engineering and in the end he found that it probably is, but he said that one interesting thing with software that is very different to every other engineering profession is the materials that we work In every single place, mechanical engineering, civil engineering, even chemical engineering, you have a material that has a threshold of of things, you don't know exactly what it's like, you know that it'll be like, it can take about this much load, etcetera.

但在软件中，材料就是软件，它就像程序一样工作，我的意思是，去掉不确定性，这可能会让我们更接近工程学，但软件，一段代码，你运行一千次，它一千次都做同样的事情，而在其他领域，情况并非如此。

But in software, the material is software which is it it just works like a program, I mean, take out the non deterministic which which may be brings us to to more engineering, but software, a code, you run it a thousand times and it does the same thing a thousand times, whereas in other fields, it doesn't.

他说他认为这是一个很大的区别。

And he said that that he sees a a big difference.

但现在，我想，随着LLM的出现，也许我们有了这样一个东西，你运行它一千次，它会有这些变体，这是大多数工程领域都有的。

But now, I guess, with LLMs, maybe we have this thing where we have a thing where you run it a thousand times, and it it will have these these variants that most of engineering has.

所以谁知道呢，LLM 能用的东西在其他工程领域是否也有用，毕竟那些领域本来就有这种不确定性，或者我们也可以借鉴其他工程领域的做法，说不定能更好地应对这个叫 AI 的材料。

So who knows if if both what works with LLMs will be useful at other engineering where, again, they already had this variance, or or we can take some approaches from other engineering professions that will maybe work nicely with working with this material called AI.

我完全同意。

I totally agree.

我觉得软件工程有意思的地方，以及为什么智能体适合做这个，是因为所有的输入和输出都是基于文本的。

What I think is interesting about software engineering and the way the reason agents are good with it is it's all the inputs and all of the outputs are text based.

全部都是。

Everything.

所以输入，比如代码、文档、给智能体的指令，全都是文本。

So the inputs, code, documentation, instructions for the agent on what to do, all text based.

输出也是代码、测试套件、类型检查结果、代码检查之类的。

And the output is more code, is, test suites, is type checking results, linting.

这些东西都是文本。

All that stuff is text based.

智能体真正搞不定的，就是那些非文本的东西。

The thing that agents really struggle with is anything that's non text based.

你知道，你会看到那些令人惊叹的演示，人们第一次就能完美地做出一个界面。

You you know, you see these amazing demos of people one shotting a perfect UI first time.

但如果那个界面里存在交互问题呢？

Well, what about if you have an interaction problem in that UI?

比如你悬停在某些元素上，动画看起来不对劲，那怎么办？

What if you're, like, hovering over something and the animation doesn't look right?

你怎么把这个告诉代理？

How are you gonna get that to the agent?

我的意思是，你可以录个视频，我想，然后它会在某些帧上暂停，但说实话，它在视觉方面还不够好。

I mean, you can record a video, I suppose, and it sort of pauses on certain frames, let's say, but it's actually not that good in terms of vision just yet.

所以任何非文本的东西，对代理来说都是垃圾。

And so anything that's non text based is just garbage from the agent.

它根本处理不了。

It just can't handle it.

所以我觉得在这些领域，如果你能把——我猜他们是在做模拟——

And so I think in those sorts of professions, if you can turn I assume they're doing simulations.

我猜他们是在做某种模拟，你知道，我不确定你们有没有那种能检查架构图的代码检查工具。

I assume they're doing some kind of, you know I don't know if you have, like, a linter that can work on architectural diagram.

我相信你们肯定有类似的工具。

I'm sure you have some variety of that.

某种模拟。

Some simulation.

如果你能把那些交互变成文本，如果你能把日常生活中的交互转化成文本——其实大多数本来就是文本——那么智能体就能做得很好。

If you can make that text based, if you can take the interactions that you have in your day to day life and turn them into text, which mostly they are anyway, then the agents are gonna do a pretty good job.

我现在正在尝试做的事情，就是把我用的所有服务都接入智能体。

That's something I'm trying to do currently is take all of the services that I use and plug them into agents.

让它们对智能体可用。

Make them available to the agents.

但是，是的，我们越能让工作对智能体友好，得到的结果就越好。

But, yeah, the more we can make our work agent friendly, the better results we're gonna get.

回到AI整体的话题，然后说说有什么变化。

Circling back to to AI as as a whole and then what has changed.

它改变了很多东西，但AI经常提到的一点，尤其是研究人员和在AI公司工作的人，就是没有先验知识。

Like, it has changed so many things, but one thing that comes up with AI is is often, especially researchers and people working in AI companies, is is no priors.

有了AI，你应该放下以前知道的一切，因为这东西不一样，从零开始，以前的方法可能行不通。

With AI, you should let go of everything that we know before because this thing is different, start from scratch, the approaches might not work.

事实上，我们就假设它们行不通，然后想出新的方法。

In fact, let's assume they don't work and come up with new approaches.

在AI出现之前你是个开发者，而且你真的很在意构建高质量的软件，你觉得AI在多大程度上改变了所有东西，包括那些根本性的东西？

Having been a developer before AI and actually, like, you're like a like, you you were really interested in building quality, software, how much do you think AI has changed of of everything, including the fundamentals?

这也是我思考过的问题。

This is something that I thought too.

我当时想，对。

I thought, right.

AI改变了一切。

AI has changed everything.

我要把洗澡水和孩子一起倒掉。

I'm gonna throw the baby out with the bathwater.

我觉得我们只需要用新的眼光看待一切。

I think we just need to look at everything in a new way.

我开始经常这么做了。

I started doing that a lot.

我特别关注那种规范驱动的开发，你知道的，我对这个词有点复杂的感觉，我觉得它挺奇怪的。

I was especially looking at, like, spec driven developments, you know, which is, I have sort of mixed feelings towards I think it's a strange term.

它涵盖的东西太多了。

It encompasses too much.

然后我想，好吧。

And I thought, okay.

也许英语才是新的热门编程语言。

Maybe English is the hot new programming language.

这就像Capacity Post上一些女性发的帖子一样火了。

Which went viral as some women under Capacity Post did.

没错。

Exactly.

比如说，我可能只需要写一个规格说明，然后这个规格说明会一直保留下来。

Like, maybe I can just write a spec, and that specification is going to be persistent.

它会是我可以编辑的东西，然后让代理在过程中不断修改它。

It's gonna be something I can edit and just get the agent to change it as it goes.

当我尝试的时候，我试了很多次，但结果总是比我自己手写代码要差。

And as I experimented with it, I tried it a lot, and I was just getting worse results than if I'd coded it by hand.

而且也没有变得更好。

And it wasn't getting better as well.

我注意到，每次我运行这个循环，修改规格说明，然后看代码变化，代码就会变得更差。

And I noticed that every time I would sort of run this loop of change the spec, see the code change, the code would get worse.

当然，他不应该看代码，但我看了，那代码简直是一团糟。

He's not supposed to look at the code, of course, but I I looked at the code, and it was garbage.

然后我想，代理怎么能在这里表现得好呢？

And I thought, how is the agent going to perform well in here?

它怎么能行呢？

How is it gonna work?

因为反馈循环对智能体来说太重要了。

Because the feedback loops are so important to the agent.

如果你的测试套件不好，智能体就会像人一样从中得到不好的信号。

If you have a bad test suite, the agent is gonna get bad signal from it just like a human would.

然后我就想，怎么改进测试套件呢？

And I thought, how do I improve the test suite?

怎么才能让这个设置不再每次产出垃圾代码？

How do I get this set up not not, like, churning out garbage every time?

然后我就打开了一本放在书架上的书，第一次拿出来的时候，我觉得它可能还包着塑料膜，那就是《程序员修炼之道》，所有人都让我读这本书。

And I just I opened a book that I had on my shelf that I I think was still wrapped in plastic the first time I took it out, which was The Pragmatic Programmer, which is everyone told me to read it.

每个人都说，你知道的，这是有史以来最好的书。

Everyone like, you know, everyone said, you know, this is the best book ever.

你刚拿到它。

You just got it.

我买了它，但出于某种原因没读。

And I bought it, and I didn't read it for some reason.

然后我翻开那本书，里面有一整章，整整一节都在讲软件熵。

And I opened it, and it had a whole chapter, a whole section on software entropy.

软件熵这个概念就是说，熵意味着事物趋向于更加无序的状态，这比它们趋向有序更常见。

And software entropy is the concept that, you know, entropy is the idea that things go towards a more disordered state, that that is more likely than them going into an ordered state.

我意识到，好吧，软件熵是不可避免的。

And I realized, okay, software entropy is inevitable.

我在这里看到的是，智能体正在以前所未有的速度制造软件熵。

What I'm seeing here is that agents are producing software entropy at a higher rate than ever.

然后我开始更仔细地看那本书，几乎每读一行，我都觉得，哇。

And I started looking more into that book, and almost every line I read, I thought, wow.

感觉这本书就像是为今天写的。

This feels like it was written for today.

你懂吗？

You know?

你应该回头看看那本书，那些想法，比如，不要超出你的车灯范围。

You should go back to that book, these ideas of, like, don't outrun your headlights.

始终在你的反馈循环内工作。

Always work within your feedback loops.

巧合编程。

Programming by coincidence.

曳光弹。

Tracer bullets.

这么多聪明的想法。

So many smart ideas.

我意识到这本书已经出版了二十五年。

And I realized this book has been out for twenty five years.

这很可能在代理的先验知识里。

This is probably in the agent's priors.

也许我只要提一下这些概念，尤其是那些特别精辟的，比如曳光弹，这个想法就是你应该总是很快地得到关于你正在做的工作的反馈。

Maybe if I just mention some of these concepts, especially the ones that are really pithy, like tracer bullets, for instance, which is the idea that you should always get feedback really quickly on the work that you're doing.

我想曳光弹的想法是，对，就像曳光弹会留下痕迹，你实现一条路径，就像软件的一个重要部分，而不是先建数据库层、应用层，还有我不知道什么层，把三层都建好然后再拼在一起。

I guess the idea of the tracer bullet is, right, that you like like a tracer bullet that leaves a a mark, you you implement a path that works like like an important piece of the software instead of like building a database layer and the application layer and the I I don't know whatever layer, building all three and then putting them together.

就是说，每一层都只做一部分，但要让它们能协同工作。

Like, just build one part of each, but they should work together.

这正是我在智能体上看到的问题。

That was the problem I was seeing with agents.

你让它构建一个软件，即使有反馈循环，它也会先建好整个数据库，然后在上面建整个应用层，再建整个React组件库。

They would you would get it to build a piece of software, even with Ralph loops, and you would it would build the entire database, and then it would build the entire application layer on top of that, then it would build the entire React component library.

直到最后才开始真正把各部分连接起来，并获取关于它正在做什么的反馈。

Only at the end would it start actually plugging things together and getting feedback on what it was doing.

这让人抓狂，因为数据库里的东西会影响你在前端显示的内容。

And it was maddening because things in the database, like, will affect what you show on the front end.

你知道吗？

You know?

只有当你看到它跨越这些集成层时，你才能真正知道事情是否合理。

You only really know whether things are actually making sense when you see it crossing those integration layers.

所以另一个概念是垂直切片。

And so another concept is vertical slices.

与其在这些不同的部署单元之间做横向切片，不如做一个纵向切片，这样它就能立刻得到反馈，然后从那里开始构建。

Instead of these horizontal slices across these different deployable units, you have a vertical slice where it gets feedback on what it's doing straight away and builds out from there.

所以我就开始在提示词里用这些说法跟智能体对话，然后我注意到它也开始用这些说法回应我。

And so I just started using these phrases in my prompts when I was talking to the agent, and I started noticing that it was saying those phrases back to me.

它会把我说的话重复回来。

It was repeating them back to me.

它会说，好的。

It was saying, okay.

我会把这个变成一个可追踪的东西。

I'll turn this into a traceable.

因为这是可追踪的，所以我会这么做。

Because this is a traceable, I'll do this.

它在我自己的推理轨迹里用了我用的那些词。

It was using the words that I was using in its own reasoning traces.

这就是我所说的引导词，或者说一个关键词，算是一个比较文雅的文学术语吧，就是你用一个简单的短语，在技能或提示词里重复几次，来引导智能体改变它的行为。

And so this is what I call a leading word, a leitwert, let's say, which is a sort of fancy literary term, where you lead the agent just with a simple phrase that you repeat a couple of times in the skill or the prompt to change its behavior.

所以“可追踪”这个词真的很棒，然后我就开始翻各种书，能找到的都翻，想从中挖出更多这样的引导词。

And so traceable ist was a fantastic one, And I just started diving into different books, all the books I could find to try to mine them for leading words.

还有一本是John Ousterhout的《软件设计的哲学》，我从里面学到了很多好东西，比如“深模块”，这个概念对我影响特别大。

And another one was John Ousterhout's book, Philosophy of Software Design, where I picked up tons of great stuff like deep modules, is which is a massive one for me.

有意思的是，这些智能体可能早就被那些书训练过了，那些书还在出版，当然也有人争论它们到底拿这些书做了什么，但如果这些书在它们的训练数据里，而且智能体在训练过程中把这些概念都串联起来了，那么，这些引导词就能唤起那些概念。我在想，这是不是跟你在某个话题上跟专业人士聊天很像——你作为外行想描述你想要的东西，然后你说了一个词，那个词就起到了作用，另一个专业人士立刻就明白了。

It's interesting to consider if these agents have always been trained on those books, just still available for for print and of course there's arguments of like what they're doing with those books or whatnot, but if it's in their training data and and and the agents as they're trained, they connect all these different concepts and yeah, the these, I guess, how do leading words could invoke those concepts, and I wonder how if this is much different to when on a topic you talk with a professional and you're trying to describe as an amateur what you want to the professional that says a word that does that and a fellow professional gets it.

你知道，这就是行话。

And you know this is jargon.

行话这东西，一方面，当你刚加入一家公司时，满耳朵都是行话，确实不太友好，但我们用它就是因为它能让我们更快、更轻松、更少误解。

And and jargon, on one end, it's it's not very inviting when when you join a company and there's jargon, but it just we use it because it makes things faster, easier, fewer misunderstandings.

确实。

Definitely.

这个想法也启发了我，因为很明显，这些引导词就在智能体的先验知识里，对吧，比如“曳光弹”之类的。

That was something that idea led me to because, obviously, you've got these leading words that are in the agent's priors, right, like tracer bullets, all that stuff.

那怎么描述我的应用程序呢？

What about describing my application?

那描述我的代码呢？

What about describing my code?

怎么让智能体……因为我觉得智能体实在太啰嗦了。

How do I get the agent to because what I the agents are just awfully verbose.

尤其是Opus 5，不知道为什么，大家都说那个模型话多，确实如此。

Especially Opus five, for some reason, and people really go after that model for being verbose, and it really is.

我就想，怎么让它少说点话呢？

And I thought, how do I get it to be less verbose?

怎么才能让我和智能体之间有一种共同语言，这又是沟通障碍的问题。

How do we start talking a common language between me and the agent, this communication barrier again?

这让我想到了DDD，领域驱动设计。

And it led me to DDD, domain driven design.

Eric Evans那本了不起的书，里面讲到了通用语言，这种语言在智能体的知识里根深蒂固，它理解得很好。

Eric Evans' incredible book where he talks about ubiquitous language, a language, again, really deep in the agent's prize and understands it really well.

我开始试着稍微改一下grill-me，因为grill-me是个很简单的技能。

I sort of started toying with the idea of maybe changing grill-me a little bit, because grill-me is a very simple skill.

但如果我们一边头脑风暴，一边思考要构建的应用，同时也在构建一种领域语言呢？

But what if we while we were ideating, while we were thinking about the application we were gonna build, what if we were also building a domain language?

如果我们也在决定使用哪些正确的术语呢？

What if we were also deciding on the right terms to use?

这就变成了一个叫“grill with docs”的技能，这个名字起得不太好，它基本上就是边做边创建这种领域语言。

And this turned into a skill called grill with docs, which is a terribly named skill, it's essentially creates this domain language as you go.

如果你让代理使用这种领域语言，效果是天壤之别。

And if you get the agent to use the domain language, the difference is night and day.

因为突然之间，你们说的是同一种语言。

Because suddenly, you're speaking the same language.

你描述想改的东西时，用的词会少很多。

You're able to describe your the things you want to change in so many fewer words.

比如，我有一个我一直在弄的应用。

Like, I had this app that I sort of work on.

里面有个复杂的交互，涉及幽灵课程和真实课程。

There's this complicated interaction where there are ghost lessons and real lessons.

那当你把一个幽灵课程里的幽灵章节里的幽灵课变成真实课时，会发生什么？

And what happens when you turn a ghost lesson that's inside a ghost section inside a ghost course into a real lesson?

这意味着幽灵章节需要变成真实的，幽灵课程也需要变成真实的。

That means the ghost section needs to become real, the ghost course needs to become real.

你怎么解释这个？

How do you explain that?

嗯，这就是所谓的“实体化级联”。

Well, that's the materialization cascade.

这些术语是你想出来的？

And you came up with these

术语？

terms?

是和智能体一起想出来的。

With the agent.

智能体其实很擅长想出这些术语，所以我有一个领域建模的技能。

The agent's actually really good at coming up with these terms, and so I have a domain modeling skill.

我们说的是行话，但其实这就是领域语言。

And we talk about jargon, but, really, it's domain language.

如果你能把这一点融入进去，不仅融入你谈论应用的方式，还融入应用代码本身，那你就有了一个很好的基础。

If you can integrate that and integrate that not only with the way you talk about the app, but the app code itself, then you've got a stew going.

这真的非常令人兴奋。

Like, it's very, very exciting.

而且这意味着智能体可以更容易地浏览你的代码库。

And it means that the agent can navigate your code base a lot easier.

它可以通过简单的搜索找到提到特定领域术语的函数。

It can find the functions that mention that specific domain terminology, you know, just with a simple grep.

这简直太棒了。

It's just gorgeous.

所以，这就是我一直在我的每个设置中整合的东西，就是领域驱动设计。

So that's that's something I've been really integrating with every part of my setup is DDD.

但这真的很有趣，因为为了让这些智能体更高效地工作，或者执行工作流，从而让你能生产出更少错误、更好的软件，你开始回溯历史，找到了这本书，现在它大概有二十、三十、四十年了吧，而且你甚至还在继续回溯，找到一些跳跃，我相信某个时候你会提到《人月神话》。

But this is so interesting because in an effort to make these agents work more efficiently or do workflows that just mean that you can produce better software with fewer mistakes and and these things, you start to go back in time, found this book that is now, I think, what is it, like twenty, thirty, 40 years old, And and you you're even still going back and finding jumps from as I'm sure at some point you'll get to mythical man month.

我已经有了。

I've I've got it already.

当然。

Absolutely.

现在已经超过五十年了。

Which is now more than fifty years.

你在努力找到合适的词来描述事物，这很有意思，因为我和Kent Beck聊过，他们和Ward Cunningham一起编程时，正在提出领域设计模式的概念，他们桌上放着一本词典，会翻来翻去，想找到那个意思最贴切的词。

And you're trying to find the right words to describe things, which is very curious because when I talked with Kent Beck on how they used to program with Ward Cunningham, as they were coming up with the concept of actually just domain design patterns, they had a thesaurus with them and they would look through trying to find the right word that is that has the right meaning and they had it on their desk.

现在感觉我们又回到了根本，回到了人们一直在问的那些问题，时不时有人把这些写进书里，像智慧一样传播开来，而现在我们又回到了起点，你要教的就是那份智慧。

Right now this feels we're going back to the the fundamentals, the how that that people have been asking themselves and and every now and then people write it in books and it kind of spreads as as wisdom, and now we're back to where we started, which is what you're trying to teach is the wisdom part.

这太不可思议了。

It's wild.

因为AI和人类太不一样了，你需要去优化它。

Like, because AI is so different to humans, you need to optimize it.

想象一下，你有一个人类，每天早上醒来都不记得自己是谁。

Imagine you essentially had a human who wakes up every morning and cannot remember who they are.

就像《记忆碎片》里的那个人。

The guy from Memento.

你懂吧？

You know?

这就是“记忆碎片驱动开发”。

This is Memento driven development.

我们是在为新人优化我们的代码库。

We are trying to optimize our code bases for new starters.

所以我们想打造一个前所未有的健康代码库。

So we're trying to have the most healthy code base that we've ever had.

因为如果是人，就算代码库很烂，也能凑合着用。

Because if you a human can work around a bad code base.

他们只是会形成记忆。

They just develop memory.

他们就是一次又一次地撞墙，直到最后搞明白。

They just slam their head against the wall again and again and again until they've got there.

但是智能体做不到这一点。

But an agent can't do that.

它每次会话都是从头开始的。

It starts fresh every single session.

所以你需要为它优化你的代码库。

And so you need to optimize your code base for that person.

这会带你进入一些非常有趣的领域，而且事实证明，软件工程的基本原则一直在说，我们一直都在努力做到这一点。

That leads you down into really interesting parts, and it turns out that software fundamentals have been saying we've been trying trying to do that for the entire time.

我完全，怎么说呢，被埃里克·埃文斯那套理论深深影响了。

I am fully, like, I don't know, Eric Evans pilled.

我完全被软件工程的基本原则深深影响了。

I'm fully, like, software fundamentals pilled.

我们有点在改变规则，但也许我们只是在强调那些我们知道自己应该遵守、但可能没有遵守的规则。

We are sort of changing the rules a little bit, but maybe we're just emphasizing rules that we knew we were supposed to do, but maybe we didn't.

我觉得这真的非常吸引人，而且绝对很有趣。

And I find that really fascinating, and it's definitely a lot of fun.

现在，好吧，我觉得顺着这个思路，很容易理解为什么基础很重要，但到底是哪些基础呢？

Now, okay, like, I think it's easy enough to follow with this train of thought why fundamentals matter, but which fundamentals?

如果我是一名工程师，尤其是那种一直埋头写代码、比较注重战术层面的编码的人，我该怎么去找到那些重要的基础，然后回过头来，你发现哪些方法是有效的？

And if I'm an engineer, especially maybe someone who has been just kind of, like, heads down coding, more tactical coding, how do I go about and find those fundamentals that matter and and go back to what have you found work?

这真的是个很难的问题。

This is really tough question.

这真的很难，因为战略性编程一直很难学。

It's really tough because strategic programming has always been really hard to learn.

原因在于它的反馈周期非常长。

The reason for that is that the feedback loop on it is really long.

你经常会发现，有些人干了六个月就辞职了，他们的战略错误根本不会追上他们。

You would often find, like, people who, quit their jobs after six months, their strategic mistakes never catch up with them.

也许那个战略错误要九个月后才会回来找你。

Maybe that strategic mistake takes nine months to come back at you.

我觉得学习战略性编程就像你面前有一个巨大的调音台，上面有很多不同的推子。

I think of strategic learning strategic programming as kind of like you've got a huge mixing desk in front of you with loads of these different sliders.

也许其中一个滑块就是你可部署的单元数量。

Maybe one of those sliders is, like, the amount of deployable units that you have.

把它调高，你就有更多的微服务。

You turn it up, you've got more microservices.

把它调低，你就得到单体架构。

You turn it down, you've got a monolith.

你怎么做这个决定？

How do you make that decision?

你把那个滑块放在哪里？

Where do you put that slider?

因为这就像你在调音，在混音，但你要等到九个月后才能听到哪里出了问题，对吧，直到错误找上门来。

Because it's kind of like you're mastering something, you're mixing some music, but you can't hear what's wrong until nine months later, right, until the mistakes come and get you.

所以我认为唯一能加快这个反馈循环的方法就是行动更快。

So I think the only thing that can make that feedback loop faster is moving faster.

现在AI让你能行动得更快。

AI now lets you move faster.