Topic · 主题全部主题 →

教程实践

拿来就能用的实操内容：提示词技巧、工作流搭建、工具用法与踩坑经验。

2,290条收录

350条精选

数据更新至 9月2日 02:24

精选归档 · 第 5 页

第 81–100 条 · 共 350 条

7月14日

星期二 · 5 条

17:59

公众号：小红书技术（dots.llm）精选

AI 评分 64/100

小红书企业级 AI 个人助理：从 0 到全员覆盖的架构实践

小红书以 3 人 3 天推出内测版本，约一个月实现全员覆盖，核心是 AI Native 项目运作机制。技术选型基于 OpenClaw 二次开发，通过 Seal AI Zone 隔离集群与 NEX 沙箱解决安全，Self-GC 使输入 Token 下降 10%~15%、Auto 模式路由使成本降低 69%，并自研 LLM Wiki 三层记忆架构与 Skill Hub 生态。

智能体开源生态教程/实践部署/工程

推荐理由：从物理隔离到三层记忆，这套方案把 OpenClaw 定制为企业个人助理，沙箱和成本控制细节对同类实践有直接参考价值。

17:57

Google AI：DEV 作者专属（RSS）精选

AI 评分 66/100

Google ADK 2.4.0 发布：Agent 可直接触发动态工作流

Google 发布 ADK 2.4.0，允许将 Workflow 直接注册为 Agent 的工具列表中的一等工具，使协调 Agent 能自动调用动态工作流。该模式通过 @node 装饰器定义动态执行节点，支持在运行时根据用户输入的任务列表迭代调用子 Agent 生成执行计划。示例使用 gemini-3.5-flash 模型实现任务协调，代码已开源至 devrel-demos 仓库。

智能体 Google MCP/工具教程/实践

推荐理由：ADK 2.4 把动态工作流直接注册成 Agent 的工具，补齐了多智能体编排里缺失的那块拼图，做复杂 Agent 的可以直接抄这个模式，代码拿来就能跑。

17:10

公众号：卡尔的AI沃茨精选

AI 评分 75/100

实测LibTV Agent：100个AI视频工作流重组为Skill，实现创意自由

LibTV推出Agent功能并内置Skill Hub，提供100多个覆盖武侠电影、皮克斯动画广告、电商口播等类型的视频Skill。用户输入想法后，Agent会分析需求并询问方向，自动生成视频分镜并串联成完整节点工作流，每个节点可查看和修改提示语。生成后LibTV会启动自查机制，自动检测并返修有问题的镜头。故事板视图提供图片与视频资产总览，支持在成片中直接打开剪辑时间线进行精细调整。用户还可自行创建Skill，上传三个文件即可，无需编程。实测中，Agent能输出剧情连贯、带粤语配音的成片，并支持双语字幕生成。

智能体教程/实践视频

推荐理由：LibTV把成熟的视频流程做成可复用的Skill，并开放自定义上传，让创作者无需从节点开始，直接输出接近成片的作品，对于想缩短想法到成片距离的人，这是一个值得上手的效率工具。

12:44

Google AI：DEV 作者专属（RSS）精选

AI 评分 67/100

合成随机向量数据会误导 PostgreSQL 和 AlloyDB 的向量搜索性能测试

Google AI 工程师指出，使用合成随机向量数据测试向量搜索性能可能导致误导性结果。对于 HNSW 索引，合成数据构建耗时 6,601,789 毫秒，而真实数据仅需 4,174,196 毫秒，速度快 1.5 倍，因为随机向量缺乏自然聚类结构，使图索引的节点连接更难建立。

Google 开源生态教程/实践部署/工程

推荐理由：玩pgvector或AlloyDB向量搜索的开发者应该看看这篇，用合成数据测HNSW索引召回率可能只有3%，而真实数据超90%，附带完整SQL复现脚本。

02:03

The Decoder：AI News（RSS）精选

AI 评分 78/100

OpenAI 面向普通用户发布提示词指南：从结果出发，少写步骤

OpenAI 整合了一份面向普通用户的提示词指南，涵盖目标、上下文、输出格式和边界四个可选模块。指南建议以结果而非步骤开头，用一两条硬性规则替代逐步骤脚本。Chat 处理快速任务，基于 Codex 技术和 GPT-5.6 模型的 ChatGPT Work 负责多源、多步骤的复杂项目。Codex 新增 Steer（重定向当前运行）、Queue（排队下一条消息）和沙盒模式，支持 /plan、/goal 和 /review 等斜杠命令。用户无需一次性写对提示词，后续追问是预期调整方式。

OpenAI 教程/实践

另有 22 家信源报道

推荐理由：OpenAI 这次把提示工程从极客技巧拉回常识沟通，核心就一句：先说你想要的结果，别替模型操心步骤。普通用户读完就能上手，思路比旧版引导更务实。

7月13日

星期一 · 1 条

07:54

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 70/100

Ploy 将 AI 智能体默认模型从 Claude Opus 4.8 切换至 GPT-5.6 Sol

Ploy 将其 AI 智能体默认模型从 Claude Opus 4.8 切换至 OpenAI 今晨发布的 GPT-5.6 Sol。在真实营销网站构建测试中，GPT-5.6 Sol 完成页面平均耗时 3 分 42 秒，较 Opus 4.8 的 8 分钟快 2.2 倍；每次构建成本从 3.06 美元降至 2.22 美元，降低 27%；输出 token 从 33.0K 降至 17.1K，视觉评分从 0.936 提升至 0.970。迁移过程发现，GPT-5.6 会为所有 25 个工具参数填充默认值，导致 52%-64% 的文件读取返回空结果；提示词指令和 OpenAI strict 模式均无法修复此行为。此外，评估框架中约三分之一的原始失败源于针对旧模型的假设，而非模型本身问题。

OpenAI 教程/实践部署/工程

另有 19 家信源报道

推荐理由：这篇 Ploy 的迁移手记把 GPT-5.6 生产中踩的坑都摊开了，工具调用参数膨胀和缓存键设计两个问题，做 agent 的团队不看可能会付昂贵学费。

7月12日

星期日 · 1 条

09:57

Tibo@thsottiaux精选

AI 评分 75/100

Tibo 分享通过 CLIProxyAPI 将 Claude Code 后端模型切换为 GPT-5.6 Sol 的方法If you aren't yet bold enough to install the Codex app, you can stay in the presence of your orange crab and point it at GPT 5.6 Sol. Takes 5 minutes. Kudos to Theo for explaining one of the ways to get this done.Step 1: Install CLIProxyAPI Step 2: Connect Step 3: Define following alias and enjoy claudexalias claudex='CLAUDE_CODE_SUBAGENT_MODEL=gpt-5.6-sol \ CLAUDE_CODE_ALWAYS_ENABLE_EFFORT=1 \ CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY=3 \ ENABLE_TOOL_SEARCH=false \ claude --model gpt-5.6-sol'If this gets blocked, I owe you a reset.译用户 Tibo 分享了一种通过 CLIProxyAPI 将 Claude Code 后端模型切换为 GPT-5.6 Sol 的方法。只需三步：安装 CLIProxyAPI、连接认证、设置环境变量别名 claudex。该别名配置了子智能体模型、始终启用 Effort、最大并发工具调用数等参数。引用推文作者 Theo 补充，若已配置好代理，仅需约 2 条提示词即可完成设置。Tibo 称整个过程约 5 分钟，若被封锁可重置。

Theo - t3.gg: @thsottiaux 的 tl；dr 版本： - 使用 Claude 和 Codex 认证设置 CLIProxyAPI - 连接到 Claude Code - 创建 "claudex" 别名，用于设置一些环境变量大概只用了 2 条提示词...

Anthropic OpenAI 教程/实践编码

推荐理由：不装Codex app也能用GPT-5.6-Sol，这个别名技巧解决了Claude Code用户的尝鲜难题，一行命令就搞定，对开发者很友好但算不上突破。

7月10日

星期五 · 2 条

15:31

Elon Musk@elonmusk精选

AI 评分 68/100

Elon Musk 转发用户称赞 Grok Build 的反馈Grok Build gets better every day and we love hearing user feedback for improvements译Elon Musk 转发用户 @0x0funky 对 Grok Build 的称赞。该用户称 Grok Build 是目前唯一集大成的 coding agentic workflow，内建图像生成和图片生视频功能，生图速度快且品质不输 Codex。Agent 可直接完成图像与视频生成，无需额外串接 MCP 或外部服务。用户结合 Agent Sprite Forge 工具，利用 Grok Build 的视频生成能力，先产出 6 秒角色动作视频再反编译为 game sprite，大幅减少对齐问题，制作 2D 横版游戏耗时不到 30 分钟，而此前用 Codex 需 1-2 小时且品质更优。

0xFunky: Grok Build 真的太疯狂了。先不管 GPT-5.6 到底有没有发布、好不好用。先来大力称赞一下 @grok 的 Grok Build，这是目前唯一一个集大成的 coding agentic workflow。 Grok Buil...

智能体 xAI 图像生成教程/实践

推荐理由：这个 Grok Build 加 Agent Sprite Forge 的工作流把做 2D 游戏的时间压到了 30 分钟，之前要 1-2 小时，而且品质更好，独立游戏开发者可以直接抄作业。

06:21

Hacker News 热门（buzzing.cc 中文翻译）精选

AI 评分 71/100

Bun 被 Anthropic 收购后用 Rust 重写，月下载超 2200 万

Bun 于 2025 年 12 月被 Anthropic 收购，作者使用预发布版 Claude Fable 5 进行了大量 Rust 重写。Bun 最初用 Zig 在一年内构建，如今 CLI 月下载超 2200 万，被 Claude Code 等采用。广泛功能带来稳定性挑战，v1.3.14 修复了多项 use-after-free、内存泄漏等 bug。团队通过 ASAN、Fuzzilli 模糊测试等系统性预防，并借助 Rust 的内存安全特性减少此类缺陷。

开源生态教程/实践编码

另有 1 家信源报道

推荐理由：Bun 创始人把 54 万行 Zig 用 Claude 11 天重写为 Rust，对抗式审查和动态工作流的细节是近期最值得看的 AI 辅助工程实战复盘，做基础设施的可以认真读。

7月9日

星期四 · 2 条

15:16

IT之家（RSS）精选

AI 评分 77/100

官方支招两种AI方案：Claude Fable 5搭配Sonnet 5省token

Anthropic官方建议将Claude Fable 5用作规划层、Sonnet 5执行任务以降低成本。顾问模式下，Sonnet 5主执行，仅需额外指导时调用Fable 5；SWE-bench Pro测试显示相比完全用Fable 5可达92%性能，成本仅63%。协调者模式下，Fable 5充当规划者，将子任务分派给多个Sonnet 5工作智能体；BrowseComp基准上达到Fable 5单独运行96%表现，成本为46%。

Anthropic 教程/实践编码

另有 1 家信源报道

推荐理由：Anthropic 官方亲自下场教你省钱，把 Fable 5 当架构师、Sonnet 5 当码农，能保住九成以上性能同时省下近半成本，用 Claude 开发的人今天就可以在项目里试试。

01:22

ClaudeDevs@ClaudeDevs精选

AI 评分 73/100

Claude Code 的 Model 与 Effort：知道更多 vs. 更加努力http://x.com/i/article/2074606120292020224Model and effort in Claude Code: knowing more vs. trying harderClaude Code gives you two settings that both seem to "make the answer better": the model, and the effort level. But what do these actually do to the output? And how do you know whether to reach for a different model or just change the effort level?It's easy to assume that choosing a larger model like Fable gives you a smarter output than Sonnet, and that a higher effort level just means Claude thinks longer before it answers.The first assumption is true. Our largest models are more capable, according to industry-standard benchmarks.But effort means more than "thinking time." Effort controls how much work Claude does on your request overall. That includes how long it thinks, but also:• how many files it reads;• how much it verifies; and• how far it pushes through a multi-step task before checking in with you.At higher effort, Claude takes more of those actions (read files, run tests, double-check) before it comes back to you. At lower effort, it would rather ask you for more context than spend tokens figuring something out on its own.How model selection worksTo understand what the model setting actually controls, it helps to start at the very beginning, from the moment you press enter.Claude Code assembles your message together with the system prompt, tool definitions, your CLAUDE.md, the conversation history, and any files in context. All of this is sent as one request to the API.The model never sees any of that as plain text, though. The first thing that happens on the server is tokenization: the text gets split into pieces, and each piece is mapped to an integer from a fixed vocabulary the model was trained with. const might map to 1978, await might map to 4293. From here on, your prompt is an array of integers.The model's job is to take that array and predict which token comes next. It does this by computing a probability for every token in its vocabulary and picking from the top. After "const x = await", a well-trained model puts high probability on "fetch" (very likely) and near-zero on "banana" (not likely at all).What turns your input tokens into those probabilities is the weights (also called parameters): billions of numbers organized into large matrices. To predict one token, the model runs your input through those matrices (a long chain of matrix multiplications) and reads the probabilities at the end. The weights are where everything the model "knows" lives.The weights of each model are set during training, and by the time you're sending requests they're read-only. Nothing in your prompt, your CLAUDE.md, or your context changes them. If you've run into the word inference, that's all it means: using the model after training is done, with the weights fixed.Everything Claude knows about TypeScript, popular frameworks, or any other general programming knowledge was encoded into those weights at training time.Your prompt and context can still steer the prediction. Putting your real code in front of Claude is steering, and it works really well. However, this doesn't add anything to the weights themselves.If a library didn't exist when the model was trained, it isn't in the weights. You can put the docs in context and Claude will use them, but that's steering, not teaching. Claude's response is only influenced for that one request, but the underlying model hasn't retained anything.When Claude confidently calls an API that doesn't exist (a hallucination), that's the weights producing a token sequence that looks plausible from training patterns, not a failed lookup.So what does changing the model actually do? It swaps which set of frozen weights handles your request.The model doesn't generate a whole answer at once. It predicts one token, appends it to the sequence, and runs the whole computation again to get the next one. A 200-token response is 200 separate passes through the weights. This loop is where most of your wait time (and your output cost) comes from.The model setting decides which weights handle your request, and it also decides what each output token costs.What it doesn't decide is how many tokens get generated. That number can vary a lot for the same prompt, depending on how much work Claude decides to do.Which is exactly what effort controls.How effort worksWhile Claude Code is working on a task, the tokens it generates fall into a few categories:• Thinking: the reasoning you see streaming before and between actions.• Tool calls: structured blocks naming a tool like Read or Edit and its arguments, which Claude Code then parses and executes.• Text to you: the plan, progress updates, the summary at the end.These are all ordinary output tokens from the same loop, billed at the same rate. Thinking tokens, for example, are generated exactly like the other output tokens and stay in context for the rest of that turn.By the time Claude moves on to writing code, its earlier reasoning is part of the input, just like a file it read.So how does effort change any of this? The effort level is sent to the model as part of the request, right alongside your prompt. The model was trained to understand how to behave at each effort level, and that learned behavior is baked into the frozen weights.When your request arrives, effort is just one more input the model responds to, the same way it responds to your prompt text. It sets how thorough, and how certain, Claude needs to be before it considers the task done. That gets weighed on every turn, and higher confidence takes more tokens to reach.At higher effort levels, Claude often starts by creating a plan, and the effort level influences the depth and breadth of that plan. But the plan isn't frozen in place. As Claude gets results back from its actions, it updates its picture of how much progress it's made and how certain it is of the accumulated result.When step 1 of a three-hypothesis debugging plan finds the bug, "investigate hypotheses 2 and 3" may no longer be necessary. Claude will usually say this explicitly (e.g. "the first check found it, so the remaining checks aren't needed") and skip ahead. You see this happen in Claude Code when task lists get revised mid-run.Higher effort does make Claude more likely to double-check, like verifying the answer it found, or still look into the hypotheses it could have skipped. However, it generally won’t artificially inflate usage on a simple task just because the effort level is turned up. "Overthinking" is something our team specifically watches for during model training as it degrades effectiveness.Picking an effort levelFor most tasks, use the model's default effort level. The default is the level where Claude scales its token usage to what most people would want to spend on a task.Think of effort as a manual override on how hard and how long Claude works. Reach for it deliberately when you have a strong preference for thoroughness or speed based on your domain or the type of work you do, and treat it as a general preference, not a task-by-task decision.One practical note following the launch of Opus 4.8: in our testing, the default effort setting on Opus 4.8 produces better results for about the same amount of tokens as the default effort setting on Opus 4.7 on the same task.What to change when Claude gets it wrongWhen Claude gets something wrong, your first instinct shouldn't be to change a setting. It should be to look at the context you gave it. Is your prompt too vague? Is Claude connected to the right tools? Does it have the right skills?If you're increasing effort on a task that shouldn't need it, the fix is usually upstream: in your context, your CLAUDE.md, or how the task is scoped.But say you've given clear context and Claude still gets it wrong. The question to ask yourself is: did it not try hard enough, or did it not know enough?Model: the problem was too hardPick a larger model when the problem is genuinely hard, like subtle bugs, unfamiliar domains, architecture decisions. A larger model is what you want when the smaller model is confidently wrong no matter how much context you give it.Larger models are also better at handling ambiguity. On smaller models, specific instructions that direct the execution are a better recipe for success.Pick a smaller model when the work is routine: edits you can describe precisely, mechanical changes, questions about code that's already in context. There's no reason to pay for capability the task doesn't need.If Claude had all the pertinent context, clearly tried, and still got it wrong; that's a signal to pick a larger model. And if you're on the larger model and the work has been routine for a while, dropping down will increase speed and typically reduce cost without impacting the quality of the output.Effort: Claude didn't try hard enoughPick a higher effort level if Claude did it wrong by not trying hard enough: skipping a file, not running the tests, or not double-checking its work. This is most relevant if you'd selected an effort level below the model's default.The specialist, the expert, and the generalistOne way I like to think about the two settings is that Fable is a specialist who can handle problems almost no one else has, Opus is the expert, and Sonnet is a really good generalist. The effort level decides how much time any of them spends on your task.Opus at low effort is like getting five minutes with an expert who has deep experience with problems like yours. They bring knowledge that isn't anywhere in your codebase; patterns they've seen before, gotchas they know to check for, the kind of experience you only get from having solved a lot of similar problems. But five minutes means a quick read of your code, not a careful pass through every file.Sonnet at high effort is the generalist with the whole afternoon. They're great at coding, and they'll read everything, run things, double-check their work, and end up understanding your specific code thoroughly.Fable is the specialist you call when everyone else is stuck. Even at low effort, they'll spot the thing no one else would. That recognition is also what you're paying the most for, so it's worth saving it for the tasks that need it.None of these is universally "better". The model setting is roughly how capable; the effort setting is roughly how thorough. Most real tasks need some of both.Effort, model, and token consumptionSo how do model selection, effort, and token consumption all interact? It depends on the task.On routine work at the same effort level, both the larger and smaller models generally get it right. The larger model consumes more tokens with extra verification steps, at a higher per-token price. That's why dropping to the smaller model for routine stretches saves real money at no quality cost.On harder, multi-step work, the equation flips. The smaller model has to grind toward the limit of its ability, burning iterations, while the larger model reaches the same quality bar in fewer steps.You're paying more per token for the larger model, but on tasks that genuinely stretch the smaller one, the total cost per task can come out lower. And more importantly: the larger model can finish tasks the smaller one can't, even at the highest effort settings.This is most pronounced with Fable. On long, multi-step work it pulls furthest ahead. In our testing, it finished jobs Opus and Sonnet can't reach at any effort level. It also costs the most per token, which is the other reason to save it for the work that really needs it.The key point in the graphs above: effort picks how far Claude is willing to travel along the curve. That doesn't mean Claude will need to go that far to finish the task.Lastly, effort shapes token consumption, but it doesn't limit it. The only hard cap in the system is max_tokens, which truncates a response mid-stream when hit, but it's a blunt instrument and mostly relevant to API developers. Softer controls like task budgets or asking Claude to keep it brief in your prompt are more helpful. They're guidance the model is trained to follow (it'll look to wrap up as it gets near the limit) rather than a wall it runs into.Effort changes how much work Claude does. The model changes what Claude knows.When you're unhappy with a result, check the context before you touch either setting: give Claude a clear prompt, the right tools and skills, and a way to verify its own work.If Claude still gets it wrong, ask yourself: did it not know enough, or did it not try hard enough? Not knowing enough is a model problem, not trying hard enough is an effort problem.This article was written by @lydiahallie, member of technical staff on the Claude Code team.译Claude Code 的 model 和 effort 两种设置都旨在提升输出，但机制不同。model 越大，模型能力越强（基于行业标准基准测试）。effort 控制 Claude 在请求上的总工作量，包括思考时间、读取文件数、验证程度、多步任务推进深度等。高 effort 时 Claude 会执行更多操作（读文件、跑测试、再检查）；低 effort 时更倾向询问上下文。模型选择本质是切换不同的冻结权重集--权重在训练时固定，prompt 和上下文只能引导（steering）而不能改变权重。模型幻觉是权重产生看似合理但错误的 token 序列。

Anthropic 教程/实践编码

推荐理由：Claude Code 官方这篇把 model 和 effort 的取舍讲得比他处都透，读完就知道什么任务该堆算力、什么任务该降模型省钱。

7月8日

星期三 · 2 条

08:20

公众号：数字生命卡兹克精选

AI 评分 75/100

《人生设计课》Prompt实测：用Claude设计人生的四个阶段

作者将斯坦福《人生设计课》理论体系制成Prompt，通过Claude逐步提问、追问和分析。Prompt融合设计思维、心流理论和积极心理学，分为看清现状、找到指南针、寻路、制定奥德赛计划四阶段，主线问题控制在6到9个。AI引导用户给健康、工作、娱乐、爱打分，区分重力问题与可设计的真问题，生成三个五年人生版本，最终输出8000至12000字的《个人人生设计蓝图》。作者实测效果超预期。

Anthropic 教程/实践

推荐理由：卡兹克把《人生设计课》的整套方法论炼成了一个追问型Prompt，它不替你规划人生，但能用一连串苏格拉底式逼问把你心里一直没厘清的线头拽出来。比心理咨询轻量，比鸡汤硬核，想用AI认真盘一盘自己方向的人值得花半小时玩一遍。

05:49

ClaudeDevs@ClaudeDevs精选

AI 评分 60/100

Fable 5 作为顾问与执行者调用模式A few patterns we frequently use with Fable 5:Use Fable 5 as an "advisor."An executor (Sonnet 5) calls Fable 5 for guidance.Most tokens are billed at the lower executor rate.译我们常与 Fable 5 一起使用的几个模式：将 Fable 5 作为"顾问"。一个执行者（Sonnet 5）调用 Fable 5 寻求指导。大多数 token 按较低的执行者费率计费。

智能体 Anthropic 教程/实践

另有 1 家信源报道

推荐理由：Anthropic官方手把手教的两层模型用法，用Fable当军师、Sonnet当执行者，省token又提质量，Agent开发者值得抄。

7月7日

星期二 · 4 条

23:09

elvis@omarsar0精选

AI 评分 77/100

Elvis Saravia 通过 HITL 和 DialAgent 提升 agentic loops 可靠性Loop engineering is great until something breaks.Here is how I improve the reliability of my agentic loops.I use human-in-the-loop (HITL). It's easy and extremely effective. Anyone can build this.My setup:I recorded a quick demo of how it all works.I shared recently that I now use more voice agents to build and communicate with agents. I also use them to verify.I hate the idea of being tied down to my computer or in a Slack channel to communicate with my agents.Here is what I have done to streamline communication with my agents.All my Claude and Codex agent sessions now use the @DialAgent MCP server. It has a bunch of tools and provisions my agents with their own number that can place calls as native tools, with voice, SMS, and iMessage behind one interface.As my loops/automations work on PRs and new features, my agents escalate decisions to me via a short phone call. This is extremely useful when I am on the road or away from my desk.If you want to try this with Claude Code or Codex, paste this into your agent and get started right away:"Get yourself a Dial phone number and call me. Say hello and that setup is working, then hang up. Follow https://getdial.ai/skills.md"@NVoitenkov and team are building something special here. Go check them out. Give your agent a phone number now: http://getdial.ai ($5 free credit)译Elvis Saravia 介绍使用 human-in-the-loop（HITL）来提升 agentic loops 的可靠性。他所有 Claude 和 Codex agent 会话都通过 @DialAgent MCP 服务器，该服务器为 agent 提供专属号码，支持语音、SMS、iMessage 作为原生工具。当循环/自动化处理 PR 或新功能时，agent 会通过简短电话将决策升级给人类，尤其适合在路上或离开电脑时。用户可粘贴指令让 agent 拨打电话测试。DialAgent 提供 $5 免费额度：http://getdial.ai

智能体 MCP/工具教程/实践

推荐理由：给AI Agent装电话号直接打电话请示，这个实操方案能大幅减少循环失败，Claude Code和Codex用户有$5免费额度马上可试，出差党尤其友好。

03:13

ClaudeDevs@ClaudeDevs精选

AI 评分 70/100

Claude Code 团队详解四种智能体循环类型http://x.com/i/article/2074204645845839872Getting started with loopsThere’s a lot of talk right now about "designing loops" instead of prompting your coding agent. If you spend some time on X trying to pin down what a loop actually is, you'll come across multiple different answers.On the Claude Code team, we define loops as agents repeating cycles of work until a stop condition is met. We categorize a few different types of loops based on:• How they are triggered• How they are stopped• What Claude Code primitive is used• What type of task is most appropriate for each.We’ll cover the main loop types, when to use each, and how to maintain code quality while managing token usage. Not all tasks require complex loops; start with the simplest solution and use these patterns selectively.Turn-based loops• Triggered by: A user prompt.• Stop criteria: Claude judges it has completed the task or needs additional context.• Best used for: Shorter tasks that are not part of a regular process or schedule.• Managed usage by: Write specific prompts and improve verification using skills to reduce the number of turns.Every prompt you send starts a manual loop with you directing each turn. Claude gathers context, takes action, checks its work, repeats if needed, and responds. We call this the agentic loop.For example, ask Claude to create a like button. It reads your code, makes the edit, runs the tests, and hands back something it believes works. You then manually check the work, and write the next prompt.You can improve the verification step by encoding your manual steps as a SKILL.md so Claude can check more of its own work, end-to-end. This should include tools or connectors to allow Claude to see, measure or interact with the result. The more quantitative the checks are, the easier it is for Claude to self-verify.For example, in your SKILL.md file you may specify:Goal-based loop (/goal)• Triggered by: A manual prompt in real-time.• Stop criteria: Goal achieved OR maximum number of turns reached.• Best used for: Tasks that have verifiable exit criteria.• Managed usage by: Setting a specific completion criteria and explicit turn caps, “stop after 5 tries.”Sometimes, a single turn is not enough, especially for more complex tasks. Agents do better when they can iterate. You can extend how long Claude keeps iterating by defining what done looks like with /goal.When you define the success criteria, Claude doesn’t have to make a determination on what is “good enough” and end the loop early. Each time Claude tries to stop, an evaluator model checks your condition and sends it back to work until the goal is met or a number of turns you define is reached.This is why deterministic criteria, such as number of tests passed or clearing a certain score threshold, are so effective.For example:Time-based loop (/loop and /schedule)• Triggered by: A specified time interval.• Stop criteria: You cancel it, or the work completes (the PR merges, the queue is empty).• Best used for: For recurring work, or interfacing with external environments / systems.• Managed usage by: Set longer intervals or react based on events rather than time.Some agentic work is recurring: the task stays the same and only the inputs change. For example, summarizing Slack messages every morning. Other work depends on external systems, and a simple way to interface with one is to check it on an interval and react to what changed. For example, a PR which may receive code reviews or fail CI.For these, you can trigger when Claude runs with /loop which re-runs a prompt on an interval. For example:/loop runs on your computer, so if you turn it off, it stops. You can move the loop to the cloud by creating a routine with /schedule.Proactive loops• Triggered by: An event or schedule, with no human in real time.• Stop criteria: Each task exits when its goal is met. The routine itself runs until you turn it off.• Best used for: Recurring streams of well-defined work: bug reports, issue triage, migrations, dependency upgrades, etc.• Managed usage by: Routing routines to smaller, faster models and using the most capable model for judgment calls.The primitives above, along with other Claude Code features like auto mode and dynamic workflows (research preview) can be composed into a loop for long-running work.For example, to handle incoming feedback, you can use:1. /schedule (research preview) to run a routine that checks for new reports1. /goal to define what done looks and skills to document how to verify it1. Dynamic workflows to orchestrate agents that triage each report, fix it, and review the fix1. Auto mode so the routine runs without stopping to ask for permissionPutting it together, a prompt could look like this:Maintaining code qualityThe quality of a loop’s output depends on the system around it. When designing the system:• Keep the codebase itself clean: Claude follows patterns and conventions that already exist in your codebase.• Give Claude a way to verify its own work: Encode what good looks like for you and your team with skills.• Make docs easy to reach: Frameworks and libraries docs have up-to-date best practices.• Use a second agent for code reviews: A reviewer with fresh context is less biased and not influenced by the main agent’s reasoning. You can use the built-in /code-review skill or Code Review for Github.When an individual result doesn’t meet the standard, don’t stop at fixing the individual issue, try to encode it to improve the system for all future iterations.Managing token usageTo manage token usage, loops should have clear boundaries:• Choose the right primitive and model for the job: Smaller tasks don’t need multiple agents or loops. Some tasks can use cheaper and faster models.• Define clear success and stop criteria: Be specific about what done looks like so Claude can arrive at the solution sooner (but not too soon).• Pilot before a large run: Dynamic workflows can spawn hundreds of agents. Gauge usage on a smaller slice of the work first.• Use scripts for deterministic work: Running a script is cheaper than reasoning through the steps. For example, a PDF skill can ship a form-filling script that Claude runs each time, instead of re-deriving the code.• Don’t run routines more often that you need to: Match the interval to how often the thing you’re watching changes• Review usage: The /usage command breaks down recent usage by skills, subagents, and MCPs, /goal with no arguments shows number of turns and token usage so far, /workflows shows each agent’s token usage and you can stop an agent at any time.Getting startedTo summarize:To get started with loops, look at the work you already do. Pick one task where you’re the bottleneck and ask which piece you could hand off: can you write the verification check? Is the goal clear enough? Does the work arrive on a schedule?Once you have an idea, run the loop, observe the results like where it stalls or over-reaches, and don’t be afraid to iterate on it.For more information, read the Claude Code docs on running agents in parallel, as well as the loop, schedule, goal, and dynamic workflows pages.This article was written by @delba_oliveira译Claude Code 团队将"设计循环"定义为智能体重复工作直到满足停止条件，划分四种类型：1）回合循环--手动提示触发，Claude 自判完成，适合短任务，可通过 SKILL.md 提升验证；2）目标循环--/goal 手动触发，达成目标或达最大轮数停止，需确定性完成标准（如测试通过数）；3）时间循环--/loop 和 /schedule 按间隔触发，适合同步消息、检查 PR 等重复任务，可云端运行；4）主动循环--事件或计划触发，无人实时参与，每个子任务独立退出。建议从最简单方案开始，选择性使用复杂循环。

智能体 Anthropic 教程/实践编码

推荐理由：Claude Code 团队官方的循环设计指南，把 `/goal`、`/loop` 这些原语讲得很清楚，想从单次提示转向自主代理工作流的开发者可以直接照着搭。

02:20

Claude：Blog（网页）精选

AI 评分 70/100

Claude Fable实地指南：发现你的未知

Claude Fable是第一款要求用户主动澄清未知才能获得高质量工作的模型。与Claude Fable协作是一个在实现前后迭代发现未知的过程。通过将问题分解为已知的已知、已知的未知、未知的已知和未知的未知四类，用户可以借助Claude Fable和Claude Code进行盲点检查、头脑风暴、原型设计、实现笔记记录以及答辩解释，从而高效挖掘并解决深藏于代码库和设计与实现中的潜在问题。

智能体 Anthropic 教程/实践编码

推荐理由：Anthropic 官方分享的 Claude Fable 协作方法论，把「发现未知」拆成盲点扫描、原型、面试等可操作步骤，如果你用 Claude Code 但常觉得代理跑偏，这篇是必读实践指南。

01:18

TechCrunch：AI（RSS）精选

AI 评分 75/100

Google 更新隐私设置，默认用媒体数据训练 AI，用户可手动退出

Google 于 6 月通过客户邮件低调更新了搜索服务隐私设置，新增“搜索服务历史”和“个性化推荐”两项开关，默认将用户上传的图片、文件、音频和视频录制等媒体数据保存并用于训练 AI 模型。该更新适用于搜索、地图、购物、航班、酒店、翻译、新闻等服务。用户可通过取消勾选“保存媒体”框来退出，同时可设置数据自动删除周期（3/18/36 个月）。此前独立的网络与应用活动设置不再影响搜索服务数据保留。Meta 等其他公司也在大规模收集用户媒体数据用于 AI 训练。

Google 教程/实践数据/训练

推荐理由：Google 悄悄把用户上传的媒体数据默认用于训练 AI，这篇教程是及时且实用的避坑指南，花两分钟改设置就能保护隐私，所有 Google 用户都该看看。

7月6日

星期一 · 1 条

09:20

公众号：卡尔的AI沃茨精选

AI 评分 73/100

分享8个Claude Fable 5下线前必跑的超实用Prompt

Claude Fable 5即将下线，作者整理了8个经实战验证的提示词：/goal提示语让模型自主跑25次实验（花费165美元，构建速度提高50%、token开销降60%）；工作模式提示语将用户习惯转化为可复用Skills；行动规范提示语约束subagent行为；subagent分配提示语智能分配任务；25个定时循环工作流（含Shadow prompt loop做A/B测试）；自治运行+自动暂停提示语；记忆系统提示语保留错题本；反向面试提示语确保95%把握再执行。这些提示词可迁移至API计费后继续使用，核心是让模型研究用户而非限制能力。

智能体 Anthropic 教程/实践

推荐理由：Fable5下线前的窗口期指南，把社区实战精华浓缩成可直接复制的 prompt，同时告诉你如何把模型行为模式固化成系统，换模型也不慌。

7月4日

星期六 · 2 条

08:00

Lilian Weng：Lil'Log（RSS）精选

AI 评分 57/100

Harness Engineering for Self-Improvement：AI装备层设计模式与自改进

Lilian Weng 近日系统探讨了 AI 的“装备层”（Harness）——位于基础模型与现实世界之间的系统层，负责编排执行、控制模型思考与规划。文章归纳三种核心设计模式：1）工作流自动化，采用“计划-执行-观察-改进”循环；2）将文件系统作为持久化内存，解决长程任务上下文窗口与状态持久化问题；3）子智能体与后台任务，实现并行执行与隔离管理。案例聚焦于 Claude Code、Codex 等编程智能体的装备层设计。未来方向包括上下文工程、工作流优化以及通过进化搜索联合优化模型权重。

智能体教程/实践部署/工程

推荐理由：Lilian Weng 这篇综述把 agent 自改进的脉络从 harness 设计一路拉到进化搜索，近期关键研究基本都串起来了，做 coding agent 和自动研究的同行建议通读。

03:22

Simon Willison 博客精选

AI 评分 73/100

Fable 的判断力：Simon Willison 从 Claude Code 团队获得的效率技巧

Simon Willison 在 AIE 上与 Claude Code 团队交流后建议，让 Fable（以及 Opus）用自己的判断力工作，而非硬性规定行为。例如，直接让 Fable 自行决定何时编写测试，比给出具体规则更好。为应对价格即将上涨、节省 Fable token，Jesse Vincent 的另一个技巧是告诉 Fable 将较小任务委托给较低功耗模型（Sonnet 用于实质性实现、Haiku 用于机械修改），主循环保留判断、审计和数据合成等任务。Willison 已将提示词存入 Claude Code 记忆文件，实际效果良好，Fable token 消耗速度明显下降。

智能体 Anthropic 教程/实践编码

推荐理由：Simon 从 Claude Code 团队得到的实战技巧：别硬性规定 Fable 怎么写测试、用哪个模型，让它自己判断。他实测这条 prompt 能明显节省代币消耗，Fable 涨价前偷时间的利器。

精选归档 · 第 5 页

7月14日

7月13日

7月12日

7月10日

7月9日

7月8日

7月7日

7月6日

7月4日

相关主题