Topic · 主题全部主题 →

Anthropic / Claude

Anthropic 的全部动态：Claude 系列模型、Claude Code、安全研究路线与公司进展的持续追踪。

3,584条收录
524条精选

精选归档 · 第 6 页

第 101–120 条 · 共 524 条

7月12日

星期日 · 1 条
17:28
The Decoder：AI News（RSS）精选
AI 评分 71/100
OpenAI CEO Altman 改口称 AI 净创造就业，Anthropic CEO 也修正早期言论

OpenAI CEO Sam Altman 表示，他“相当确信”AI 迄今为止净创造了就业，并承认“这并非我预期”。此前他曾警告 AI 影响可能快得“有点吓人”。Anthropic CEO Dario Amodei 也修正了早期言论，将自动化描述为生产力倍增器而非岗位杀手。然而，多项研究未发现 AI 对整体生产力或劳动力市场产生显著影响。一项多校联合研究指出，程序员和文案的就业危机始于 2022 年初，早于 ChatGPT 发布。耶鲁预算实验室也未发现与 AI 相关的就业市场变化。

AnthropicOpenAI大佬观点现象/趋势
另有 1 家信源报道IT之家（RSS）
推荐理由：Altman和Amodei几乎同时调头，从“AI消灭工作”变成“AI净增就业”，这个转向本身比任何研究都更能说明行业叙事在怎么变。

7月11日

星期六 · 3 条
16:29
IT之家（RSS）精选
AI 评分 71/100
11天Claude Fable 5写超100万行代码：Rust重构JavaScript运行时Bun

开发者Jarred Sumner借助Claude Fable 5模型，11天内将Bun从Zig重写为Rust，64个实例并行编写超100万行代码，API费用约16.5万美元。重构主因是Zig频繁内存错误，Rust可在编译时捕获。Bun v1.4.0以Canary版本发布，修复128个错误，速度提高约2%到5%。Bun团队已于2025年12月被Anthropic收购。

Anthropic开源生态编码行业动态
推荐理由：这是我能找到的第一个用真金白银量化AI编程能力的项目，16.5万美元对一年人工，Bun的这次重构给所有还在观望的人一记实锤。
09:20
Claude Code：GitHub Releases（RSS）精选
AI 评分 56/100
Claude Code v2.1.207 发布

Claude Code v2.1.207 发布。Auto 模式在 Bedrock、Vertex AI 和 Foundry 上无需 CLAUDE_CODE_ENABLE_AUTO_MODE 即可使用，可通过 disableAutoMode 设置关闭。修复了流式响应中包含超长列表、表格、段落或代码块时终端冻结和按键延迟的问题；修复了非交互式运行中远程托管设置被永久记录为已同意而未显示安全同意对话框的问题；修复了自动更新程序每次发布时覆盖 ~/.local/bin/claude 自定义启动脚本或符号链接的问题。Bedrock、Vertex 和 Claude Platform on AWS 默认切换为 Claude Opus 4.8。Auto 模式不再从 .claude/settings.local.json 读取 autoMode，改为使用 ~/.claude/settings.json。修复了 Windows 上 AWS 凭证解析卡住时无限挂起的问题，60 秒超时保护现在生效。

Anthropic产品更新编码
推荐理由：对使用 Bedrock、Vertex 和 Foundry 的开发者来说，自动模式默认开放是最实用的变化，加上模型默认升到 Opus 4.8，是个值得升级的稳定版。
01:40
ClaudeDevs@ClaudeDevs精选
AI 评分 70/100
Claude Code桌面版新增应用内浏览器Claude Code on desktop now has an in-app browser.Claude can pull up docs, designs, or any other site. It can read, click through, and interact the same way it does with your local dev servers.It's sandboxed and configurable: you choose whether sessions persist.译Claude Code 桌面版现在有了应用内浏览器。 Claude 可以调出文档、设计稿或任何其他网站。它可以像操作本地开发服务器一样，进行阅读、点击浏览和交互。 该浏览器采用沙盒机制且可配置：你可以自行选择会话是否持久保留。
Anthropic产品更新搜索编码
另有 1 家信源报道The Decoder：AI News（RSS）
推荐理由：Claude Code这次更新把看的能力直接内置了，开发者再也不用另开浏览器复制粘贴，对前端调试和文档查阅的效率提升是立竿见影的。

7月10日

星期五 · 5 条
15:34
Rohan Paul@rohanpaul_ai精选
AI 评分 75/100
马斯克承认Anthropic是当前AI领导者This is Anthropic’s strongest flex译马斯克在X上发文承认自己此前对Anthropic的判断有误，称其"显然是当前AI领域的领导者"。他表示，没有公司发布过像Mythos/Fable这样优秀的模型，并相信Anthropic很快会推出Mythos 2。他还强调，即使作为竞争对手，也不会以伤害对方的方式切断合作，并列举了特斯拉开源专利、开放超级充电网络等先例。该推文被Rohan Paul转发，称这是Anthropic"最强有力的炫耀"。

Elon Musk: 我之前对 Anthropic 的看法显然是错的。他们目前显然是 AI 领域的领导者。没有哪家公司发布过像 Mythos/Fable 这样优秀的模型，而且他们无疑很快就会准备好 Mythos 2。 即使作为竞争对手，我也绝不会以严重伤害他们的...

AnthropicxAI大佬观点
另有 1 家信源报道TechCrunch：AI（RSS）
推荐理由：马斯克难得公开认错，直接称 Anthropic 是当前 AI 领导者，这个表态可能重塑行业竞争叙事。不过更关键的是他提到 Mythos 2 快来了，这才是真正的信号。
10:13
Claude Code：GitHub Releases（RSS）精选
AI 评分 62/100
Claude Code v2.1.206 发布

Claude Code v2.1.206 发布，主要更新包括：为 /cd 命令添加目录路径建议；新增 /doctor 检查以建议修剪 CLAUDE.md 文件中模型可从代码库推导的内容；/commit-push-pr 现在自动允许 git push 到仓库配置的推送远程仓库；/login 支持 Anthropic 运营的公共网关端点；后台智能体在更新后自动升级。修复了过期登录导致所有模型报错、claude --resume 和 --continue 在启动时无键盘响应、MCP 服务器忽略 request_timeout_ms 配置、OAuth MCP 服务器需手动重新认证、/model 选择器价格显示错误、桌面会话卡在“运行中”状态、Windows 上键盘输入被忽略等多项问题。

AnthropicMCP/工具产品更新编码
推荐理由：Claude Code 这次更新修复了一串体验问题，/doctor 检查能帮团队清理冗余的项目文件，后台静默升级也减少了等待时间，日常使用的开发者更新一下不会亏。
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 的内存安全特性减少此类缺陷。

开源生态教程/实践编码
推荐理由：Bun 创始人把 54 万行 Zig 用 Claude 11 天重写为 Rust，对抗式审查和动态工作流的细节是近期最值得看的 AI 辅助工程实战复盘，做基础设施的可以认真读。
01:40
Anthropic：Newsroom（网页）精选
AI 评分 56/100
Anthropic发起"硬问题"倡议，邀请公众提出AI相关尖锐问题

Anthropic作为公益公司，发起“硬问题”倡议，邀请公众就AI对就业、社会、家庭、科学医学等领域的影响提出最尖锐的问题。此前已通过多种方式收集看法：首轮调查询问5.2万美国人；通过Anthropic Interviewer调查了159个国家70种语言的8.1万Claude用户；开展数十场线下焦点小组；并基于匿名真实数据研究Claude使用情况。公司还设立了Anthropic Institute和Long-Term Benefit Trust以监督公益使命进展。Anthropic承诺将公开追踪并报告针对这些问题的具体行动及成效。

Anthropic安全/对齐行业动态
推荐理由：Anthropic 不再只做技术输出，开始系统性收集公众对 AI 的恐惧和期待，并承诺公开回应——这是头部 AI 公司一次认真的公共对话实验，值得关注后续回应。
00:40
Anthropic：Newsroom（网页）精选
AI 评分 56/100
Anthropic长期利益信托任命本·伯南克为受托人

Anthropic的长期利益信托（LTBT）任命前美联储主席、2022年诺贝尔经济学奖得主本·伯南克为最新受托人。他将与另外三位受托人共同监督公司以对社会长期有益的方式负责任开发先进AI的使命。LTBT独立于管理团队和投资者，受托人不持股、不分红，仅按服务时间获酬。该信托有权向Anthropic董事会任命成员，并就AI风险与社会影响等关键决策提供建议。伯南克将参与公司的经济研究，帮助理解AI对全球劳动力与经济的影响。

Anthropic政策/监管行业动态
推荐理由：请前美联储主席进入长期利益信托，Anthropic 在治理上下了重注。这不止是人事新闻，更透露了公司对 AI 经济影响的预判——他们正在为系统性风险做准备。

7月9日

星期四 · 5 条
21:40
Anthropic：Newsroom（网页）精选
AI 评分 73/100
Claude 推出反思功能（Beta）

Anthropic 为 Claude 推出一项反思功能（Beta），帮助用户追踪使用模式。用户可回顾过去 1、3、6 或 12 个月的活动总结，涵盖关键主题、使用频率和任务类型。功能结合 4D AI Fluency Framework（委托、描述、辨别、勤勉）提供协作分析，支持设定静音时段或定时休息提醒。隐私方面，不涉及无痕对话和健康集成工具，也不提取连接工具中的底层文件。该功能面向 Free、Pro 和 Max 用户，需开启记忆功能，可通过 Claude 网页或桌面应用设置。

Anthropic产品更新
推荐理由：这是大模型公司第一次认真讨论‘人机边界’，上线了帮你看清自己怎么用 Claude 的反思仪表盘，我觉得做产品的可以思考一下这个设计思路。
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 家信源报道The Decoder：AI News（RSS）
推荐理由：Anthropic 官方亲自下场教你省钱，把 Fable 5 当架构师、Sonnet 5 当码农，能保住九成以上性能同时省下近半成本，用 Claude 开发的人今天就可以在项目里试试。
07:27
Anthropic：Research（发表成果 · 网页）精选
AI 评分 68/100
面向AI模型双重用途知识的"开关"：Anthropic与AE Studio提出GRAM方法

Anthropic与AE Studio联合提出梯度路由辅助模块（GRAM）方法，通过在Transformer每层添加可移除的神经元模块，使模型在训练时将病毒学、网络安全、核物理、专业编程语言等双重用途知识仅路由到对应模块，而非扩散至全局。训练后删除模块即可消除该能力，保留则供可信部署使用。实验在合成数据、真实数据及50M到5B参数模型上测试，GRAM效果与数据过滤相当，移除模块不降低通用性能，且比事后“遗忘”技术更难恢复。该研究为平衡双重用途知识的安全访问与有益使用提供了更鲁棒的方案。

Anthropic安全/对齐数据/训练
推荐理由：这是Anthropic在模型安全对齐上的一个新尝试，提出可拆卸模块来精细控制有毒知识，同时保留一般性能。方法还未上Claude，但实验结果表明这条路可能比简单的拒绝训练更鲁棒。
07:16
IT之家（RSS）精选
AI 评分 73/100
利润超10亿美元、ARR剑指千亿，Anthropic抢先OpenAI冲击IPO

Anthropic今年第三季度利润预计超10亿美元，已于6月1日秘密提交IPO申请，若成功将成为规模最大AI实验室IPO。其与OpenAI的年度经常性收入合计接近1000亿美元。凭借Claude Code在软件开发领域的快速普及，Anthropic在2026年实现AI模型盈利变现，成为B2B市场领跑者。SemiAnalysis报告认为其商业模式优越，若持续良好执行，市值可能触及6万亿美元。

Anthropic行业动态
推荐理由：Anthropic抢先提交IPO，利润超10亿美元，在OpenAI推迟上市的档口，这一步会让整个AI赛道的资本竞赛明显提速，投资人该坐不住了。
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日

星期三 · 3 条
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 家信源报道The Decoder：AI News（RSS）
推荐理由：Anthropic官方手把手教的两层模型用法，用Fable当军师、Sonnet当执行者，省token又提质量，Agent开发者值得抄。
00:24
Claude：Blog（网页）精选
AI 评分 71/100
Claude Cowork 向移动端和网页端开放

Claude Cowork 正在向移动端和网页端开放，让会话和文件跨设备同步。Beta 版将在未来几周内首先面向 Max 用户推出。Cowork 可让 Claude 跨文件、日历、邮件、即时通讯等工具完成复杂任务，其中超过 90% 的使用场景并非软件开发，而是日常知识工作（业务运营和内容创作）。工作可跨设备跟随用户：在桌面端开始任务，从手机查看进度；关闭笔记本后 Claude 可继续后台运行，支持定时任务（如周一 6 点自动准备客户简报）。当需要用户决策时，Claude 会将问题推送到手机。桌面端保留完整 Cowork 体验，支持无法安装桌面应用的用户。聊天和 Cowork 已在网页端和桌面端合并。为庆祝上线，双倍 Cowork 使用额度延长至 8 月 5 日。

智能体Anthropic产品更新
另有 1 家信源报道Claude：Blog（网页）
推荐理由：Claude Cowork 把它从桌面解放到手机和浏览器，90% 的日常知识工作被它接住了，跨设备、后台运行让 AI 助手真正能替你干活，不是聊天。

7月7日

星期二 · 3 条
07:09
Claude Code：GitHub Releases（RSS）精选
AI 评分 67/100
Claude Code v2.1.202 发布

Claude Code v2.1.202 在 /config 中新增“Dynamic workflow size”设置，可控制动态工作流的 agent 数量规模（小/中/大），作为指导性建议而非硬性上限。工作流派生的 agent 现在会发射 workflow.run_id 和 workflow.name 的 OpenTelemetry 属性。修复了 mTLS 握手失败、远程控制发送命令失败、移动端发送无说明图片被静默丢弃、语音听写在麦克风故障时无限重试（改为暂停输入）、重载已有技能导致重复指令等问题。改进了工作流 agent 列表布局，MCP 错误消息更清晰。/review <pr> 恢复为快速单次审查，多 agent 审查请使用 /code-review。

智能体Anthropic产品更新
另有 1 家信源报道Claude：Blog（网页）
推荐理由：这波修复让远程控制和工作流终于稳了，以前被 silent drop 的文件和无线重试的 bug 都治好了，Claude Code 重度用户升级后体验会好一个档次。
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 但常觉得代理跑偏，这篇是必读实践指南。
OpenAI / ChatGPTGoogle / Gemini安全对齐