了解 Warp 如何设计出一种简单的开发模式，让任何人都能构建自我改进的智能体。
Category [Agents](https://claude.com/blog/category/agents)Product [Claude Platform](https://claude.com/platform/api)Date August 26, 2026Reading time 7 minShare [Copy link](https://claude.com/blog/how-warp-builds-self-improving-agents-on-claude#)https://claude.com/blog/how-warp-builds-self-improving-agents-on-claudeAuthor(s) Michael Segner
在我们的系列文章中，我们重点介绍初创公司如何利用 AI 改造其所在行业。在本文中，我们分享 Warp 如何将无状态的用户反馈转化为其智能体的自我改进循环。
| 快速概览 |
|---|
| 公司名称 |
| 成立时间 |
| 创始人 |
| 技术栈 |
| 增长情况 |
智能体需要可靠且高效地处理重复性任务。一个首次提示词只能完成 80% 任务的智能体，会给用户带来嘈杂且令人烦恼的体验。Warp 在这方面吃了不少苦头，并以此为依据制定了产品策略，为全球近 100 万开发者带来了更优质的体验。
Warp 是一款 AI 驱动的终端和智能体开发环境，构建在 Claude 平台之上。该团队在其内部代码审查智能体上遇到了这个“嘈杂体验”的问题。工程师们抱怨他们的智能体会发表无用的评论，并产生低质量的输出。
团队最初尝试了一些临时解决方案，比如根据观察到的代码审查失败情况手动重写提示词。这使输出更可用，但无法规模化。改进 AGENTS.md 等上下文文件也有帮助，但远非完整的解决方案。
最终，他们意识到，真正的问题在于：无论反馈的目的是什么，反馈给智能体的信息通常会在会话结束时消失，从而从智能体循环中移除了关键上下文。他们的解决方案是：一个基于 Agent 技能（Skills）的框架，用于创建自我改进的智能体，让反馈随时间不断累积，持续优化和增强智能体的输出。
继续阅读，了解他们如何利用 Claude 平台之上的技能（Skills）构建这一系统。
基于技能构建的智能体自我改进循环
核心技术是一个利用技能（Skills）的自我改进循环。技能是基于文件的知識编码，将指令从原始提示词中分离出来。Warp 演进了一种由两个技能组成的自我改进智能体架构，中间穿插人工反馈。
内部/基础技能持有功能性领域知识和指令。例如，当有 PR 被创建时，Warp 的代码智能体会使用该基础技能和上下文来执行并生成审查意见。
人类对智能体输出的反馈是自我改进循环中的关键组成部分。就代码审查而言，反馈可以简单到只是一个点赞，但反馈越具体明确，效果就越好。
“人类可以确认，‘这是一条很好、很有用的评论’，”Warp 创始人 Zach Lloyd 解释道，“但人类也可以给出详细理由，说明某次代码审查为什么不够好。像‘你建议重命名这个变量，但我们代码库的约定是这类全局变量使用这种特定的命名语境’这样的具体细节，能告诉智能体下次该怎么做才对。”
外层/改进者技能（improver skill）充当一个观察者智能体，它按计划运行，而不是按任务运行。它会汇总积累的人类反馈，将智能体的建议与人类的回应进行对比，然后对基础技能提出一处小而聚焦的修改。
由于技能就是普通文件，智能体非常擅长更新它们。这些更新是可审查、可批准、可合并的，能够通过常规的 PR/代码审查流程流转；一旦合并，内层技能的下一次运行就会继承这项改进。
Warp 目前已在整个开源仓库中运行这一模式，分别设有专门的规范编写、审查和分诊智能体，每个智能体都带有各自的自我改进循环。
“基于文件的技能是一种为智能体编码知识的方式，无需把这些知识直接放进提示词里，智能体可以在执行任务的过程中随时查阅，”Zach 表示。“这个框架其实非常简单：有一个基础的领域专用技能，然后有一个改进者技能来优化那个领域专用技能。这种简洁性正是该方法的精妙之处。”
如何为智能体编写自我改进的技能
以下是 Warp 团队在编写智能体循环的自我改进技能方面总结出的一些经过验证的实用建议：
- 写原则，而不是写规则。“构建技能时，要像在指导一个聪明人那样，而不是像在给计算机编程，”Zach 说。“在技能中加入‘寻找重复代码’这样的方向性指引，比罗列详尽的变量命名规则能提供更好的指导。”
- **解释“为什么”。** 给出规则背后的理由，能让智能体对问题进行推理，而不是死板地遵循指令，这同样有助于实现更好的泛化。
- 让反馈的给出变得毫不费力。在人们已经工作的场景中捕捉反馈，比如直接在 PR 或 issue 上评论。同时，让这一过程自动发生，无需额外的提交步骤。“低摩擦是保持信号流动的关键，”Zach 指出。“如果你把门槛设得太高，你就得不到反馈，也就无法改进技能。”
- 保持技能小巧，并采用渐进式披露。一个好的技能文件并不大；它引用资源文件和脚本，而不是一次性把所有内容都塞进上下文。
- 反馈质量 > 数量，但数量也有帮助。来自资深工程师的少量、详细且领域特定的反馈，可能比大量草率的反馈更有价值，因为简单的点赞/点踩并不能说明原因。“即使样本量相对较小，只要反馈来自对领域特定知识有深入了解的人，而这些知识是智能体本身无法获取的，你就能获得非常好的信号，”Zach 继续说道。“话虽如此，高质量信号的语料库越大越好。在 Warp，我们用一个循环来管理整个开源仓库。我们有数百人参与贡献，并且我们正在进行数千次代码审查。”
- 在改进者技能上投入更多精力。在编写改进者技能（观察者智能体）上投入更多精力，其回报会超出当前的智能体循环本身，因为改进者技能在不同用例中具有很高的可复用性。“除了领域特定知识的部分，这是一个相当可复用的机制——代码审查智能体的改进者技能，与其他任何智能体的改进者技能并没有太大区别。”
循环的实际应用：Warp 的 issue 分类智能体
Warp 的 issue 分类智能体展示了自我改进的智能体技能框架。每当有人提交新的 GitHub issue 时，该模式就会被触发：一个 GitHub Action 启动一个智能体，分析 issue 的复杂度和可行性，分配标签，并提出修复方向的建议。该分类智能体运行在一个内部技能文件之上，该文件包含关于每个标签含义以及如何在行动前研究代码库的领域知识。
在一个示例 issue 上，第一阶段的内部技能表现不错，但漏掉了一个标签——“ready to spec”，该标签表示贡献者可以开始针对该 issue 编写产品和技术规格。Warp 团队的一位维护者发现了这个缺口，并直接在 issue 上留下了反馈，恰好就在工作发生的地方。关键在于，他既解释了他的期望，也解释了为什么有这样的期望：这种可操作的反馈便于智能体日后吸收。
外部改进技能运行在 Warp 的智能体编排平台 Oz 中，作为一个定时执行的“更新分类”智能体。该智能体通过 GitHub 认证，运行技能附带的 Python 脚本拉取带有反馈的近期 issue，将其汇总为 JSON 文件，然后读回上下文中。附带的脚本本身就是一种最佳实践；技能可以引用资源文件，而不是每次运行时都编写新代码。
接下来，智能体识别了维护者评论中的具体反馈信号，并提出了能够捕捉这些信号的最小修改。它开启了一个 PR，编辑内部技能，使其在 issue 描述了一个真实问题（即使具体的 UI 或 UX 形态尚未定义）时应用“ready to spec”标签。
由于整个更新就是一个技能文件，它走的是正常的代码审查流程。PR 附带了一个描述，说明哪些信号促使了这次变更以及它改变了什么。由人工进行审查、批准和合并，下一次分类技能运行时就会继承新知识。这最后的人工步骤闭环了整个流程，并确保人对实际发生的变化保持掌控。
这正是 Warp 现在在其开源仓库中大规模运行的机制——规格编写智能体、审查智能体和分类智能体各自携带自己的自我改进循环。
任何智能体，无论其任务是什么，只要从一开始就构建这样的循环——捕捉人类反馈信号、将其转化为技能更新、把智能体从一次性助手扩展为能在整个组织中持续积累能力的系统——它就会随着时间推移不断进步。
| Warp 团队的最佳实践 |
|---|
| 你是否混淆了技能与记忆？ |
| 你需要一个改进循环，还是每个智能体各一个？ |
| 当反馈本身是错误的时候会发生什么？ |
| 你的领域是否可验证？ |
| 如果领域不可验证呢？ |
| 你如何知道整个系统正在改进？ |
观看完整网络研讨会，观看现场演示并深入了解 Warp 如何使用 Claude 构建能够从团队反馈中学习并随时间自我改进的智能体。
立即使用 Claude 平台开始构建。
Learn how Warp devised a simple development pattern that anyone can use to create self-improving agents.
Category [Agents](https://claude.com/blog/category/agents)Product [Claude Platform](https://claude.com/platform/api)Date August 26, 2026Reading time 7 minShare [Copy link](https://claude.com/blog/how-warp-builds-self-improving-agents-on-claude#)https://claude.com/blog/how-warp-builds-self-improving-agents-on-claudeAuthor(s) Michael Segner
In our series, , we highlight how startups are transforming their industries with AI. In this article, we share how Warp turned stateless user feedback into a self-improvement loop for its agents.
| The quick pitch |
|---|
| Name |
| Founded |
| Founders |
| Stack |
| Growth |
Agents need to handle recurring tasks reliably and effectively. A first-pass prompt that gets 80% of the task correct can create a noisy and annoying experience for the user. Warp learned this the hard way, and used this to inform its product strategy, creating an improved experience for nearly 1M developers worldwide.
Warp, the AI-powered terminal and agentic development environment, builds on the Claude Platform. The team ran into this “noisy experience” problem with their internal code review agent. Engineers complained that their agent made unhelpful comments and produced low-quality output.
The team initially tried stopgap solutions, like manually rewriting the prompt based on observed code review failures. This made output more usable but didn’t scale. Improving context files like AGENTS.md also helped, but was far from a complete fix.
Ultimately, they realized, the real issue was that feedback to an agent, no matter what its purpose, typically disappears when the session ends, removing critical context from the agentic loop. Their solution: an Agent Skills-based framework to create self-improving agents where feedback compounds over time to continually refine and enhance agent output.
Read on to learn how they built it with skills on top of the Claude Platform.
Agent self-improvement loops built on skills
The central technique is a self-improvement loop using skills, which are file based encodings of knowledge that keep instructions out of the raw prompt. Warp evolved a self-improving agent architecture consisting of two skills, with human feedback in between.
The inner/base skill holds the functional domain knowledge and instructions. For example, when a PR is opened, Warp’s code agent executes using that base skill and context to produce its review.
Human feedbackon agent output is a critical component for the self-improvement loop. For code review this could be something as simple as a thumbs up, but the more explicit the better.
“A human could affirm, ‘this was a good, useful comment’,” Warp founder Zach Lloyd explains, “But the human could also give detailed reasons why a code review wasn't good. Specifics like ‘you suggested renaming this variable, but our code base convention is this type of global variable uses this particular naming context’ tell the agent how to do it right next time.”
The outer/improver skill functions as an observer agent that runs on a schedule rather than per-task. It pulls the accumulated human feedback, compares what the agent suggested against how humans responded, and proposes a small, focused edit to the base skill.
Because skills are plain files, agents are extremely good at updating them. These updates, which are reviewable, approvable, and mergeable, can flow through a normal PR/code-review workflow; once merged, the next run of the inner skill inherits the improvement.
Warp now runs this pattern across its entire open-source repo, with separate spec-writing, review, and triage agents, each carrying their own self-improvement loop.
“File-based skills are a way of encoding knowledge for agents without putting that knowledge directly in the prompt, as something the agent can simply look up in the course of doing its job,” says Zach. “The framework is really simple actually: there's the base domain-specific skill and then there's the improver skill that refines that domain-specific skill. This simplicity is the beauty of this approach.”
How to write self-improving skills for agents
Here are some of the Warp team’s tried and true tips for writing self-improving skills for agentic loops:
- Write principles, not rules. "Construct the skill as though you're instructing a smart person, not like you're programming a computer,” Zach says. “Including direction in the skill like ’Look for repeated code’ provides better direction than exhaustive variable naming rules.”
- **Explain the why.**Providing the rationale behind the rule lets the agent reason about the problem instead of following rigid instructions, again allowing for better generalization.
- Make feedback effortless to give. Capture it where people already work, like by commenting directly on a PR or issue. Also, make this happen automatically, with no extra submission step. “Low friction is what keeps signal flowing,” Zach notes. “If you make it too hard you're not going to get the feedback and you're not going to be able to improve the skill."
- Keep skills small and use progressive disclosure.A good skill file isn't large; it references resource files and scripts rather than dumping everything into context at once.
- Feedback quality > volume, but volume helps. A small amount of detailed, domain-specific feedback from a senior engineer can be worth more than lots of cursory feedback because binary thumbs up/down doesn't say why. “You can get really good signal even from a relatively small sample size if it's very detailed feedback from a person around domain specific knowledge that the agent otherwise would have no way of getting,” Zach continues. “That said, the bigger the corpus of quality signal, the better. At Warp we're using a loop to manage our whole open source repo. We have hundreds of people contributing and we're doing thousands of code reviews.”
- Put extra effort into the improver skill. Putting extra effort into writing the improver skill (the observer agent) pays off beyond the immediate agent loop, because improver skills are very reusable across different use cases. “Outside of the domain specific knowledge component, this is a fairly reusable mechanism—the improver skill for a code review agent is not that different from the improver skill for any other agent.”
The loop in action: Warp’s issue triage agent
Warp’s issue triage agent demonstrates the self-improving agent skills framework. The pattern is triggered whenever someone files a new GitHub issue: a GitHub Action fires an agent that analyzes the issue for complexity and feasibility, assigns labels, and suggests a direction for the fix. That triage agent runs off an inner skill file holding the domain knowledge about what each label means and how to research the codebase before acting.
On a sample issue, the first-stage inner skill did a solid job but missed one label, ready to spec, which signals that a contributor can start building product and technical specs against the issue. A maintainer on the Warp team caught the gap and left feedback directly on the issue, exactly where the work was happening. Critically, he explained both what he expected and why he expected it: actionable feedback easy for the agent to absorb later.
The outer improver skill runs in Oz, Warp's agent orchestration platform, as a scheduled “update triage” agent. The agent authenticated to GitHub, ran a Python script bundled with the skill to pull recent issues carrying feedback, summarized them into a JSON file, and read that back into context. The bundled script is itself a best practice; skills can reference resource files instead of writing fresh code on every run.
From there, the agent identified the concrete feedback signals in the maintainer comments and proposed the smallest edit that captured them. It opened a PR editing the inner skill to apply the "ready to spec" label when an issue describes a real problem, even though the exact UI or UX shape is not yet defined.
Because the whole update is a skill file, it moves through the normal code-review workflow. The PR arrived with a description explaining which signals prompted the change and what it altered. A human reviews, approves, and merges, and the next run of the triage skill inherits the new knowledge. That final human step closes the loop and keeps a person in control of what actually changes.
This is the same mechanism Warp now runs at scale across its open-source repo, where spec-writing agents, review agents, and triage agents each carry their own self-improvement loop.
Any agent, no matter what its task, gets better over time if you build one of these loops into it from the start to capture human feedback signals, turn them into skill updates, and expand agents from one-off helpers into capable systems that compound across your org.
| Best practices from the Warp team |
|---|
| Are you conflating skills with memory? |
| Do you need one improver loop, or one per agent? |
| What happens when the feedback is wrong? |
| Is your domain verifiable? |
| And if it isn't domain verifiable? |
| How do you know the whole system is improving? |
View the full webinarfor a live demo and deeper discussion of how Warp uses Claude to build agents that learn from team feedback and improve themselves over time.
Start building with theClaude Platformtoday.