# Loops & Harnesses: Why The Best AI Engineers Stopped Writing Prompts
**作者**: Rahul
**日期**: 2026-07-18T06:33:35.000Z
**来源**: [https://x.com/sairahul1/status/2078367561453101097](https://x.com/sairahul1/status/2078367561453101097)
---
Two of the most senior AI engineers alive said the same thing last month.
Peter Steinberger, creator of OpenClaw, now at OpenAI:
"You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."
Boris Cherny, head of Claude Code at Anthropic:
"I don't prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops."
Most people read that and thought: what does that actually mean?
And more importantly: how do I build one?
This article tells you exactly how.
# The way most people use AI is already outdated
Write prompt. Wait. Read output. Fix it manually. Write another prompt.
You are the loop.
Every step runs through you. The AI waits. You decide. The AI waits again.
The moment you stop, everything stops.
The builders moving fastest in 2026 are not writing better prompts.
They are building systems that do the prompting for them.
The leverage point has moved.
From typing prompts → to designing loops.
# What a loop actually is (Define this before we go further)
A prompt is a question.
You ask. The model answers once. Done.
A loop is a job.
The agent keeps working, checks its own progress, and keeps going until the task is actually finished.
Not until it generates an answer.
Until it reaches a verified outcome.
That repeat-until-done cycle is the loop.
And it is the engine inside every AI agent you have ever used.
Claude Code. Cursor. Codex.
Underneath, they all work the same way:
→ The agent calls a model
→ The model picks an action
→ The action runs
→ The result goes back to the model
→ It repeats until the goal is met
The loop is what makes an agent an agent instead of a single reply.
In every one of those tools, the loop is fixed and hidden.
You do not get to open it. You do not get to change how it works. You get whatever the tool decided the loop should be.
That is about to change.
# Program by Slate (Next stage of Loops)
Slate is a CLI for running AI agents that actually fan out. Instead of one assistant working through a task step by step, Slate spins up independent threads that run in parallel.
Programs let you author your own agent workflows: pick any model per task, give the agent real software to use, and control the loop yourself rather than relying on a black-box “managed agent.”
A Program is that loop — except it is written in JavaScript and Slate runs it for you.
You decide:
→ What happens on each step
→ Which model handles which step
→ What the loop checks before it continues
→ When it stops
So a loop is the idea — keep working until done.
A Program is how you build one in Slate
If you can describe the steps, you can build the loop.
Think of it like Minecraft.
Minecraft doesn't give you a fixed path through the game.
It hands you blocks and says: go build whatever you can picture.
Programs work the same way.
Here are the blocks you can wire together:
→ A goal input — define the objective and success rubric
→ A planner — researches and breaks the job into steps
→ Worker blocks — execute each step
→ Verifier blocks — check execution without bias
→ The loop itself — runs for each step, repeats until the goal is met
→ Model selection — cheap fast model for easy steps, frontier model for hard thinking
→ State — persistent memory across sessions
→ Stop conditions — how the program knows when to exit
Once a few blocks work together, Slate can self-diagnose the program and add more blocks.
The loop gets smarter over time.
# Why this matters: any model, any step
Inside a single Program, you can use any model on any step.
A cheap open-weight model for sorting through files.
A stronger frontier model for the hard reasoning.
Whatever fits the step.
This includes open-source models.
Most agent tools lock you to one model for everything.
Programs don't.
You are the engineer.
You decide what runs where.
# A real Program: the wildfire wiki
Here is what this looks like on an actual task.
Say you want to build an interactive wiki for wildfire data.
Normally you would lose a day or two wiring this together manually.
With Programs, you describe the steps. Slate builds and runs the loop.
Block 1 — Deep Research
Point the first block at the question.
It searches. Reads. Sharpens.
Comes back with the datasets, the sources, and what actually matters.
Block 2 — Planner
Hand the research to a planner block.
Tell it the order to work in:
→ First: figure out how to set up the project
→ Then: break the wiki into real requirements — map view, timeline, data tables, search
Block 3 — Parallel Workers
Run each requirement on its own.
Each one its own goal block working in parallel until that feature is done.
Block 4 — Compose
The blocks compose.
What started as a research question ends as a React wiki you can click through.
Generated from nothing but a repeatable loop you described.
When you need to refresh it: run the loop again.
No guessing about how it will behave.
Deep research went in. An interactive website came out.
# You do not build Programs alone
You do not start from a blank file.
You tell Slate what you want.
Slate drafts the loop with you, step by step.
It saves the loop so you can run it again.
It runs it for you.
Slate is your co-engineer for building loops.
This is different from every other tool.
Other tools: here is a fixed agent. Use it inside our system.
Slate: here are the blocks. Tell me what you want to build. I'll wire it with you.
Think creative mode.
You are the engineer setting the vision.
Slate is the co-engineer who knows the shape of these things and places the blocks.
# Because Programs are JavaScript, they can do real work
This is the part that changes what's possible.
A prompt can answer a question.
A Program can interact with the world.
Point a Program at Slack and it can check every few minutes for a new message, then generate code on demand.
Point it at your codebase and it runs migrations while you sleep.
Point it at a spreadsheet and it processes rows continuously.
You could build your own version of Claude Tag.
You could build a software factory.
You could build an organization.
The loop holds state and keeps going.
It does real work instead of returning one reply.
# Install Slate in one line
Start it in your project:
Tell Slate what program you want to build.
It drafts the loop with you.
# Recap
A prompt answers once and stops.
A loop is a job — the agent keeps working until it is actually done.
Every AI agent you have ever used — Claude Code, Cursor, Codex — is a loop underneath.
In those tools, the loop is fixed. You cannot open it.
A Program is that loop, except it is written in JavaScript and Slate runs it for you.
You decide the steps. You pick the model for each step. You set the stop condition.
Any model. Any task. Any integration.
Because the loop is just code, it can hold state, keep going, and interact with anything — your codebase, an inbox, a spreadsheet, a game.
You do not build it alone.
Slate is your co-engineer.
# If this was useful:
→ Repost to share it with every developer you know
→ Follow @sairahul1 for more systems like this
→ Follow @wearerandomlabs — they built this
Subscribe to theaibuilders.co for more such interesting articles
Try Programs by Slate: randomlabs.ai
> npm i -g @randomlabs/slate
## 相关链接
- [Rahul](https://x.com/sairahul1)
- [@sairahul1](https://x.com/sairahul1)
- [1.1K](https://x.com/sairahul1/status/2078367561453101097/analytics)
- [@sairahul1](https://x.com/@sairahul1)
- [@wearerandomlabs](https://x.com/@wearerandomlabs)
- [theaibuilders.co](https://theaibuilders.co/)
- [randomlabs.ai](https://randomlabs.ai/s)
- [@randomlabs/slate](https://x.com/@randomlabs/slate)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [2:33 PM · Jul 18, 2026](https://x.com/sairahul1/status/2078367561453101097)
- [1,169 Views](https://x.com/sairahul1/status/2078367561453101097/analytics)
- [View quotes](https://x.com/sairahul1/status/2078367561453101097/quotes)
---
*导出时间: 2026/7/18 15:17:14*
---
## 中文翻译
# 循环与挽具：为何顶尖 AI 工程师不再编写提示词
**作者**: Rahul
**日期**: 2026-07-18T06:33:35.000Z
**来源**: [https://x.com/sairahul1/status/2078367561453101097](https://x.com/sairahul1/status/2078367561453101097)
---
上个月，两位当今最资深的 AI 工程师表达了相同的观点。
Peter Steinberger，OpenClaw 的创造者，现就职于 OpenAI：
“你不应该再向编码代理发送提示词了。你应该设计能够向代理发送提示词的循环。”
Boris Cherny，Anthropic Claude Code 的负责人：
“我不再向 Claude 发送提示词了。我有运行中的循环来提示 Claude 并弄清楚该做什么。我的工作是编写循环。”
大多数人读到这些时会想：这到底是什么意思？
更重要的是：我该如何构建一个？
本文将确切地告诉你如何做。
# 大多数人使用 AI 的方式已经过时了
编写提示词。等待。阅读输出。手动修复。再编写一个提示词。
你就是那个循环。
每一步都要经过你。AI 等待。你做决定。AI 再次等待。
你停下的那一刻，一切都停止了。
在 2026 年行动最快的构建者们并不是在编写更好的提示词。
他们在构建能替自己编写提示词的系统。
杠杆支点已经转移。
从输入提示词 → 转向设计循环。
# 循环究竟是什么（在继续之前先定义它）
提示词是一个问题。
你提问。模型回答一次。结束。
循环是一项工作。
代理会持续工作，检查自己的进度，并继续进行直到任务真正完成。
不是直到它生成了一个答案。
而是直到它达到了一个经过验证的结果。
那个“重复直到完成”的周期就是循环。
它是你使用过的每一个 AI 代理内部的引擎。
Claude Code。Cursor。Codex。
在底层，它们的工作方式都一样：
→ 代理调用模型
→ 模型选择一个动作
→ 动作运行
→ 结果返回给模型
→ 重复直到目标达成
循环正是让代理成为代理而不是单一回复的原因。
在每一个这些工具中，循环都是固定且隐藏的。
你无法打开它。你无法改变它的工作方式。你只能接受工具决定的循环方式。
但这即将改变。
# Slate 的程序（循环的下一阶段）
Slate 是一个用于运行真正能展开工作的 AI 代理的命令行界面（CLI）。不同于一个助手逐步完成任务，Slate 会启动并行运行的独立线程。
程序让你能够编写自己的代理工作流：为每项任务选择任意模型，给代理真正的软件使用，并自己控制循环而不是依赖黑盒子的“托管代理”。
程序就是那个循环——只不过它是用 JavaScript 编写的，并由 Slate 为你运行。
你决定：
→ 每一步发生什么
→ 哪个模型处理哪一步
→ 循环在继续之前检查什么
→ 何时停止
所以循环是一个理念——持续工作直到完成。
程序是你在 Slate 中构建循环的方式
如果你能描述步骤，你就能构建循环。
把它想象成 Minecraft。
Minecraft 不会给你一条固定的游戏路径。
它交给你积木并说：去构建你能想象到的任何东西。
程序的工作方式也是一样。
这里是你可以连接在一起的积木：
→ 目标输入——定义目标和成功标准
→ 规划器——研究并将工作分解为步骤
→ 工作者积木——执行每一步
→ 验证器积木——无偏见地检查执行情况
→ 循环本身——对每一步运行，重复直到目标达成
→ 模型选择——简单的步骤使用便宜快速的模型，困难的思考使用前沿模型
→ 状态——跨会话的持久记忆
→ 停止条件——程序如何知道何时退出
一旦几个积木协同工作，Slate 就能自我诊断程序并添加更多积木。
循环会随着时间的推移变得更聪明。
# 为什么这很重要：任何模型，任何步骤
在单个程序中，你可以在任何步骤使用任何模型。
用于整理文件的廉价开源权重模型。
用于困难推理的更强前沿模型。
适合该步骤的任何模型。
这包括开源模型。
大多数代理工具将你锁定在一个模型上处理所有事情。
程序不会。
你是工程师。
你决定在哪里运行什么。
# 一个真实的程序：野火维基
这在实际任务中看起来是这样的。
假设你想构建一个用于野火数据的交互式维基。
通常你会花一两天时间手动将其组装起来。
有了程序，你描述步骤。Slate 构建并运行循环。
积木 1 — 深度研究
将第一个积木指向问题。
它搜索。阅读。提炼。
返回数据集、来源以及真正重要的内容。
积木 2 — 规划器
将研究交给规划器积木。
告诉它工作的顺序：
→ 首先：弄清楚如何设置项目
→ 然后：将维基分解为真正的需求——地图视图、时间轴、数据表、搜索
积木 3 — 并行工作者
独立运行每个需求。
每一个都有自己的目标积木并行工作，直到该功能完成。
积木 4 — 组合
积木进行组合。
最初作为一个研究问题开始，最终变成了一个可以点击浏览的 React 维基。
除了你描述的可重复循环之外，这一切都是凭空生成的。
当你需要刷新它时：再次运行循环。
无需猜测它的行为方式。
输入了深度研究。输出了一个交互式网站。
# 你不是独自构建程序
你不是从空白文件开始。
你告诉 Slate 你想要什么。
Slate 逐步与你一起起草循环。
它保存循环以便你可以再次运行它。
它为你运行它。
Slate 是你构建循环的联合工程师。
这与所有其他工具都不同。
其他工具：这是一个固定的代理。在我们的系统中使用它。
Slate：这是积木。告诉我你想构建什么。我会与你一起连接它。
想象一下创造模式。
你是设定愿景的工程师。
Slate 是了解这些事物的形状并放置积木的联合工程师。
# 因为程序是 JavaScript，它们可以做真正的工作
这是改变可能性边界的关键部分。
提示词可以回答一个问题。
程序可以与世界互动。
将程序指向 Slack，它可以每隔几分钟检查新消息，然后按需生成代码。
将它指向你的代码库，它会在你睡觉时运行迁移。
将它指向电子表格，它会持续处理行。
你可以构建你自己的 Claude Tag 版本。
你可以构建一个软件工厂。
你可以构建一个组织。
循环保持状态并继续运行。
它做真正的工作，而不是返回一个回复。
# 一行命令安装 Slate
在你的项目中启动它：
告诉 Slate 你想构建什么程序。
它会与你一起起草循环。
# 回顾
提示词回答一次并停止。
循环是一项工作——代理持续工作直到真正完成。
你使用过的每一个 AI 代理——Claude Code、Cursor、Codex——底层都是一个循环。
在这些工具中，循环是固定的。你无法打开它。
程序就是那个循环，只不过它是用 JavaScript 编写的，并由 Slate 为你运行。
你决定步骤。你为每一步挑选模型。你设置停止条件。
任何模型。任何任务。任何集成。
因为循环只是代码，所以它可以保持状态、继续运行，并与任何事物互动——你的代码库、收件箱、电子表格、游戏。
你不是独自构建它。
Slate 是你的联合工程师。
# 如果这对你有用：
→ 转发给你知道的每一位开发者
→ 关注 @sairahul1 获取更多这样的系统
→ 关注 @wearerandomlabs —— 他们构建了这个工具
订阅 theaibuilders.co 获取更多有趣的文章
试用 Slate 的程序：randomlabs.ai
> npm i -g @randomlabs/slate
## 相关链接
- [Rahul](https://x.com/sairahul1)
- [@sairahul1](https://x.com/sairahul1)
- [1.1K](https://x.com/sairahul1/status/2078367561453101097/analytics)
- [@sairahul1](https://x.com/@sairahul1)
- [@wearerandomlabs](https://x.com/@wearerandomlabs)
- [theaibuilders.co](https://theaibuilders.co/)
- [randomlabs.ai](https://randomlabs.ai/s)
- [@randomlabs/slate](https://x.com/@randomlabs/slate)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [2:33 PM · Jul 18, 2026](https://x.com/sairahul1/status/2078367561453101097)
- [1,169 Views](https://x.com/sairahul1/status/2078367561453101097/analytics)
- [View quotes](https://x.com/sairahul1/status/2078367561453101097/quotes)
---
*导出时间: 2026/7/18 15:17:14*