Anthropic Moves 90% of Internal Coding to Claude AI, Mobile Phone Use Rises

Anthropic将90%内部编程转向Claude AI，手机端开发使用增加 AI生成代码的大幅加速，使工程瓶颈从人工语法编写转向下游的产品构思与安全基础设施。 在这场炉边谈话中，Boris Cherny详细介绍了Anthropic的Claude Code如何从根本上改变了软件开发生命周期，并指出自Opus 4.5发布以来，他100%的代码均由AI生成。讨论重点提及了向移动端开发的大幅转变、自动化循环的引入，以及通过动态工作流利用“测试时计算”（test time compute）来优化诸如CI流水线等操作。Cherny强调，随着AI实现代码生成、审查和安全修补的自动化，人类工程瓶颈正从技术执行层面转向更高维度的产品构思与分布式系统设计。 软件开发领域对 AI 的应用发生巨大转变，大量工程师已实现 100% 依靠 AI 编写代码；Boris Cherny 自 2025 年 11 月 Opus 4.5 发布后也实现了 100% 由 Claude Code 编写代码，且目前大部分开发工作直接在手机上完成。 (1:40) 企业在部署 AI 模型时应采用 ROI（投资回报率）框架，而非狭隘地削减成本或限制 Token 预算，因为顶级模型带来的潜在收益远超前期的节省空间。 (2:58) Anthropic 自 2026 年初以来观察到每位工程师生成的代码量增长了 8 倍，导致研发瓶颈由工程产能转移至产品创意构思与市场推广（GTM）速度。 (5:37) AI 架构正在从单个 Agent 演进为自主循环运行的“Loops”，能够自主执行代码审查、排查不稳定测试或直接通过用户反馈提交 PR，Boris 目前约有 30% 的代码通过该自动化方式生成。 (8:32) Anthropic 推出的桌面端“co-work”应用将 Claude Code 的 Agent 基础设施拓展至非工程人员，在安全的沙箱虚拟机中执行跨工具的项目管理和日常自动化任务。 (12:23)

Boris Cherny, Head of Claude Code, argues that software engineering is shifting from manual coding to higher-level agentic orchestration, which displaces traditional productivity metrics and moves operational bottlenecks toward system verification, security, and product ideation. Reassessing Productivity Metrics and Token Return on Investment (2:58) Traditional engineering productivity benchmarks—such as single-digit annual efficiency gains or lines of code written—fail to reflect environments where AI generates the vast majority of software. Cherny reports that 100% of his code has been generated by Claude Code since Opus 4.5 in November of the prior year, resulting in 1,700 pull requests, 400,000 added lines, 250,000 deleted lines, and 8 billion tokens consumed since March 2026, predominantly managed from a mobile phone. Across Anthropic, an estimated 80% to 90% of internal code is model-generated, corresponding to an eightfold increase in code output per engineer. Addressing cost concerns and organizational token caps—such as Uber's reported $1,500 monthly limit per engineer—Cherny asserts that organizations should evaluate AI expenditure through return on investment rather than upfront cost containment. While techniques like using advisor models or lowering effort levels can trim compute expenditures by roughly 50%, Cherny contends that the upside of granting broad token access across engineering, design, and non-technical staff yields orders of magnitude higher business returns. Autonomous Loops and Dynamic Test-Time Compute (8:32) Cherny describes a progression in development abstractions: transitioning from human-written code to autonomous coding agents, and now to 'loops,' where agents prompt other agents. Analogous to higher-order functions in programming, background loops autonomously execute recurring operational tasks, such as scanning user feedback on Threads to open pull requests, reviewing code, or running repository maintenance to eliminate flaky tests and consolidate duplicate abstractions. Cherny estimates that approximately 30% of his daily code is produced via these automated loops. Beyond basic loops, Anthropic is deploying 'dynamic workflows' powered by test-time compute, defined simply as the volume of tokens a model generates during problem-solving. Through this setup, Claude creates an orchestrator program inside a virtual machine to coordinate hundreds or thousands of sub-agents. In an internal trial, Cherny prompted Claude to profile and optimize CI timings with a single instruction; the workflow ran for several hours, consumed several million tokens, and delivered four pull requests that reduced CI runtime by 50%. Resolving Downstream Bottlenecks in Review and Security (5:37) Because instantaneous code generation removes coding as the primary development bottleneck, organizational friction moves downstream to code verification, security, and ideation. To prevent human review queues from collapsing under high PR volumes, Anthropic introduced Claude Code Review, an automated system claiming to catch and resolve 98% to 99% of bugs before human review, shifting human oversight from bug detection to conceptual evaluation. Security introduces another downstream constraint, as autonomous agents can introduce structural flaws. Anthropic relies on Claude Security, an automated product that conducts weekly repository scans to detect and patch vulnerabilities. Powered by Opus 4.8, Cherny notes the tool now detects security flaws during pre-launch red-teaming and penetration testing that human evaluators overlook. Once code review and security pipelines are automated, Cherny argues that the central bottleneck shifts entirely to how quickly product managers and user researchers can generate viable ideas and coordinate go-to-market execution. Current Model Boundaries and Engineering Oversight Despite rapid capability gains, Cherny identifies clear architectural boundaries where human engineers still outperform frontier models. While models excel at writing syntax and frontend interfaces, humans maintain a distinct advantage in product sense and distributed systems design, specifically regarding service orchestration, data flows, and load factor calculations. Cherny forecasts that model competence in distributed systems design will become 'quite good' by the end of the year. To balance autonomy with developer discipline, Anthropic altered its permission architecture. Because engineers experienced 'prompt fatigue' and routinely approved actions without reading them, the team introduced 'auto mode,' which uses an underlying model and prompt-injection classifiers (showing an approximate 1% attack success rate at 100 attempts) to evaluate command safety autonomously. For developer training, Claude Code provides configurable output styles: an 'exploratory' mode that explains codebase mechanics to onboarding engineers, and a 'learning' mode that provides step-by-step instructions without writing the code directly. Reflecting the exponential pace of frontier model releases, Cherny explains that Anthropic has abandoned traditional annual product roadmaps in favor of weekly and monthly planning cycles. Unresolved questions remain regarding how quickly models will conquer complex distributed system design, and how engineering organizations will restructure around non-engineering automation platforms like Co-work.

Claude Code 负责人 Boris Cherny 指出，软件开发正经历从手动编写代码向多智能体循环与高阶抽象的根本范式跃迁；随着代码生产力暴增，企业的关键策略应转向以投资回报率为主导，并集中攻克代码审查、系统安全、分布式设计与创意生成等下游瓶颈。 开发者工作流重构与代码生产的倍增效应 (1:40) Boris Cherny 披露了其高度依赖 AI 的极限开发数据：自 2026 年 3 月以来已消耗 80 亿 Token，提交了 1,700 个 PR，净增加 40 万行代码并删除 25 万行代码。自前一年 11 月 Opus 4.5 发布以来，Boris 的代码 100% 由 Claude Code 编写，他已彻底卸载 IDE，并将大部分日常开发迁移至移动端手机上完成。从 Anthropic 内部全局来看，公司整体约 80% 至 90% 的代码由 Claude Code 编写，若干团队已达 100%，人均代码产出量自年初以来实现了 8 倍增长。 这种生产力跃迁颠覆了传统研发效能评估标准。传统工程基建团队通常将每年 2% 至 3% 的效率提升视作显著成绩，而在当前数百个百分点的增长态势下，旧有指标已然失效。Boris 提出了一套团队采纳三步路径：首先推动工程团队达到 100% 模型生成代码；其次持续度量人均代码生成的加速度；最后精准定位并移除因代码海量产出而在下游环节堆积的新瓶颈。 投资回报率导向与跨职能协同的扩展 (2:58) 针对部分科技企业（如 Uber 设定每位工程师每月 1,500 美元上限）严格控制 AI 成本的做法，Boris 认为企业应建立以投资回报率（ROI）为核心的全局视角，而非局限于前期的单点算力支出。通过使用廉价顾问模型或精细调优虽然能够节省约 50% 的前期开销，但全面引入顶尖前沿模型所释放的业务 upside 与综合回报率可达千倍乃至十万倍。他建议向工程师、产品经理、设计师、数据科学家以及非技术岗位广泛开放 Token 试用，待高价值场景自发涌现后，再通过基于角色的访问控制（RBAC）、调低努力程度或模型路由等后端功能控制成本。 为了将智能化收益外溢至传统研发之外，Anthropic 重点投入了桌面端 Co-work 工具。该产品运行在深度结合操作系统且完全隔离的虚拟机环境中，配备严格的防提示词注入与误操作防护机制，被定义为“面向非工程师的 Claude Code”。Boris 透露其实际应用于各类项目管理场景，例如自动化执行每日晨会：智能体自主读取主进度表格并向各工程师的 Slack 发送进度查询，甚至由工程师的 AI 智能体自动对答。此外，该工具还能全自动化接管复杂的跨国多程差旅预订（如已全自主预订东京、伦敦和柏林行程）。 循环、动态工作流与测试时计算 (8:32) 在软件架构层面，行业正在从单纯的“智能体编写代码”步入“智能体驱动智能体编写代码”的“循环”（Loops）模式。Boris 将编写单行代码类比为单条语句，单智能体编写代码类比为函数，而循环则是更高阶的高阶函数。目前 Boris 约有 30% 的日常代码由后台循环自主生成，包括全天候自主执行代码审查，或每隔数分钟自动扫描 Threads 用户反馈并直接开启修复 PR。针对历史技术债务，持续运行的循环可以在无人预审的情况下，自主重组架构、消除脆弱测试、清理失效用例并整合重复抽象，开发人员仅需在事后进行 PR 合并审查。 支撑高阶自动化能力的核心是第四类扩展法则——“测试时计算”（Test-Time Compute），即通过让模型在推理阶段生成更多 Token 来攻克难题。除显式设置努力程度档位外，高阶形态是近期推出的“动态工作流”，该功能允许模型在虚拟机内自主编写管理程序，动态编排数十至数千个子智能体协作。Boris 举例证实，他在前一晚仅给出单句优化 CI 运行时间的指令，Claude 便通过动态工作流运行数小时、消耗数百万 Token，最终产出 4 个 PR 将 CI 耗时缩减了 50%。 解除下游工程约束与当前技术能力边界 (5:37) 当代码生产不再是阻碍，传统流程在审查与安全防线上面临严峻冲击。为此，Anthropic 推出了商用级 Claude Code Review，通过大量消耗 Token 拦截 98% 至 99% 的代码缺陷，将人类工程师从捉虫中解放出来以专注于方案逻辑本身的评估；同时利用 Opus 4.8 支持的 Claude Security 每周自主扫描代码库以修补漏洞，在红队渗透测试中捕获传统人工容易遗漏的深层风险。此外，为解决工程师因疲劳而盲目放行操作的安全隐患，系统推出了“自动模式”（Auto Mode），由模型基于对话历史智能判断 Bash 指令与网络调用的安全性，借助在 100 次攻击下成功率仅约 1% 的高韧性防注入模型保障自动化执行。 尽管模型能力大幅进化，Boris 坦言人类工程师目前依然在两大维度保持明确优势：其一是敏锐的产品直觉与高层构思，其二是复杂的分布式系统设计（包括服务拆分拓扑、数据流拓扑与负载因子计算），但他预期模型在分布式架构设计上的短板将在年底前显著缩小。为防止开发者因过度代劳而丧失技术底蕴，Claude Code 提供了“探索风格”（讲解底层架构与跨文件交互）和“学习风格”（扮演逐步引导的教学导师且拒绝代写代码）等输出模式，以兼顾组织效率与人员技术成长。 面对技术指数级爆发的现状，Anthropic 放弃了僵化的年度规划，转而维持以周和月为周期的敏捷迭代，以快速响应模型跃迁并拆解管道中的下一个瓶颈。当前工程范式正从手工编写代码不可逆地转向意图表达与系统校验，然而企业如何在成本控制与上限潜力之间找到平衡、并在高度自治的智能体集群中维持系统可解释性与架构安全，仍是行业必须持续解答的核心命题。

## Background 该内容由 YouTube 频道 @Scale 于 2026 年 6 月 19 日发布，记录了 Meta 开发者基础设施产品总监 Jesse Chen 与 Anthropic 旗下 Claude Code 负责人 Boris Cherny 的一场前沿技术炉边对谈。视频简介显示，两位主讲人围绕软件工程的演进、大模型落地实践以及开发范式的重塑展开了深度交流。 ## TL;DR Anthropic 的 Claude Code 负责人 Boris Cherny 透露，自 Opus 4.5 发布以来他 100% 的代码均由 AI 编写，日常主要在手机端开发，单人代码产出暴增 8 倍。他建议企业打破死磕 50% 边际成本的降本思维，转向全员发放 Token 并追求成百上千倍回报的 ROI 视角。随着编码门槛被抹平，研发瓶颈正全面转移至 Code Review、安全渗透测试以及商业创意，Anthropic 正通过动态工作流（Dynamic Workflows）、Loops 自动化维护与 Auto Mode 权限机制重构软件工程的全生命周期。 ## Atmosphere & style 对谈整体洋溢着轻松幽默却极具思想冲击力的极客氛围，两位前 Meta 同事在台上互动自然、谈笑风生，开场的即兴自拍与现场举手调查瞬间拉近了距离。随着 80 亿 Token 消耗、手机写代码、彻底卸载 IDE 等颠覆性日常数据的揭晓，现场气氛迅速从欢快的调侃转变为对未来工程范式加速到来的震撼与深思。整场谈话兼具极高密度的实战经验与深邃的工程洞见，给人一种提前窥见下一代软件开发图景的强烈临场感。 ## Bulletin - [01:40](https://www.youtube.com/watch?v=Z47vatpsGPI&t=100s) Claude Code 负责人 Boris Cherny 透露，自 2025 年 11 月使用 Opus 4.5 以来，他个人 100% 的代码均由 AI 编写，且日常大部分编码已转移至手机端完成。 - [05:48](https://www.youtube.com/watch?v=Z47vatpsGPI&t=348s) Anthropic 内部单名工程师代码产出量增长 8 倍，全公司 80%–90% 的工程代码由 Claude Code 编写，核心瓶颈已从“编写代码”全面转向“产品创意”与“商业化推进”。 - [03:00](https://www.youtube.com/watch?v=Z47vatpsGPI&t=180s) 企业在 AI 工具落地中应采取全员发放 Token 的 ROI 视角，并在后端实施单席位配额与 Advisor 模型调度，而非在前端压制员工的试错与探索。 - [25:22](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1522s) Anthropic 推出全自动审查工具 Claude Code Review 与安全扫描工具 Claude Security，利用海量 Token 消耗拦截高达 98%–99% 的代码缺陷，并在漏洞挖掘上超越常规人工渗透测试。 - [36:16](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2176s) 为应对频繁弹窗导致的“提示疲劳”，Claude Code 引入 Auto Mode 智能仲裁机制，依托上下文安全模型与低至 1% 攻击成功率的提示注入防护，实现数小时至数天的长程自主运行。 ## Key takeaways - [01:40](https://www.youtube.com/watch?v=Z47vatpsGPI&t=100s) AI 辅助编程正迈向全面代写的新范式，Boris Cherny 年内提交 1700 个 PR、新增 40 万行代码，且自 3 月以来已消耗 80 亿 Token。 - [03:00](https://www.youtube.com/watch?v=Z47vatpsGPI&t=180s) 企业应当以投资回报率（ROI）而非纯粹的“成本”来评估大模型投入，先在前端全员开放 Token 激发创新，再在后端实施配额与模型分流等精细化管控。 - [05:48](https://www.youtube.com/watch?v=Z47vatpsGPI&t=348s) 当工程师产出暴涨且代码编写变得极度廉价时，研发的根本瓶颈从实现层前移至需求与创意，随后进一步后移至 GTM（推向市场）与商业化分发。 - [08:37](https://www.youtube.com/watch?v=Z47vatpsGPI&t=517s) 软件工程抽象层级正在从手写源码（语句）跃迁至智能体编写（函数），并进一步演变为智能体驱动智能体的 Loops（高阶函数）模式。 - [12:25](https://www.youtube.com/watch?v=Z47vatpsGPI&t=745s) Cowork 本质上是面向非技术人员的 Claude Code，基于相同 SDK 构建，但深度整合了虚拟机隔离与系统级防误触等安全护栏，可全自动处理差旅订票与日常站会追踪。 - [17:01](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1021s) 前沿模型 Fable 展现出如同资深同事般的细微洞察与假设验证能力，推动资深工程师彻底告别本地 IDE。 - [19:15](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1155s) 在模型选型上，精细化路由降本最多节省约 50% 的前期开销，但顶尖模型的超强智力带来的业务杠杆收益可达数千倍，应当全力拥抱最强模型以追求上限回报。 - [21:16](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1276s) 人类工程师的核心竞争力不在于手动编码，而在于需求挖掘、组织拉齐、架构把控以及将精准业务意图转化为高密度自然语言 Prompt。 - [25:22](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1522s) 研发下游瓶颈正通过专用智能体工具打破：Claude Code Review 承担了海量 PR 的深度排错，Claude Security 则每周自动巡检仓库并自主修复安全漏洞。 - [28:15](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1695s) 通过“动态工作流（Dynamic Workflows）”引入测试时计算（Test-time Compute），模型能够自主调度成百上千个 Sub-Agent 并行重构 CI 流水线，实现运行耗时减半。 - [31:48](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1908s) 面对大规模代码库的技术债，常驻后台的 Loops 可以全自动完成架构重构、清理偶发失败测试（Flaky Tests）与抽象整合，人类只需在 PR 终审确认。 - [35:10](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2110s) 大模型在“产品感”与复杂分布式系统架构设计上仍落后于人类专家，但在纯代码质量与前端实现上已全面超越顶尖工程师。 - [36:16](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2176s) 人工逐条确认命令行容易引发“提示疲劳”导致安全失守，Auto Mode 通过上下文审计模型接管决策，为长程自主任务提供兼顾安全与效率的运行环境。 - [39:24](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2364s) 为防止工程师因 AI 代写而技能退化，Claude Code 提供 Exploratory（探索式原理拆解）与 Learning（互动式导师教学）等 Output Styles，帮助开发者加速掌握新架构与陌生技术栈。 ## Detailed walkthrough ### [00:03](https://www.youtube.com/watch?v=Z47vatpsGPI&t=3s) 开场自拍与现场调查：从辅助编码到 100% AI 生成 对谈在一片轻松热烈的气氛中展开。Meta 开发者基础设施（Dev Infra）团队产品总监 Jesse Chen 与好友——Anthropic 旗下 Claude Code 负责人 Boris Cherny 共同登台。在正式切入正题前，Jesse 掏出手机邀请全场观众合影拍了张自拍，还打趣地喊了一句“大家笑一个，开玩笑的”，瞬间打破了严肃的技术演讲距离。Jesse 介绍，接下来的 40 分钟将是一场炉边谈话，现场屏幕展示了提问二维码，他手持 iPad 实时收集观众投票最高的问题，并在后半段开启开放麦克风问答。 在进入深度提问前，Jesse 面向观众发起了一场现场举手调查：“在场有多少人正在使用 AI 来写代码？”台下随即举起了一大片手。接着，Jesse 抛出了一个更具冲击力的进阶问题：“如果你的代码 100% 都是由 AI 写的，请继续举着手。”环顾会场，依然举着手的人数之多让 Jesse 大为感叹，他直言这一比例远超以往提问时的场景，全行业显然正在亲历一场前所未有的范式重塑。 ### [01:40](https://www.youtube.com/watch?v=Z47vatpsGPI&t=100s) 惊人的编码数据：手机写代码与 80 亿 Token 的日常 谈话以一个极具画面感的破冰问题切入——Jesse 询问 Boris 今年到底写了多少行代码。对此 Boris 早有准备，他笑着透露自己在做准备时特意调取了数据：今年以来他一共提交了 1700 个 PR（Pull Request），累计新增 40 万行代码，删除了 25 万行代码。他补充道，去年他的删除量其实比新增量还要多，今年新增量才稍微反超；而在 Token 消耗方面，尽管部分早期数据因为数据保留策略而被清理，但仅从 3 月份算起，他就已经消耗了整整 80 亿个 Token。 紧接着，Jesse 追问这些代码中究竟有多少是 Boris 亲手敲出来的。Boris 给出了一个令人咋舌的答案：“自去年 11 月 Opus 4.5 以来，我 100% 的代码都是由 Claude Code 编写的。”更颠覆传统认知的是开发载体的转移——当 Jesse 问起如今在手机和笔记本电脑之间的编码比例时，Boris 直言现在最疯狂的事情就是，他大部分的编码工作竟然都是在手机上完成的。Boris 感慨道，要是六个月前有人预言他未来会拿着手机写代码，他一定会觉得对方疯了，但如今这已成为不可思议的现实。 - **PR 提交量**：今年累计提交 1,700 个 PR。 - **代码变动量**：新增代码 400,000 行，删除代码 250,000 行。 - **Token 消耗量**：自 3 月份以来消耗已达 80 亿 Token。 - **AI 编写比例**：自去年 11 月（提及 Opus 4.5）起达到 100%。 - **主要编码终端**：日常大部分编码场景已全面转移至手机端。 ### [03:00](https://www.youtube.com/watch?v=Z47vatpsGPI&t=180s) 算成本还是算 ROI：全员发放 Token 与后置成本控制 针对业内普遍面临的算力成本焦虑，Jesse 抛出了一个许多企业深切关注的难题：业界像 Uber 等公司已经开始针对工程师设立每月算力预算（例如每人每月 1500 美元），但与此同时，以 Anthropic 为代表的前沿实验室却在不断推出能力更强、单价也更昂贵的高端模型。企业究竟该如何在追求极致性能的高成本模型与追求 Token 效率之间拿捏平衡？ Boris 明确指出，在与众多现有客户及潜在客户的日常交流中，他观察到企业通常存在两种截然不同的思考视角：一种单纯计算“成本”，另一种则审视“投资回报率（ROI）”。他坚决认为“ROI 才是绝对正确的思考框架”，因为技术投入必然对应着价值产出。Boris 分享了推广 Claude Code 最具成效的企业做法：不要将 Token 局限在工程部门，而是应该全员发放，涵盖产品经理、设计师、数据科学家甚至是行政财务和市场营销人员。因为在实际落地中，最有价值的创新和流程重构往往并非来自资深工程师，而是来自企业角落里某个 CEO 甚至从未听说过的会计或市场人员。因此，企业初期的核心目标是提供充足的 Token 与安全感，鼓励跨岗位自由探索，绝不要让员工因尝试而背负被问责的心理包袱。 当内部跑通了真正有效的高价值场景后，企业才需要介入成本控制，并且“必须在后端而非前端进行控制”。Boris 介绍，Claude Code 提供了完善的企业治理能力，能够支持灵活精细的成本调优： ```mermaid flowchart TD accTitle: Claude Code 企业落地与治理演进路径 accDescr: 展示从前端全员赋能创新到后端精细化成本控制的双阶段实施框架。 subgraph S1["第一阶段：前端全员赋能与试错"] A["全员发放 Token<br/>(工程/设计/PM/财务/市场)"] --> B["建立容错机制<br/>(消除创新惩罚顾虑)"] B --> C["涌现高价值用例<br/>(非技术岗位创新流程)"] end subgraph S2["第二阶段：后端精细化控制与治理"] C --> D["单席位成本上限管控<br/>(Per-seat Cost Controls)"] D --> E["顾问模型与全局模型调度<br/>(Advisor Models & Effort Level)"] E --> F["部门级预算与 RBAC 权限隔离"] end ``` - **单席位成本限制（Per-seat cost controls）**：为每个员工设置合理的支出防护网。 - **顾问模型调度（Advisor models）**：针对不同任务自动分流至高性价比模型。 - **全局配置与努力程度（Effort level）**：在公司全局统一设置模型的推理深度与消耗档位。 - **分级权限与部门预算**：基于组织架构与角色访问控制（RBAC）下发针对性的算力预算。 ### [05:48](https://www.youtube.com/watch?v=Z47vatpsGPI&t=348s) 生产力暴涨 8 倍后：瓶颈从“编码”转向“创意”与“商业化” 当企业度过了前期的探索阶段、深入落地 Claude Code 后，ROI 的衡量模型需要发生根本性蜕变。Boris 回顾道，过去衡量投入产出比很简单：投入看 Token 消耗，产出则看“AI 编写代码的比例”或“代码行数的增长百分比”。但现场举手表决已经证明，当工程师的代码已经 100% 由 AI 编写时，旧有的评估指标便彻底失效了。过去在传统开发者基础设施团队中，如果一年能让工程师生产力提升 2% 到 3% 就已是卓越的战绩；然而现在行业面对的是数倍的跨越——在 Anthropic 内部，自今年年初以来，单名工程师产出的代码量暴涨了整整 8 倍（8x）。 在生产力呈指数级爆发的新范式下，Boris 提出了企业应遵循的三步思考顺序：首先，让全员代码达到 100% 由 Claude 编写；其次，观察并加速人均代码产出；第三，也是最关键的一步，识别并破除浮现出来的新瓶颈。当编写代码变得极其廉价且极度充裕时，代码本身就不再是阻碍，团队的核心瓶颈将迅速前移至“好的创意”。此时企业必须解除创意的束缚（unhobble），引进或赋能更多产品经理和用户研究员；随后，瓶颈又会迅速后移到“如何将创意迅速推向市场”，这就要求企业快速解除 GTM（Go-To-Market）和市场营销环节的卡点。 Jesse 对此深表赞同并总结道，行业当前所处的演进拐点非常引人深思：如果在一年前举办这场炉边谈话，大家的焦点必然还停留在“如何用 AI 写更多代码”的技术细节上；而如今，当编码工作在很大程度上正在被 AI 全面接管时，全行业都在面对一个全新的终极命题——当代码不再是瓶颈，阻碍业务价值变现的协同壁垒、部署安全以及商业化分发，究竟该如何解决。 ### [08:37](https://www.youtube.com/watch?v=Z47vatpsGPI&t=517s) Loops 是炒作还是下一波技术浪潮？ Jesse Chen 提到自己与 Boris 曾在 Meta 的 Threads 团队共事，并顺带分享了 Threads 刚刚宣布月活跃用户（MAU）突破 5 亿的好消息。借此契机，Jesse 提到了他们前同事 Peter 在 Threads 上抛出的一个尖锐问题：“Loops 究竟是下一个炒作周期，还是切实可用的真东西？”为了让现场观众更好地理解，Jesse 邀请 Boris 解释什么是 Loops，以及他是如何在日常工作中使用的。 Boris 先是向台下调研有多少人试用过 Loops/Routines，发现目前这套概念依然非常早期（nascent），随后又询问在场有多少人是真正写代码的工程师，以便拿捏解释的技术深度。面对程序员群体，Boris 梳理了软件工程近年来抽象层级的演进逻辑：两年前，大家还在纯手动手写源代码；之后开始向 Agent（智能体）代写代码过渡；而眼下正在经历的转变，则是“由 Agent 去 Prompt 另一个 Agent，进而编写代码”。 ```mermaid flowchart LR accTitle: 软件工程抽象层级的演进 accDescr: 展示从手写源码、Agent代写代码到Loops高阶抽象的三阶段演化过程。 subgraph Phase1["传统阶段"] A["手写源代码<br/>(底层语句 Statement)"] end subgraph Phase2["Agent 阶段"] B["Agent 编写代码<br/>(函数 Function)"] end subgraph Phase3["Loops 阶段"] C["Agent 驱动 Agent<br/>(高阶函数 Higher-Order Function)"] end A --> B B --> C ``` Boris 将其比作编程语言本身的抽象跃升：“如果说源代码就像编程里的基础语句（Statement），那么写代码的 Agent 就相当于函数（Function），而 Loops 则类似于高阶函数（Higher-Order Function）。”换句话说，Loops 沿着抽象阶梯又向上迈进了一大步。从手写代码跨越到 Agent 的飞跃有多大，从 Agent 跨入 Loops 的变革就有多深远。 当前 Loops 的成熟度大约相当于一年半以前的 Agent 状态，尚处萌芽期，但已显露出切实的成效。Boris 举了两个极其实际的例子来对比两者的代际差异： - **代码审查（Code Review）**：最初是纯人工逐行审查；接着是工程师主动去 Prompt 自己的 Agent 完成审查；而 Loops 模式下，是一个后台常驻的 Agent 在循环（Loop）中全天候自动处理所有到来的 Code Review。 - **用户反馈处理**：比如在 Threads 上刷用户对产品的反馈意见，最开始是人工刷，之后是调遣 Agent 定点抓取，而 Loops 则是常驻 Agent 每隔 5 到 10 分钟自动轮询一次反馈，并自动提 Pull Request（PR）修复缺陷。 Boris 坚信无论工程师还是设计师、数据科学家、市场营销人员，日常很大一部分工作都可以被拆解并封装进这样的“循环”里。行业中越来越多比例的代码和工作流正逐步被表达为 Loops。就他个人而言，目前平均每天约有 30% 的代码是通过 Loops 自动生成的；如果某些日子刻意全力使用，甚至能逼近 100%，不过整套体系目前还没有彻底“完全顺手（doesn't totally click yet）”。Jesse 对此总结道，Boris 的探索总是走在整个团队前 3 到 6 个月，眼下人类依然必须频繁介入（Human-in-the-loop），而通过工具编排把闭环自动化跑通，正是解锁下一阶段生产力的核心钥匙。 --- ### [12:25](https://www.youtube.com/watch?v=Z47vatpsGPI&t=745s) Cowork：为非工程师打造的“Claude Code”与自动化工作流 Jesse 接着切入 Anthropic 近期重度投入的 Cowork 功能，希望 Boris 聊聊为什么在 Claude Code 大行其道的当下，大家也应该关注并使用 Cowork，以及它在编码之外的具体场景。 Boris 澄清了产品的底层架构：想要体验 Cowork，只需下载官方的 Claude 桌面客户端（Mac 与 Windows 均支持），该客户端集成了普通聊天（Chat）、Claude Code 以及 Cowork。从本质上说，“Cowork 就是面向非工程师的 Claude Code（Cowork is Claude Code for non-engineers）”。两者的底层完全相通，均构建在同一个 Claude Agent SDK 之上，甚至外部开发者也可以基于该 SDK 构建相同的系统。 二者的核心区别在于安全机制与防护栏（Guardrails）： - **深层系统隔离**：Cowork 内置了完整的虚拟机与一套相当复杂的机制； - **防误触系统保护**：深度挂钩（Hook）操作系统底层，防止用户意外删除重要文件； - **注入攻击防御**：针对提示词注入（Prompt Injection）做了大量专门防护，大幅降低非技术人员“误伤自己（shoot yourself in the foot）”的概率。 在实际使用中，Boris 将 Cowork 彻底当成了自己的“非研发全能副手”。他分享了两个极具代表性的日常落地用例： 1. **自动化项目管理与站会**：团队过去每天早晨需要开站会同步进展。现在，Boris 让 Cowork 在浏览器中直接打开本周的工作流在线表格，Cowork 会自动在 Slack 上逐个私信询问工程师最新进展。有趣的是，很多时候对端并不是工程师本人在打字，而是“工程师的 Claude 在跟 Boris 的 Claude 对话（agents talking to agents）”。获取最新状态后，Cowork 会自动把结果回填到表格里。整个过程零额外配置，仅凭桌面客户端搭配 Claude Chrome 浏览器扩展即可无缝联动。 2. **端到端智能差旅预订**：起初，Boris 只是给 Cowork 喂一段行程要求，让它打开浏览器登录 Anthropic 内部差旅预订网站填单买票；而现在这套流程已经实现了全自动化： - Cowork 每天以定时任务常驻运行，自动扫描 Boris 的电子邮件； - 检查 Google Calendar 上接受的新日程，一旦识别出地点不在旧金山（异地活动），就会主动启动订票流程； - 它完全记住了 Boris 偏好的航班席位、航空公司以及酒店标准，全自动完成多程机票与酒店的选择并提交预订，仅在最后一步等待确认。 Boris 提到自己最近前往东京参加 “Code with Claude”，此前还去了伦敦和柏林，这一整套横跨多国、包含多段复杂联程的机酒差旅，完全由 Cowork 自动化搞定，自己全程几乎没有人工干预。这种能够自主组合各种现成工具、像真人一样操作软件的体验，给初次尝试的用户带来了如同当年第一次使用 AI 对话应用般的震撼。 --- ### [16:13](https://www.youtube.com/watch?v=Z47vatpsGPI&t=973s) 谈及 Fable 模型及其生态定位 现场调查显示已有不少观众开始使用 Cowork。紧接着 Jesse 抛出了社区与现场开发者极度关注的敏感话题：前不久很多人仅仅拿到新模型 Fable 大约 3 天的访问权限，随后服务便告一段落。大家迫切想了解 Boris 长期使用 Fable 的体验，以及在 Anthropic 旗下模型家族不断扩充的背景下，工程师该如何针对不同的软件工程场景去选型不同能力特性的模型。 Boris 首先正面回应了访问权限的波动，明确表示在他们看来这纯属一场“误会（misunderstanding）”，团队内部正全力推进，希望能尽快将其重新带回给广大用户。随后，他开始深入拆解自己对 Fable 的理解，并准备复盘代码生成领域那个至关重要的转折时刻。 ### [17:01](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1021s) 从 Opus 4.5 到 Fable：彻底卸载 IDE 与能力的大跃迁 去年 11 月，随着 Opus 4.5 的发布，整个开发者社区在社交网络上掀起了关于 AI 编程能力的讨论热潮。Boris Cherny 回忆道，从之前的模型跃升至 Opus 4.5 的幅度惊人，正是从那个历史性节点开始，大量工程师第一次完全依靠 Claude 来编写全部代码。对于 Boris 个人而言，这也是他做出彻底告别传统工作流决定的时刻——他直接卸载了自己的 IDE，因为在日常工作中已经完全不再需要手动键入代码。 如果说 Opus 4.5 带来了质的突变，那么从 Opus 4.8 跨越到最新前沿模型 Fable 的提升幅度则同样巨大，甚至在模型底层能力上展现出了更为惊人的进化。Boris 形容 Fable 具备一种前所未有的“细微洞察力与思维维度（nuance and dimensionality）”，其思考方式就像团队中最聪明的同事，彻底摆脱了过去模型那种不解风情的“钝器”感。它不仅在数据分析时能够自主连续追问三次“为什么”以直击问题本质，在复杂 Debug 场景中更能自主提出假设、主动搜集证据并层层验证排查。在纯代码编写上，Boris 感慨自己甚至已经给不出能难倒它的题目：“我几乎耗尽了所有能想到的难题，无论是单次零样本（one-shot）还是略加提示（few-shot），它总能直接搞定。” 这种能力的进化也完全重构了 Anthropic 内部的开发流程。当被问及 Claude Code 本身是否已经 100% 由 Claude Code 编写时，Boris 给出了斩钉截铁的肯定回答，并指出这一状态早在去年 11 月引入 Opus 4.5 时就已经实现。目前不仅 Claude Code 和 Co-work 完全由此方式构建，Anthropic 整体代码库中由 Claude Code 编写的比例平均也已高达 80% 至 90%，且越来越多的团队正在跨过 100% 全自动化的门槛。 - **关键历史节点**：去年 11 月 Opus 4.5 发布，Boris Cherny 正式卸载本地 IDE，进入纯 AI 驱动编程阶段。 - **Fable 的核心特质**：展现出极强的语境细微感知与假设验证能力，在数据分析与复杂排错中能像资深工程师一样自我深挖。 - **Anthropic 内部渗透率**：全公司平均 80%–90% 的工程代码由 Claude Code 自动生成，多个核心产品团队已达到 100%。 --- ### [19:15](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1155s) 算力成本与 ROI 权衡：追逐上千倍的回报而非 50% 的降本 尽管 Fable 拥有碾压级的智力表现，但它的调用成本更为高昂，响应速度也相对较慢。当被问及是否会在不同场景下降级使用 Sonnet 或 Opus 时，Boris 坦承自己在所有任务中都无条件首选 Fable。面对 Jesse Chen 现场打趣“是不是因为 Anthropic 内部根本没有算力预算限制”，现场爆发出一阵笑声。Boris 随即认真澄清：Anthropic 内部对 Token 消耗极其敏锐，因为作为大模型提供方，内部消耗的每一个 Token 都意味着无法交付给付费客户的机会成本（Opportunity Cost）。 从投资回报率（ROI）的角度剖析模型选择时，Boris 提出了一个极具颠覆性的工程经济学视角。开发者固然可以通过精心设计的架构来降本——例如配置轻量的 Advisor 模型，或者默认调用 Opus 并在遭遇瓶颈时路由至 Fable。但这类工程优化往往伴随着巨大的维护负担，团队必须不断进行评测、微调以适应新模型的迭代，最终费尽周折可能也仅能节省约 50% 的前期投入。 相反，如果企业将重心转移到产出端，最顶尖模型所带来的价值杠杆则是成百上千倍甚至上万倍的。Boris 强调：“当下这项技术的普及仍处于极早期，过度聚焦于削减成本完全是本末倒置。”他主张开发者应当直接拥抱最强、最昂贵的模型，将全部精力集中在“如何最大化业务产出与价值回报”上。保持基本的成本治理固然必要，但在巨大的生产力跃升面前，死磕边际成本优化只会错失真正的技术红利。 ```mermaid flowchart LR accTitle: 模型选型 ROI 权衡策略 accDescr: 对比传统降本思维与价值最大化思维在收益和精力投入上的巨大差异。 subgraph Cost_Mindset["降本思维 (聚焦投入端)"] direction TB A1["路由/微调架构"] --> B1["持续评测与维护负担"] B1 --> C1["最多节省 ~50% Token 成本"] end subgraph Value_Mindset["价值思维 (聚焦产出端，Boris 推荐)"] direction TB A2["无脑顶配 Fable"] --> B2["专注于高质量业务交付"] B2 --> C2["释放 1,000% ~ 10,000%+ 上行收益"] end ``` - **Token 的机会成本**：在 Anthropic 内部，研发自用 Token 会挤占向外部企业客户履约的算力配额。 - **精细化路由的隐性代价**：采用混合模型方案（如 Opus 搭配 Advisor）需要频繁运行 Eval 并反复调优，工程维护成本高昂。 - **ROI 核心结论**：成本端最多优化 50%，但价值端（Upside）蕴含数十倍乃至万倍的增长空间。 --- ### [21:16](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1276s) 问答环节：从 MCP 团队协作到软件工程师的核心价值重构 在现场征集的 107 个观众提问中，得票最高的问题聚焦于团队协作——提问者抱怨 Claude Code 目前更像是一个单兵作战工具，团队配合依然只能依赖 GitHub 等传统载体。对此 Boris 透露，团队内部正在紧锣密鼓地研发协作向的新特性；在此之前，他强烈建议开发者通过 MCP（Model Context Protocol，模型上下文协议）将 Claude Code 深度集成至团队常用的协同软件（如 Slack、Microsoft Teams 或 Google Chat），从而打通 Agent 与人类团队的信息流。 随后观众提出的核心困惑在于：“当 Agent 已经能够包揽绝大部分编码工作，人类工程师的核心阵地究竟在哪里？”Boris 与 Jesse 展开了深入探讨。他们一致认为，编码在软件工程师的工作总时长中历来只占极小一部分，大量精力原本就沉淀在上下游环节：与客户沟通挖掘需求、与产品经理及设计师头脑风暴、处理数据分析、敲定系统演进方向以及跨部门跨组织拉齐认知。 ```mermaid flowchart TD accTitle: 软件研发价值重心迁移图 accDescr: 展示工程师的核心职责从手动敲代码转移到前端意图构思与后端智能体监管。 subgraph Upstream["研发上游 (当前人类核心价值)"] U1["用户访谈 / 需求挖掘"] U2["方案构思 / 跨团队拉齐"] U3["精准意图转化为 Prompt"] end subgraph Core_Execution["执行环节 (Agent 全权接管)"] E1["Claude Code / Fable 编写代码与单测"] E2["自动 Debug 与假设验证"] end subgraph Downstream["研发下游 (人工把控与迭代)"] D1["Code Review / 架构监管"] D2["上线部署与业务效果验证"] end Upstream --> Core_Execution --> Downstream ``` Jesse 指出，Meta 内部的数据同样印证了这一规律，工程师的大部分时间消耗在方案设计、文档对齐和部署管理上。Boris 则用了一个生动的比喻：Claude Code 就像是绑在工程师背上的“喷气背包（Jetpack）”，模型每升级一次，背包上就多加装一组喷气引擎，让人的推进速度成倍激增。 在当前的开发状态下，纯手工编写代码已经退化为 Boris 偶尔在飞机上没有 Wi-Fi 时纯粹为了消遣的自娱自乐，他对此毫无留恋。阻碍工程产出的绝对瓶颈已经从“敲代码的速度”彻底转变为“提 Prompt 的速度”以及“提出优质构想的能力”。为了突破这一瓶颈，Boris 表示自己现在大部分时间已经弃用键盘，直接通过语音向 Claude 输入高密度的自然语言指令，人类工程师的角色正彻底进化为驱动并监督超级智能体的系统架构师与业务总指挥。 - **团队协作临时解法**：通过 MCP 协议将智能体挂载至企业即时通讯软件（Slack、Teams 等），实现初步的群组协同。 - **工程师核心职能转变**： - 从关注语法、算法实现与代码重构，转向商业洞察、组织协同、数据决策与 Prompt 意图定义。 - 核心瓶颈转移至“构思高质量 Prompt 的效率”与“高质量业务创意的产生频率”。 - **人机交互范式转变**：Boris 目前已主要转向纯语音交互向 Claude 下达研发指令，完全摆脱键盘输入限制。 ### [25:22](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1522s) 打破下游瓶颈：从编码到全自动的 Claude Code Review 随着上游代码生成能力呈指数级爆发，企业原有的工程评审范式正面临巨大压力。Jesse Chen 提出疑问：很多公司都依赖人工代码审查（Human Code Review），当下游涌入海量代码时，这个流程是否会崩溃？Anthropic 又是如何应对的？Boris Cherny 梳理了软件研发的完整价值链——从写代码、上线部署到最终驱动业务指标（无论是收入还是活跃度）。在过去，整条链路最大的瓶颈就是“写代码”本身；而如今 Anthropic 和许多早期采用 Claude Code 的客户已经彻底攻克了这一难关。随之而来的下一个阻塞点便是代码审查（Code Review）。 面对海量需要审查的代码，Anthropic 并没有依赖传统方法，而是打造了自研产品 **Claude Code Review**。该产品已对外开放，与 Anthropic 内部审查每一个 Pull Request（PR）所使用的工具完全相同。Boris 坦言，这款产品与市面上现存的任何代码审查工具都截然不同，“它的定价要贵得多”（a lot more expensive）。之所以昂贵，是因为它消耗了数以百万计的 Token 来进行深度的全自动化代码审查。当工程师在 GitHub 上真正看到 PR 时，系统几乎可以确保绝大多数潜在缺陷已被根除；尽管还达不到 100% 的完美，但准确率已经逼近 98% 到 99%。这意味着工程师的角色发生了根本性逆转：大家不再需要眯着眼睛逐行挑刺找 Bug，因为 Claude 已经找出来并且修复好了，人类工程师只需思考更高维的问题：“这个 PR 到底应不应该存在？它是否符合产品愿景？” - **业务交付闭环**：代码编写 → 上线生产环境 → 驱动核心业务指标（如收入、用户使用量）。 - **极高查错率**：拦截约 98%–99% 的常见代码缺陷与逻辑漏洞，将人工精力从低级纠错中彻底解放。 - **高算力消耗属性**：通过消耗海量 Token 换取极高精度的全自动审查与自主修复。 ```mermaid flowchart TD accTitle: 软件研发价值链瓶颈的演进迁移 accDescr: 展示从最初的编码瓶颈转移至代码审查、安全检查以及CI/CD优化的全流程演变图。 subgraph Phase1["第一阶段：编码阶段"] A["传统最大瓶颈：编写代码"] -->|"Claude Code 解决"| B["高吞吐代码产出"] end subgraph Phase2["第二阶段：验证阶段"] B --> C{"次级瓶颈：Code Review"} C -->|"Claude Code Review"| D["几乎零 Bug 的 PR"] D --> E{"下一瓶颈：安全审核"} E -->|"Claude Security 自动修复"| F["安全合规基线"] end subgraph Phase3["第三阶段：交付与系统维护"] F --> G{"流水线瓶颈：CI/CD 耗时与测试维护"} G -->|"动态 Workflows / Loops"| H["业务上线与长期维护"] end ``` --- ### [27:11](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1631s) 安全审核自动化：超越人工渗透测试的 Claude Security 当代码生成的门槛被抹平，下一个浮出水面的核心瓶颈便是安全性。Agent 在极速编写代码的同时，也会像人类开发者一样引入安全脆弱点。为此，Anthropic 构建了内部安全工具 **Claude Security**，并在内部验证成熟后同样向客户开放。该系统每周都会在 Anthropic 所有的代码库中进行例行全量扫描，自主发现漏洞并直接生成修复补丁。 Boris 透露了一个令人惊叹的技术飞跃：Anthropic 对每个重大新功能发布都会进行常规的红队演练（Red Teaming）和外部渗透测试（Penetration Testing）。过去自动化工具往往只能作为辅助，但随着底层大模型进化到 **Opus 4.8**，Claude Security 已经开始频繁捕捉到连资深专业渗透测试人员都会漏掉的隐蔽安全隐患。这表明在极其复杂的系统安全建模上，模型已经展现出超越人类专家的广度与敏锐度。 - **每周自动化巡检**：全自动扫描所有底层仓库，主动挖掘安全漏洞并自主完成修复。 - **Opus 4.8 驱动突破**：底层推理能力的大幅跨越，让模型在漏洞挖掘深度上超越了常规红队与人工渗透测试。 - **工具产品化逻辑**：Anthropic 解决自身研发痛点的内部工具，验证成熟后直接对齐转化为面向外部客户的商业产品。 --- ### [28:15](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1695s) 动态工作流落地：一句 Prompt 削减 50% CI 运行时间 解决完安全瓶颈后，研发链路的阻碍进一步向外围蔓延，例如创意构思（Idea Generation）以及持续集成（CI）的性能扩容。Boris 分享了他在访谈前一晚亲手完成的一项惊人实验：他注意到团队内部的 CI 流水线响应变慢，于是启动 Claude Code，仅仅输入了一行简单的 Prompt：“使用工作流分析我的数据，查看数据集中的真实 CI 运行耗时，并对 CI 进行优化以大幅提升速度。”（"Use a workflow to look at my data, look at real CI timings from the data set, and optimize CI to make it much faster."） 听到这里，Jesse 忍不住惊呼：“就这么简单？”Boris 笑着证实：“就是这么简单。”在这个过程中，系统调用了 Anthropic 刚刚上线几周的新特性——**动态工作流（Dynamic Workflow）**。模型以此作为一种全新的“测试时计算”（Test-Time Compute）范式，自主编排并调度了成百上千个 Sub-Agent（子代理）。在耗时数小时、消耗数百万 Token 后，Claude 最终提交了 4 个 PR，将团队原本拖沓的 CI 耗时整整削减了 50%。Boris 在前一天晚上直接合并了这些改动。在以往，这种级别的性能剖析（Profiling）和构建流水线重构往往需要工程师耗费数天、数周乃至数月的时间。 - **极简自然语言交互**：无需复杂的指令约束，仅靠单句目标驱动复杂的动态系统工程。 - **海量子代理调度**：动态工作流能够自发拉起数十、数百甚至上千个子代理协同推进任务。 - **显著工程收益**：消耗数百万 Token、自主运行数小时，直接生成 4 个优质 PR，将 CI 耗时减半。 --- ### [29:59](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1799s) 敏捷迭代与未来愿景：不设年度计划，专注长程运行与意图对齐 针对 Jesse 提出的“团队未来一年的愿景是什么”这一问题，Boris 给出了一个出人意料的免责声明：团队根本没有长达一年的年度计划，而是严格按照“周”（Weekly）或“月”（Monthly）的超短周期推进。他解释道：“这个领域的技术演进是指数级的，面对这种疯狂的指数曲线，你只能紧紧抓牢，走一步看一步。” 回顾技术轨迹，从 Claude 3.5 Sonnet 开始，模型编码能力经历了跨越式提升，但市场上长期缺乏能让开发者彻底释放这种潜力的前端形态；Claude Code 的诞生正是为了“摒弃人工直接翻看源码”的旧习惯，让用户纯粹以 Agent 交互的形式去感知模型能力。展望未来几个月至一年，Anthropic 的核心主线非常明确： 1. **长程任务处理能力（Long-Running Work）**：Claude 在处理超长时间跨度任务上已遥遥领先，未来这一优势还将继续拉大； 2. **代码安全性与交付质量**：进一步杜绝漏洞，提升系统架构的健壮度； 3. **意图深度对齐（Alignment）**：无论使用者是工程师、产品经理还是设计师，模型都将以极高的保真度理解并表达其顶层意图，打造跨越所有工作环境（Anywhere）的无缝体验。 - **迭代周期**：放弃僵化的 12 个月长期计划，转向以周和月为维度的敏捷冲刺。 - **全生态随处运行**：无需开发者替换现有的底层技术栈，“无论你的团队在哪里工作，Claude 都能在那里运行”。 - **长期领先优势**：持续压测超长程复杂任务的执行稳定性与多角色意图的高效落地。 --- ### [31:48](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1908s) 用 Loops 与 Workflows 治理大规模代码库的技术债 在问答环节，观众 Reza 提出了一个直击痛点的问题：“在大规模软件项目中，编码并不是最大的难题，长期维护（Maintenance）才是。你们如何应对代码的长期维护？”Boris 坦言，自己近期一直在尝试利用 **Loops（循环）** 来重塑维护体系。所谓循环，即让 Claude Code 在后台持久运转，自主探查代码库并持续发起优化。 Boris 列举了目前已在内部常态化运行的一系列“维护循环”任务： - **架构重构**：巡检整个工程架构，提出并实施渐进式重构方案； - **清理脆弱测试（Flaky Tests）**：排查测试套件中不稳定、偶发失败的测试用例并予以修复； - **清理冗余无用测试**：直接识别无价值的废弃测试代码并执行删除； - **抽象归一化**：在全库检索重复出现的底层抽象逻辑，将其整合统一为优雅的单类或通用模块。 Jesse 追问在这些高风险操作（例如直接删除测试或修改抽象）中，人类是否需要在代码改动前逐一核准？Boris 明确表示并不需要——Agent 会自主跑完循环并直接提 PR，人类工程师只需在 PR 层面做最终确认。对于这类有特定模式的工程维护任务，最新版本的模型已经展现出惊人的掌控力。如果效果不尽如人意，开发者甚至不需要念所谓的“不要犯错”这种玄学咒语，只需要加上核心提示词——**“使用工作流”（Use a workflow）**，模型就会自动追加更多的测试时计算（Test-Time Compute），交付高质量的改动。在进入后半段讨论时，Jesse 顺势问及 Workflows 与 Loops 之间的底层概念差异，Boris 指出二者有本质不同，其核心逻辑扎根于大模型的前沿 Scaling Law 之中。 ### [33:49](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2029s) 扩展定律的第四维度：测试时计算与动态工作流 回顾大语言模型（LLM）的发展历程，早期关于 Transformer 扩展规律（Scaling Laws）的经典论文确立了模型能力的增长主要取决于三个核心变量：训练数据量、神经网络参数规模以及训练所投入的算力。正是这三项因素驱动了模型智能呈现指数级跃升。然而在过去几年中，业界迎来了第四个全新维度——测试时计算（Test-time Compute）。 所谓的“测试时计算”，本质上就是让模型在推理阶段生成更多的 Token，从而以更充裕的思考与演算换取更优质的最终结果。Anthropic 在实践中主要探索了两种实现路径： 1. **努力程度设置（Effort Settings）**：在 Claude 模型中提供了从 low、medium、high、extra high 到 max 等不同档位，直接调控模型愿意输出和消耗的 Token 数量。投入的 Token 越多，模型推理得越深入，输出质量也越好。 2. **动态工作流（Dynamic Workflows）**：这是最新推出的形态。系统利用 Claude 编写在虚拟机（VM）中运行的调度程序，通过代码化编排来指挥、协作大量其他的 Claude 实例。这种测试时计算模式使 Claude 具备了动态生成并驱动数十、数百乃至数千个 Agent 协同作战的能力。 ```mermaid flowchart TD accTitle: 测试时计算的两种实现机制 accDescr: 展示 Claude 模型通过努力程度设置与动态工作流提升推理表现的流程架构 subgraph Config["配置维度"] A["努力程度设置<br/>(low / med / high / max)"] --> B["调节 Token 预算与深度"] end subgraph Dynamic["编排维度"] C["Claude 编写调度代码"] --> D["运行于虚拟机 (VM)"] D --> E["动态派发数十至数千个 Agent 协同求解"] end B --> F["提升最终输出质量与复杂任务表现"] E --> F ``` --- ### [35:10](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2110s) 模型的短板：产品感与分布式系统设计 谈到当前模型依然难以攻克的硬核难题时，Boris 坦承模型绝非完美，尚有许多待提升的短板。其中最突出的软肋就是“产品感”（Product Sense）与想法生成（Idea Generation）。在探索产品方向和创意构思上，人类工程师依然能够提出比模型更好的想法。然而在具体执行层面，局势已经发生了逆转——Boris 直言，目前模型写出的代码水准以及前端设计水平，都已经超越了他自己亲手编写的质量。 另一个人类明显占优的阵地是大型分布式系统设计（Distributed System Design）。如何划分微服务、组织模块拓扑、规划数据流走向，以及精细评估系统负载因子等系统架构层面的推演，模型仍有巨大的提升空间。当被现场追问“还需要几个月、几周甚至几天模型才能追平人类架构师”时，Boris 虽谨慎表示自己向来不爱预言，但依然给出判断：预计到今年年底，模型在分布式架构设计上的表现就会变得相当出色。 --- ### [36:16](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2176s) 警惕“提示疲劳”：从人工审批到 Auto Mode 与提示注入防御 针对现场观众 Andrew 提出的核心挑战——“如何防止工程师变得懒惰，对 Claude 输出的一切照单全收”，Boris 将其拆解为安全执行与日常学习两个层面。首先在安全层面，过去 Claude Code 默认采用严格的人在回路（Human-in-the-loop）授权机制：每当 Claude 试图在本地终端执行 Bash 命令、调用 MCP 协议扩展或在浏览器中抓取特定 URL 时，都会弹出提示要求工程师确认。 然而在真实使用中，Anthropic 团队与安全专家发现事与愿违：由于频繁弹出确认，工程师很快陷入了严重的“提示疲劳”（Prompt Fatigue）。无论是 Boris 本人还是多数团队成员，最终都变成了机械化地狂点“Yes”而根本不再仔细核对命令细节，导致原本为了加强安全的人工审核反倒严重削弱了整体安全性。为此，团队研发并上线了全新的权限机制——**Auto Mode**。 ```mermaid flowchart LR accTitle: Claude Code 权限审批模式对比 accDescr: 展示提示疲劳导致的安全漏洞如何通过 Auto Mode 智能仲裁解决 subgraph Legacy["传统模式: 提示疲劳隐患"] L1["CLI / MCP / 网络请求"] --> L2["频繁弹窗询问人类"] L2 --> L3["工程师机械点 Yes 失去防御"] end subgraph Auto["Auto Mode: 模型智能仲裁"] A1["危险操作请求"] --> A2["上下文安全审计模型"] A2 -->|依据会话意图| A3{"模型自主裁定批准/拦截"} A3 --> A4["支持数小时至数天的长时间自主运行"] end ``` 在 Auto Mode 下，所有敏感操作的权限决策全部交由上下文安全模型自动研判。这一模式不仅通过了严苛评估，其安全性表现超越了高危模式以及因疲劳而失效的人工作答，更从根本上解放了工程师，使得 Claude 能够连续自主运行数小时甚至数天，完美支撑超长程自主任务。支撑这一转变的底层基石是 Anthropic 多年积累的提示注入防御能力： - 根据官方公布的系统卡片（System Cards），在 100 次提示注入对抗测试中，攻击成功率仅约为 1%，处于业界领先水平。 - 结合大流量覆盖的独立提示注入分类器（Prompt Injection Classifier），模型对恶意提示注入攻击具备了极高抗性。 --- ### [39:24](https://www.youtube.com/watch?v=Z47vatpsGPI&t=2364s) 工程师角色的重塑：借助 Output Styles 深度学习 当日常代码编写逐渐被 Agent 接管，工程师该如何避免技能退化并保持对底层细节的掌控？Boris 分享了 Anthropic 内部极力推崇的利器——Claude Code 的输出风格配置（Output Styles）。对于新入职团队的工程师，团队要求他们在配置中开启探索模式（可通过执行命令 `/config output style = exploratory` 或直接通知 Claude 启用）： - **Exploratory 输出风格**：Claude 在每一次修改代码时，都会主动附带详尽的架构原理解释，讲清楚相关代码库的组织逻辑以及特定语言特性的底层原理，确保工程师在审查改动的同时快速理解系统全貌。 - **Learning 输出风格**：面向非专业编程人员或涉足全新技术栈的开发者。在此模式下，Claude 完全改变作业逻辑——它不再替用户直接完成修改，而是转为“教学导师”。它会细致拆解教学步骤，耐心地说：“在 JavaScript 中第一步先打开该文件并做这几处调整，第二步在终端执行该测试命令”，一步一步引导用户亲自动手。 Boris 强调，这类输出风格与深度交互方式不仅没有架空工程师，反而成为了高强度的学习加速器。尤其在技术栈快速演进、底层基础设施频繁变动，或者必须短时间内编写陌生编程语言时，它能帮助技术人员牢牢掌握核心认知，真正做到掌控全局。 ## Notable quotes > [00:03](https://www.youtube.com/watch?v=Z47vatpsGPI&t=3s) 如果你的代码 100% 都是由 AI 写的，请继续举着手。 — Jesse Chen > [01:40](https://www.youtube.com/watch?v=Z47vatpsGPI&t=100s) 自去年 11 月 Opus 4.5 以来，我 100% 的代码都是由 Claude Code 编写的。 — Boris Cherny > [01:40](https://www.youtube.com/watch?v=Z47vatpsGPI&t=100s) 要是六个月前有人预言我未来会拿着手机写代码，我一定会觉得对方疯了，但如今这已成为不可思议的现实。 — Boris Cherny > [03:00](https://www.youtube.com/watch?v=Z47vatpsGPI&t=180s) ROI 才是绝对正确的思考框架 — Boris Cherny > [08:37](https://www.youtube.com/watch?v=Z47vatpsGPI&t=517s) 如果说源代码就像编程里的基础语句，那么写代码的 Agent 就相当于函数，而 Loops 则类似于高阶函数。 — Boris Cherny > [12:25](https://www.youtube.com/watch?v=Z47vatpsGPI&t=745s) Cowork 就是面向非工程师的 Claude Code — Boris Cherny > [17:01](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1021s) 我几乎耗尽了所有能想到的难题，无论是单次零样本还是略加提示，它总能直接搞定。 — Boris Cherny > [19:15](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1155s) 当下这项技术的普及仍处于极早期，过度聚焦于削减成本完全是本末倒置。 — Boris Cherny > [25:22](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1522s) 它的定价要贵得多 — Boris Cherny > [28:15](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1695s) 使用工作流分析我的数据，查看数据集中的真实 CI 运行耗时，并对 CI 进行优化以大幅提升速度。 — Boris Cherny > [29:59](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1799s) 这个领域的技术演进是指数级的，面对这种疯狂的指数曲线，你只能紧紧抓牢，走一步看一步。 — Boris Cherny > [29:59](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1799s) 无论你的团队在哪里工作，Claude 都能在那里运行 — Boris Cherny > [31:48](https://www.youtube.com/watch?v=Z47vatpsGPI&t=1908s) 使用工作流 — Boris Cherny ## Mentioned Jesse Chen, Boris Cherny, Peter, Andrew, Reza, Anthropic, Meta, Threads, Uber, GitHub, Slack, Microsoft Teams, Google Chat, Google Calendar, Chrome, Claude, Claude Code, Claude Code Review, Claude Security, Cowork, Opus 4.5, Opus 4.8, Fable, Claude 3.5 Sonnet, MCP, Auto Mode ## Video description Jesse Chen, Meta and Boris Cherny, Anthropic [Source](https://www.youtube.com/watch?v=Z47vatpsGPI)

[0:03] Jesse Chen: 如果你的代码 100% 都是由 AI 写的，请继续举着手。 [1:40] Boris Cherny: 自去年 11 月 Opus 4.5 以来，我 100% 的代码都是由 Claude Code 编写的。 [1:40] Boris Cherny: 要是六个月前有人预言我未来会拿着手机写代码，我一定会觉得对方疯了，但如今这已成为不可思议的现实。 [3:00] Boris Cherny: ROI 才是绝对正确的思考框架 [8:37] Boris Cherny: 如果说源代码就像编程里的基础语句，那么写代码的 Agent 就相当于函数，而 Loops 则类似于高阶函数。 [12:25] Boris Cherny: Cowork 就是面向非工程师的 Claude Code [17:01] Boris Cherny: 我几乎耗尽了所有能想到的难题，无论是单次零样本还是略加提示，它总能直接搞定。 [19:15] Boris Cherny: 当下这项技术的普及仍处于极早期，过度聚焦于削减成本完全是本末倒置。 [25:22] Boris Cherny: 它的定价要贵得多 [28:15] Boris Cherny: 使用工作流分析我的数据，查看数据集中的真实 CI 运行耗时，并对 CI 进行优化以大幅提升速度。 [29:59] Boris Cherny: 这个领域的技术演进是指数级的，面对这种疯狂的指数曲线，你只能紧紧抓牢，走一步看一步。 [29:59] Boris Cherny: 无论你的团队在哪里工作，Claude 都能在那里运行 [31:48] Boris Cherny: 使用工作流

[0:03] Host: we need to take a selfie real quick [1:40] Boris Cherny: 100% of my code has been written by Claude code since Opus 4.5 [1:40] Boris Cherny: I would have said you're crazy if you told me that 6 months ago. But yeah, here we are. [2:58] Boris Cherny: ROI is absolutely the right framing [5:37] Boris Cherny: 8x increase in code per engineer [8:32] Boris Cherny: agents prompting agents that then write the code [12:23] Boris Cherny: Claude Code for non-engineers [12:23] Boris Cherny: clouds talking to clouds Boris Cherny: the smartest co-workers Boris Cherny: thousand percent opportunity Boris Cherny: It feels to me like Claude Code is just like this like jetpack, where like as the model gets better, I get like more jets or something in my jetpack, and I can go faster and faster. Boris Cherny: Use a workflow to look at my data, look at real CI timings from, you know, like you know, from from the data set, and optimize CI to make it much faster. Boris Cherny: no more source code, you're just using an agent Boris Cherny: make no mistakes Boris Cherny: use a workflow

[0:03] Good morning, guys. [0:05] I'm here joined with Boris. Before we [0:07] get started, we need to take a selfie [0:09] real quick. If you guys can join us. [0:11] I'm going to take one real quick, all [0:12] right? [0:14] All right, here we go. [0:16] Everyone say cheese. [0:18] Just kidding. [0:19] Okay. Um we have 40 minutes joined by my [0:24] amazing friend Boris. [0:26] Um [0:26] who doesn't need any introduction, but [0:28] in case you haven't heard of him, he's [0:30] the head of Cloud Code. I'm a director [0:31] of product on the Dev Infra team here at [0:33] Meta supporting our AI developer [0:35] productivity stuff. [0:36] And we're going to just have a friendly [0:39] fireside chat to chat about a bunch of [0:41] different questions that we have for [0:42] Boris. [0:43] There's a QR code, I think that was [0:44] shared up screen earlier or somewhere. [0:47] Um we are going to have a later portion [0:49] of the talk to be open open mic. So, I [0:53] have an iPad here with a bunch of [0:54] questions that you guys are submitting. [0:56] We'll go through some of those top voted [0:57] questions. But, as you guys are going to [0:59] fill those out, um [1:02] I want to quickly ask folks, uh how many [1:05] people here use AI to write their code? [1:07] Just Just a quick raise of hands. [1:10] Okay, good amount of people. Um [1:12] keep your hands up though if you 100% of [1:14] your code is written by AI. Let's look [1:16] around the room. How many people is [1:18] that? Okay. It's a lot more than before [1:21] when I asked these questions. So, it's [1:22] really kind of an interesting time to be [1:24] here talking about this stuff because [1:26] all of us are witnessing this [1:27] transformation in our industry. And so, [1:31] I think we're going to get this question [1:32] started. I'm going to have a few [1:33] questions that I'm going to start off [1:34] first. And then, as you guys fill this [1:36] out and vote on the top questions, I'll [1:38] get to those afterwards. [1:40] So, just a few quick warmer questions. [1:41] Boris, [1:43] how many lines of code have you written [1:44] this year? [1:45] >> How many lines of code? [1:46] >> Yeah. [1:46] >> Um so, I actually I I pulled the answer [1:49] for this in prep because I knew you were [1:50] going to ask that question. [1:51] >> Yeah. [1:51] >> Um okay. So, uh 1.7 thousand PRs. [1:57] Uh four added 400,000 lines, deleted [1:59] 250,000 lines. [2:01] >> Okay. [2:02] >> think last year it was actually I [2:03] deleted more than I added. [2:05] Um but this year I added a little bit [2:06] more than I deleted and I also tried to [2:09] get the token account. Unfortunately, [2:11] the the data kind of gets deleted due to [2:13] retention and stuff. But since March, I [2:15] used 8 billion tokens. [2:17] >> 8 billion tokens. And so, those lines of [2:20] code that you deleted and added, those [2:21] are all written by you or Claude code? [2:24] >> Um 100% of my code has been written by [2:27] Claude code since Opus 4.5. So, that's [2:31] like November of last year. [2:33] >> That's crazy. And then, do you use your [2:35] phone or your laptop? Like what's the [2:37] split nowadays when when you code? [2:40] >> Yeah, this is sort of like the the the [2:42] craziest thing like I would not have [2:43] predicted this if you asked me like 6 [2:45] months ago, where are we going to be [2:46] doing our coding? Um but yeah, like most [2:48] of my coding now is on my phone. [2:51] Um I would have said you're crazy if if [2:53] you told me that 6 months ago. But yeah, [2:55] here we are. [2:56] >> Yeah, it's crazy, right? [2:58] Um [2:59] Okay, I think uh [3:00] one of the questions that a lot of [3:02] people have been pinging me about and we [3:03] really want to get your thoughts on is [3:05] they're really starting to think about [3:06] like efficiency and ROI. [3:08] Um [3:09] we kind of like hear of Uber and other [3:11] companies starting to set like annual [3:13] like monthly budgets, for example, like [3:15] $1,500 [3:16] per engineer. [3:18] Um but at the same time, Anthropic, you [3:20] guys and other frontier labs are pushing [3:21] out these more capable but also more [3:23] expensive models. [3:25] What do you think uh about this? Like [3:26] what are your thoughts on how companies [3:27] should balance this tension between like [3:29] more performing but costly models versus [3:31] like having to start to demonstrate more [3:32] efficiency, token efficiency? [3:34] >> Yeah, totally. So, you know, like I [3:36] luckily I get to talk to so many [3:37] companies every day, you know, that are, [3:39] you know, our customers and kind of [3:40] future customers. And broadly, people [3:43] think about it in two ways. Some [3:44] companies think about it in terms of the [3:47] cost. [3:48] And other companies think about it in [3:50] terms of ROI. And I'm like ROI is [3:53] absolutely the right framing because you [3:54] don't want to just think about cost [3:55] because you kind of spend something on [3:57] it and you get something back. [3:59] Um [4:00] when you think about ROI and kind of [4:02] like deploying cloud code in general, I [4:05] think it's useful to think about like [4:06] what's a a really good way to deploy it. [4:08] And I I think like the most successful [4:10] companies we've seen, they sort of give [4:12] everyone tokens, not just engineers, but [4:14] also like the product managers, the [4:16] designers, the data scientists. They [4:18] give everyone tokens and let the company [4:20] experiment to see where the ideas come [4:22] from [4:23] because often it's just like not the [4:25] person that you would expect. Often some [4:27] of the most interesting ideas and the [4:29] most innovative like ways to improve [4:31] processes and kind of like new product [4:32] ideas, it's going to come from like, you [4:35] know, like an accountant somewhere in [4:36] the corner of the org or like a [4:38] marketing person that you've never heard [4:40] that the CEO has never heard of. [4:42] That's where a lot of the innovation [4:43] comes from. It won't necessarily be like [4:44] the most senior engineer always. [4:47] Um [4:48] and so I think for this reason like you [4:49] kind of want companies to experiment and [4:50] you like you want to you want your team [4:52] to experiment. The way to do this is [4:54] give people tokens and give them safety [4:57] to experiment so they feel [5:00] like like like they can try stuff and [5:02] they're not going to get kind of [5:03] penalized for it. [5:04] Once you find these internal use cases [5:06] that kind of work, [5:08] then you want to control the costs and [5:10] you want to do that on the back end, not [5:12] on the front end. And you know, like [5:13] once there's some use case that takes [5:14] off, uses a lot of tokens, then you want [5:17] to think about how to like optimize [5:18] that. There's all sorts of ways like you [5:20] know, like in cloud code we have like [5:21] per-seat cost controls. There's ways to [5:24] use like advisor models. You can change [5:26] the model for your entire company. You [5:28] can control the effort level for your [5:29] entire company. [5:31] Um you can set budgets like based on [5:32] department, based on our back. So [5:34] there's just like all sorts of ways to [5:36] do this. [5:37] I I think the maybe like the second way [5:39] to think about it. So this is kind of [5:41] like the deployment side and like how to [5:42] actually get it out and like when you're [5:43] like at the very beginning. Once [5:45] companies have been using cloud code for [5:46] a while, [5:48] you really do want to think about ROI. [5:50] And you know, like for ROI, there's kind [5:51] of like two parts. There's the [5:53] investment and there's the return. [5:56] In the past, the way that, you know, [5:58] investment is easy to measure. That's [6:00] just tokens. [6:01] Return in the past, the way that we used [6:03] to measure it is what percent of the [6:05] code is written by AI. Or maybe like [6:08] percent increase in the lines of code or [6:09] something. [6:10] And um yeah, like, you know, we just saw [6:13] a bunch of hands go up that said, you [6:14] know, like 100% of your code is AI. So, [6:17] once it gets to 100%, how do you [6:18] actually like measure that return? And [6:20] that's where it gets kind of hard [6:21] because, you know, like we worked on [6:22] Devin for back in the day. And you know, [6:24] like on on Devin for, you know, like if [6:26] if you have like a percentage, like like [6:29] 2, 3% productivity improvement for a [6:31] year, that used to be like pretty good. [6:33] Now, the productivity improvements we're [6:35] looking at are, you know, like hundreds [6:36] of percentage points. And at Anthropic, [6:38] you know, we've seen like a 8x [6:41] increase in code per engineer since the [6:42] beginning of this year. [6:44] And so, like in the in this kind of [6:46] regime, how do you think about the [6:47] return? And I so, I think part of it is [6:50] get to 100% of your code written by [6:51] Claude. Then think about how much is the [6:56] code per engineer accelerating? [6:58] And then the third thing to think about [7:00] is like what are the other bottlenecks [7:02] that are getting in the way? [7:04] Because once you get it to this point [7:05] where engineers are just like writing a [7:06] lot of code, the bottleneck is going to [7:08] be like good ideas. So, how do you kind [7:11] of unhubble that so that your company [7:12] can generate ideas faster? And this [7:14] could mean like more PMs or user [7:16] researchers or something. Um then you [7:18] have to think about how to get these [7:19] ideas to market faster. So, this is kind [7:21] of unhubbling on the GTM and on the [7:22] marketing side. [7:24] Um so, this is this is kind of roughly [7:26] the order that I think about it in. And [7:28] when I look at our customers, everyone [7:29] is kind of like a a different step of of [7:32] of this adoption curve. [7:33] >> Yeah. I think it's really interesting to [7:35] think about, like kind of how you said, [7:37] it started with coding and just getting [7:39] more and progressively more hands up [7:41] where is like 100% of their code is AI. [7:43] But then you start to realize there's [7:45] upstream and downstream bottlenecks, the [7:47] ultimate thing that companies want, [7:49] which is delivering more business value. [7:50] So like un-hobbling those ideas, getting [7:53] code to be deployed faster and safely [7:55] and more accurate. I think those are all [7:57] the things that the the whole industry [7:59] is like figuring out. It's like, okay, [8:01] let's say coding is like more or less [8:03] largely getting solved with AI. What are [8:05] the things now that's blocking [8:06] coordination and collaboration? I [8:08] actually see one of the top voted [8:09] questions is about that. So we'll we'll [8:11] talk about that in a moment. But I think [8:12] that's that's like the interesting [8:14] question we're in now. It's like a year [8:15] ago if we were doing this fireside chat, [8:17] we'd be talking about like how can we [8:19] use AI more for coding? How can we sort [8:20] of like do all that? But now it's kind [8:22] of like the next question. It's like, [8:23] okay, what's next now that coding is [8:26] more or less going to be more and more [8:27] just written by AI. So I think that's a [8:29] really interesting situation that we're [8:31] in right now. [8:32] Um [8:33] All right, next question I have uh so [8:36] for context Boris Boris and I actually [8:37] used to work together on Threads. So of [8:39] course and also Threads just hit 500 [8:41] million monthly actives yesterday, we [8:43] announced. [8:43] >> Congratulations. [8:44] >> Thank you. So I had to obviously ask [8:46] some folks on Threads some for some [8:47] questions. So I have one question from [8:49] there I want to pull out. It's actually [8:50] from our ex-colleague uh old colleague [8:52] Peter. He asked like, is Loops the next [8:55] hype cycle or is it real? Um [8:57] maybe you can explain what Loops are for [8:59] maybe people who don't aren't familiar [9:00] with it and then how you use it [9:01] personally. [9:02] >> Yeah, yeah. Um have people here tried [9:04] Loops, routines? [9:06] >> Still pretty nascent, yeah. Not [9:08] >> Okay, and and just so I know like how [9:09] technical to make the explanation. Raise [9:11] your hand if you're like an engineer [9:12] that codes. [9:15] Okay. So I I think like for the engi- [9:17] for the engineers in the room, the way [9:18] to think about it is um [9:23] 2 years ago [9:24] we wrote source code by hand. [9:28] We started to transition to make it so [9:31] agents write the code. [9:33] And now we're transitioning to the point [9:36] where agents are prompting agents that [9:39] then write the code. [9:41] Maybe that's like the less technical [9:42] explanation. The Vortex explanation like [9:44] actually my mental model is sort of like [9:46] if code if like source code is like [9:49] kind of like the basic level that's sort [9:51] of like a statement in programming then [9:52] the agent run [9:53] writing the code is like a function in [9:55] programming and then loops are like a [9:57] higher order function. So it's it's sort [9:59] of like we're we're stepping up the [10:01] abstraction ladder. It's one more step [10:02] up. Yeah. So loops are sort of like as [10:04] big as the step from source code to [10:06] agents was loops are the step from [10:08] agents to the next thing. It's just as [10:10] important and as big a step. [10:12] To me it feels like right now in the [10:14] world of like loops where um [10:17] I don't know like maybe we're agents [10:19] were like a year and a half ago. So it's [10:20] still like fairly early but we're [10:21] starting to see signs that it's working. [10:24] And the the idea is like okay let's say [10:27] um [10:27] as an engineer a lot of my work is to do [10:29] code review. [10:31] And so like one thing that I could do is [10:32] like I could do the code review by hand. [10:34] The other thing that I could do is I can [10:35] have an agent and I can prompt my agent [10:37] to do the code review. [10:38] The loop version of this is I have an [10:40] agent that's running in a loop that does [10:42] all of the code reviews. [10:44] Or like another example is um you know [10:46] like I read threads to to see like [10:48] people's feedback. Um and so like I [10:50] could do this by hand or I can have an [10:52] agent do it or I can have an agent [10:54] that's constantly looping over and every [10:56] like 5 or 10 minutes reading the [10:57] feedback and putting up PRs for the [10:59] fixes. [11:00] Um and so like a couple you know like a [11:02] year and a half ago we were kind of at [11:03] the first step now we're kind of at the [11:05] third step. [11:06] And so like when you think about all the [11:07] work that we do as engineers and all the [11:09] work that you know like non-engineers do [11:11] like like like designers and data [11:12] scientists and you know like marketing [11:14] people and so on. [11:16] A lot of the work I think we can [11:17] probably chunk up into loops in this [11:19] way. [11:20] And I think we're starting to get to the [11:22] point in the industry where like a [11:23] bigger and bigger percentage of the code [11:25] is like expressed as loops and a bigger [11:26] percentage of the work. [11:28] And so for me personally maybe at this [11:30] point like 30% of my code is written by [11:32] loops [11:33] on an average day. [11:35] Um if I try really hard I can get to [11:37] like 100% for some days, but it it [11:39] doesn't totally click yet. [11:41] >> Nice. [11:42] I feel like if we ask the question of [11:43] how many engineers write loops maybe in [11:45] a year from now we'll see more hands. So [11:47] in some ways you're always like just [11:48] kind of living [11:50] the like 3 months 6 months ahead of the [11:52] rest of the team here and so like I [11:54] think loops is something that's been [11:56] fascinating to internally. I think [11:58] people have been starting to explore [11:59] what are these what are the various ways [12:01] you can orchestrate all the various [12:02] tools you need to kind of create this [12:04] sort of like automatic loop because like [12:06] right now humans are in the loop, right? [12:09] You have to be every single part of the [12:10] way. We were just talking about in the [12:11] first question how to kind of like get [12:14] this sort of process more and more [12:15] automated. And so getting this loop [12:17] going is really sort of like the key to [12:20] to figuring this out um and getting [12:22] getting more productivity. [12:23] Um [12:25] the other thing we've been talking about [12:26] for a while is that Anthropic's been [12:28] investing a lot in co-work as of late. [12:31] I'm pretty sure a lot of the audience [12:32] here primarily uses Claude Code. I think [12:35] um it'd be great if you could tell us [12:37] sort of like why folks here should use [12:38] co-work, what are some of the use cases [12:40] you're most excited about, you know, [12:41] especially related to the first question [12:42] we talked about just like um how how [12:44] people are using it beyond just coding. [12:47] >> Yeah, totally. So for folks that don't [12:48] know like the way that you try co-work [12:50] is you download the Claude desktop app. [12:52] That's the same app that has chat and [12:54] Claude Code in it. It also has co-work [12:55] in it. Um so you just download it. You [12:57] can use it. Works on Mac, works on [12:58] Windows. [13:00] Co-work is Claude Code for [13:02] non-engineers. [13:04] Um it's just Claude Code under the hood [13:06] and it actually uses the same like [13:08] Claude agent SDK that Claude Code is [13:10] built on. So the infra is the same and [13:12] you can actually build on the SDK [13:13] yourself, too. It's exactly the same [13:15] thing. [13:16] Um the reason we say it's not for [13:18] engineer is it's for non-engineers is [13:21] there's a bunch more guardrails built [13:22] in. So co-work has like an entire [13:24] virtual machine. It has this like [13:25] actually quite sophisticated [13:28] Uh and then we like hook into the [13:29] operating system to make sure you don't [13:31] accidentally delete stuff. There's a lot [13:33] of protection for prompt injection. [13:34] There's all sorts of things that we do [13:36] that are, you know, make it a little bit [13:37] harder to shoot yourself in the foot. [13:40] When I think about how I use Cogram, I I [13:42] actually use it for everything that's [13:43] like non-engineering. [13:44] So, you know, like one example is I do [13:46] it I use it for project management. And [13:48] so like we have stand-up We used to have [13:50] stand-up every morning where we talk [13:51] about here's what everyone on the team [13:52] did. [13:53] And now actually what we do is I have [13:55] Cogram and it opens up uh this like [13:59] spreadsheet in the browser and the [14:00] spreadsheet has essentially like all of [14:01] the work streams for the week. And it'll [14:03] message every engineer in Slack for me [14:05] automatically to ask like what's the [14:07] latest status. And often their clouds [14:09] will respond. [14:11] >> What's agents talking to agents? [14:12] >> It's like the clouds talking to the [14:13] clouds. [14:14] >> Yeah, clouds. [14:14] >> Um but sometimes like engineers will [14:16] respond and then like Cogram sees this [14:17] and then it'll fill out the status in [14:18] the spreadsheet. [14:20] And all this is is like Cogram will open [14:21] a browser and it'll do this for you. [14:23] It's like zero setup. You just need [14:25] Cogram and you need the cloud Chrome [14:27] extension and then they'll just kind of [14:28] work together to do this. [14:30] So, this is like this kind of magic of [14:32] combining tools. And I think this that's [14:35] like this like magic moment that that [14:36] people see when they use Cogram. It's [14:38] like, "Oh my god, this thing can use my [14:39] tools and it can combine all my tools [14:42] for me in the way that I would." And it [14:44] it just feels incredible. It feels like [14:45] using like a AI chat app for the first [14:47] time. It's like a revelation. [14:49] There There's this like more [14:50] sophisticated usage um [14:52] One thing that I used to do is I would [14:54] use Cogram to book all of my travel. [14:57] So, what I would say is like, "Okay, [14:58] here's like my itinerary. I need to be [15:00] here on this day, here on this day. Can [15:01] you like go out and book the plane [15:02] tickets for me?" And it I guess it would [15:04] like open a browser and it would go to [15:06] this like, you know, travel site that we [15:07] used to book stuff at Athropic. And it [15:10] would just like fill it out and book the [15:11] tickets. [15:12] And what I've done now is I've actually [15:13] automated it a little bit more. And so [15:15] what Cogram does now is it has a [15:17] scheduled task where every day it'll [15:20] look through my email. [15:22] It'll look for any events that I've [15:23] accepted on my Google Calendar. [15:26] If the event is in a different location, [15:28] then, you know, like it's not in San [15:29] Francisco, it'll go and it'll [15:31] automatically book the tickets. And then [15:32] it'll send it to me. It'll book like the [15:34] tickets. It knows to book like hotels [15:36] and it knows all my like flight and [15:37] hotel preferences. And it'll just do [15:39] this automatically. [15:40] And so, you know, like I was just in [15:42] Tokyo for Code with Claude, and then, [15:43] you know, I was in London and Berlin for [15:45] Code with Claude before that. [15:47] And uh it just fully booked all the [15:48] tickets for me. It was It was like like [15:51] multi-leg like flight and hotel thing, [15:53] and it just booked everything. I did I [15:55] wasn't involved at all. [15:56] >> at all? [15:57] >> Not at all. Yeah, it just like it found [15:59] it in my email and then and it booked it [16:00] after I confirmed. [16:02] Crazy. [16:03] >> Okay. Yeah, I mean, how many people here [16:06] has tried Code Work? Just curious. [16:09] Good amount, actually, right? [16:11] Hopefully more. [16:12] Um [16:13] That's great. I think um [16:15] another question that I got a lot of [16:17] pings about, would love to hear your [16:19] take on this, is that many of us only [16:21] got access to Fable for like maybe 3 [16:23] days or so. So, while we wait to hear [16:26] what happens next, like, you know, [16:27] obviously I'm I'm assuming you had [16:28] access to them for much longer, share [16:31] maybe some of your experiences with how [16:32] you use Fable for coding and like, you [16:34] know, now you guys have a family of [16:35] different models. Um how do you think [16:37] about using different models for [16:38] different software engineering use [16:40] cases? [16:41] >> Yeah, totally. Um and you know, like [16:43] first of all, like, you know, with with [16:44] Fable, just want to say it from our [16:46] point of view, it is a it's like a it's [16:48] a misunderstanding and we're working uh [16:50] to hopefully get it back really soon. [16:52] Um [16:54] the the the way that I think about Fable [16:56] is [16:58] with coding, there was this moment back [17:01] in November of last year. I don't know [17:02] if everyone like remembers this, but [17:03] everyone started like posting on Twitter [17:05] and kind of talking about like how good [17:07] the model has gotten at coding. And what [17:09] happened is Opus 4.5 came out. [17:11] And the leap from the previous model to [17:14] Opus 4.5 was so big that for a lot of [17:18] people they just started writing all of [17:19] their code using Claude for the first [17:21] time. And that that was actually the [17:22] moment for me where I just uninstalled [17:24] my IDE cuz I wasn't using it anymore. [17:26] Wow. And so like for me that's the same [17:28] moment when Claude started to write all [17:30] the code. [17:31] The leap from Opus 4.8 to Fable [17:35] feels to me like a leap of at least that [17:37] same size. And I think it might be even [17:39] a larger leap in model capability. [17:42] For me Fable is um [17:45] it it's just like it has this like [17:46] nuance and dimensionality and kind of [17:49] like way of thinking about things that [17:51] is kind of like similar to like my [17:53] smartest co-workers. It's not just like [17:55] a blunt instrument the way the previous [17:57] models were where it doesn't understand [17:59] nuance. It it's actually like really [18:01] able to grapple with a problem. And this [18:03] is useful for all sorts of things from [18:04] like data analysis cuz there's a lot of [18:07] nuance there and you have to understand [18:08] like you know, you have to ask why like [18:10] three times to get to the bottom of a [18:11] question. Fable just naturally does [18:13] this. [18:14] Um it's useful in debugging where you [18:16] have to form a hypothesis and you have [18:17] to kind of like chase down that [18:18] hypothesis. Look for evidence. It's able [18:20] to do this really well. And for coding [18:24] I feel like I actually just ran out of [18:25] hard problems to give it. [18:28] Like I I just couldn't think of a harder [18:29] problem. Like every problem that I gave [18:31] it, it essentially one shotted or maybe [18:33] like few shotted with a few prompting. [18:35] With a with a little bit of prompting. I [18:36] just kind of ran out of hard problems [18:38] and this is something that I heard from [18:40] a lot of the team also. [18:42] So yeah, it's like it's it's a it's [18:44] quite a big step. [18:45] >> Is Claude code just basically 100% [18:47] written by Claude code at this point? [18:49] >> Yes. Uh that has been the case again [18:52] since November of last year. [18:53] >> Oh, so it wasn't even like with Fable, [18:54] it was like with Opus 4.5. [18:56] >> Yeah, with Opus 4.5. Yeah, that's true [18:57] for Claude code, that's true for [18:59] co-work, it's true for an increasing [19:01] number of [19:02] Anthropic's products. I think I think [19:03] across all of Anthropic um 80 to 90% of [19:06] the code is written by Claude code on [19:09] average. But actually for a larger and [19:11] larger share of teams, it's just 100%. [19:14] >> I also heard that um Fable is like more [19:17] expensive, but it's it's also a little [19:19] slower, but it's also like incredibly [19:21] intelligent, like you said. How do you [19:23] Do you Do you just use Fable for like [19:25] all of your tasks, or do you use like Do [19:26] you drop down to like Opus or Sonnet for [19:28] different kind of use cases? [19:30] >> Yeah, I use Fable for everything. Just a [19:32] feel for everything. Is it because [19:33] Anthropic has no [19:34] >> budget? [19:35] >> [laughter] [19:38] >> So, you know, like I don't [19:40] >> topic, we do actually think about token [19:41] use, right? [19:42] >> Yeah. [19:42] >> Like, you know, like we we essentially [19:43] make the tokens. [19:44] >> Yeah. [19:45] >> Um but they're not free for us because [19:46] every token we use is a token we do not [19:48] give to a customer. Right. So, there's [19:49] an opportunity cost. [19:51] Um [19:53] when I think about it, it actually maybe [19:54] comes back to ROI. So, like when you [19:56] think about kind of ROI for something [19:57] like Fable, you can reduce the [19:59] investment maybe like 50% or something [20:01] if you use like, you know, Fable with an [20:03] advisor model or, you know, use Opus by [20:05] default and have a call out to Fable [20:07] when it needs. So, there's like all [20:08] sorts of ways to optimize usage, and as [20:10] new models come out, you have to kind of [20:11] keep tuning the way they optimize this [20:13] usage. It's actually quite a bit of work [20:14] to keep up with it and to keep that you [20:16] have to like run evals to make sure it [20:17] works pretty well. [20:19] Um although, you know, like you can use [20:20] advisors. That's kind of the recommended [20:22] out of the box approach. [20:24] But I I actually think that if you think [20:26] about ROI, there's probably like 50% [20:28] chance to reduce the investment, but [20:31] probably like a thousand percent [20:32] opportunity or even hundred thousand or [20:34] ten thousand, whatever, percent [20:35] opportunity to increase the return. [20:38] And so, what I would think about is just [20:39] use the most expensive model and focus [20:41] on how do I get more out of it? How do I [20:43] increase the return? Do not focus on [20:45] cost cutting. It's just like it's so [20:47] early in kind of like the adoption of [20:50] this technology to think a lot about [20:51] this. And you probably want to spend [20:52] like some effort on cost cutting, and [20:54] like you definitely want to make sure [20:55] costs are under control and kind of [20:56] well-governed. But I would focus almost [20:59] all your effort on increasing returns. [21:01] >> Yeah, focus on the upside more than like [21:02] the potential downsides, essentially. [21:04] >> Exactly, because there's so much more [21:06] upside right now than there is uh than [21:08] there is kind of like room to optimize [21:09] the downside. [21:10] >> Yeah. Hopefully we the rest of us get [21:11] access to fuel soon so we can kind of [21:13] all explore [21:14] that as well. Okay, I think [21:17] we got a decent amount of questions. [21:19] Actually there's 107 questions. We're [21:21] obviously not going to get through all [21:22] of them, but I'm going to handpick and [21:24] kind of like MC some of the top voted [21:25] questions that we got here. [21:27] So Andrew kind of the top voted question [21:30] here is saying, "What is quad code doing [21:32] to improve collaboration? Currently it [21:34] feels like a solo work product with only [21:36] awful things like GitHub for working [21:37] with others." Well, that's a [21:40] interesting question. What do you think? [21:41] >> Yeah, [21:43] you know, we have a bunch of stuff in [21:44] the fire that that we're that we're [21:46] cooking up. [21:47] So hopefully we'll have something there [21:49] soon. [21:50] In the meantime, the thing that I would [21:51] recommend is use an MCP [21:54] to hook up quad code to slack or to [21:57] teams or to G chat or whatever you use [22:00] for cooperation. [22:02] >> Sounds good. [22:04] The next voted question was, "Since [22:06] agents can do most of the code now, [22:08] where should engineers focus most?" [22:11] Kind of touched on this earlier, but [22:13] yeah, curious. [22:14] >> Yeah, yeah. So you know, like as we [22:16] think about like what engineers do, one [22:19] of the things that we do is coding, but [22:20] we do like a lot of stuff that's not [22:21] coding. All right, so we do um [22:24] you know, like talking to customers, [22:25] coming up with ideas, jamming on stuff [22:28] with with with designers and PMs, doing [22:30] data analysis, [22:32] figuring out what to build next, [22:34] aligning with other parts of the org. [22:36] There's just like all sorts of things [22:37] that we do as engineers. [22:39] I think over time the model will be able [22:41] to do all of these things better than we [22:42] better than we can. [22:44] We are not there yet. [22:45] And so I think in the meantime, like the [22:47] model does the coding, but someone has [22:50] to prompt the model. [22:52] And figuring out what prompt to give the [22:55] model, there's actually like a lot that [22:57] goes into that, right? Like you have to [22:58] kind of figure out what's the next [22:59] thing. You have to do the market [22:59] research. You have to talk to your team. [23:02] You have to do all this other work. Um [23:04] so yeah, it's it's kind of all all these [23:06] other things. [23:07] >> Yeah, and then I think like you said [23:08] with loops, too, that's also [23:10] progressively moving up the abstraction [23:12] layer, where maybe at some point for [23:13] some certain cases, you don't even [23:15] actually need a prompt. And so, I think [23:17] it's interesting, like I said earlier in [23:19] in this in this conference, is like [23:21] we're in this like transformational [23:22] stage. We're all figuring this out [23:24] together as an industry. Um we also see [23:27] have seen at Meta that like like you [23:28] said, it's actually a minority of an [23:31] average software engineer's time is [23:32] actually spent coding. It's all the [23:34] other things that kind of happen [23:35] upstream and downstream with it, whether [23:37] it's like managing your code [23:38] deployments, or if it's like [23:40] collaboration, and working kind of like [23:42] in docs and planning. And so, I think [23:44] this is kind of like where [23:46] where like Claude and other other apps [23:49] and products for AI is just thinking [23:51] about how can we just accelerate the [23:53] whole development life cycle. This is [23:54] something that we're we're largely [23:56] solving now with coding, and we're going [23:58] to continue doing so, but then the [23:59] upstream and downstream parts of [24:01] development life cycle is still still [24:02] the thing we're discovering. [24:03] >> Yeah, yeah. And like like coding, I [24:05] think was always the minority of the [24:06] time, right? [24:07] >> been, yeah. [24:08] >> And for me, it's like sometimes it's [24:09] like really fun to code and like write a [24:11] bunch of code by hand, and then [24:12] sometimes it's just like a total slog. [24:14] And you know, like I never wanted to do [24:15] it by hand in the first place. [24:16] >> Yeah. [24:17] >> Um I heard the Twitter laughing. [24:19] >> [laughter] [24:21] >> Yeah, yeah. [24:22] Um and so like, you know, like sometimes [24:24] like when I don't have, you know, Wi-Fi [24:26] on like an airplane or something, I'll [24:27] I'll still like write code by hand like [24:28] just for fun. [24:30] But it's uh it's actually like not [24:31] something that I personally really miss. [24:33] It it feels to me like Claude code is [24:35] just like this like jetpack, where like [24:37] as the model gets better, I get like [24:39] more jets or something in my jetpack, [24:41] and I can go faster and faster. And at [24:43] this point, I'm like purely bottlenecked [24:45] on how fast I can prompt. And most of my [24:48] prompting now is actually just like [24:49] audio, like talking to Claude. And how [24:52] and and being bottlenecked on good [24:53] ideas. But but coding is just no longer [24:56] the the bottleneck. [24:57] >> Right. And this is kind of like what a [24:59] lot of conversations have been about is [25:00] like what is the role of software [25:01] engineering? It's like less and less [25:03] about the coding aspect and more about [25:05] sort of like how you supervise these [25:07] agents, how you sort of manage the agent [25:09] end-to-end, and help generate and [25:11] product productize some of the ideas [25:12] that you have. [25:13] Um [25:14] I think related to that is like, you [25:15] know, with the explosion of AI-generated [25:17] code, everyone's just like writing code [25:19] so quickly now with AI. How does How How [25:22] do you or Anthropic sort of like handle [25:24] the downstream impacts of that? So like [25:26] with code review, right? Like I think a [25:27] lot of a lot of companies require a a [25:30] human code review. That paradigm may or [25:32] may not be actually breaking or shifting [25:34] because of the increased supply from [25:36] upstream. How are you thinking about [25:37] that? [25:38] >> Yeah. So when we think about code, [25:41] essentially like you you write code and [25:44] then it it it gets to production and [25:46] then hopefully it drives a business [25:47] metric for you like like revenue or [25:49] usage or whatever whatever it is that, [25:52] you know, like whatever business metric [25:53] you care about. [25:54] When you think about this process, [25:56] there's all sorts of different [25:57] bottlenecks and the biggest bottleneck [25:58] used to be coding. [26:00] We've now solved that bottleneck and, [26:02] you know, at Anthropic and for a lot of [26:04] our customers that, you know, have [26:06] adopted Claude Code for a bit, they're [26:08] getting to this point also. [26:10] And so like now we're thinking about the [26:11] next bottleneck and, you know, for us [26:13] the next bottleneck was code review. You [26:14] write a lot of code, now someone has to [26:15] review it. [26:16] And our answer was to build a product [26:18] for this and so we built this product, [26:20] it's called Claude Code Review. It's [26:22] available to anyone. Um you can use it. [26:26] It is the the exact same code review [26:27] product that we use internally at [26:29] Anthropic for every single pull request. [26:31] It is different than any other code [26:34] review product on the market [26:36] because it's a lot more expensive. [26:39] And the reason it's a lot more expensive [26:41] is it uses a large number of tokens to [26:44] fully automate the code review. [26:46] So by the time that I see a pull request [26:49] as an engineer, there's essentially a [26:50] guarantee that all the bugs have been [26:52] caught. And it's not, you know, it's [26:54] it's not 100%. We're still working on [26:56] improving it, but it's like, you know, [26:57] like 98, 99% of the bugs. So, like when [27:00] I look at the code, essentially, like [27:01] I'm not looking for bugs anymore. I know [27:03] there's no bugs cuz Claude caught it and [27:05] Claude fixed it. Um the next thing is [27:07] like, is this a pull request that should [27:09] exist? Is this a good idea? [27:11] The next bottleneck for us was security [27:13] review because you're running all this [27:15] code, you need it to be secure. Um you [27:17] know, like agents can introduce [27:19] vulnerabilities the same way that people [27:21] can. And so, how do you make sure the [27:22] code is really good and secure? [27:24] And the answer for the for us is the [27:26] Claude is is is the Claude security [27:28] product. And again, like we we built [27:30] this internally to solve our own [27:32] problem, to solve our own bottleneck. [27:34] And what it does is every week [27:36] we run it and it scans over all of our [27:37] codebases, it finds issues, and it fixes [27:40] them autonomously. [27:42] And we're actually at the point now [27:43] where, you know, we we we do red teaming [27:45] and we do penetration testing for like [27:46] every big new feature launch to make [27:48] sure that it's secure. And we're we're [27:49] actually getting to the point where [27:51] Claude security is catching issues that [27:53] even pen testers didn't catch. [27:55] >> Oh, wow. [27:56] >> This didn't used to be the case. We've [27:57] had this product for a bit, but because [27:59] of the model with Opus 4.8, it's now [28:01] starting to get to that point. [28:03] And so, you know, like this was the next [28:05] bottleneck. And so, you know, we solved [28:07] it. And again, we make this available to [28:08] our product, so as a product so [28:10] customers can use the same product, too. [28:12] And this is just like the Claude [28:13] security product. [28:15] And, you know, now we're thinking about [28:16] the next bottleneck. And the next [28:17] bottleneck might be like idea [28:19] generation. Um it might be like [28:21] optimizing CI to make it kind of scale [28:23] better. [28:24] And so, like in a for example, a thing [28:25] that I did last night is um I noticed [28:27] that our CI was a little bit slow. [28:29] And so, what I did is I I had Claude [28:31] code run and I said, "Use a workflow [28:35] to look at my data, [28:37] look at real CI timings from, you know, [28:39] like you know, from from the data set, [28:41] and optimize CI to make it much faster." [28:43] That was my prompt. That was the entire [28:45] prompt. [28:45] >> That's it? [28:46] >> That's it. [28:46] >> [laughter] [28:47] >> Um it used a dynamic workflow, which is [28:49] this new feature that we launched a few [28:50] weeks ago where essentially the model [28:52] kind of orchestrates uh dozens, [28:54] hundreds, thousands of sub agents [28:55] dynamically. It's essentially like a [28:57] form it's a new form of test time [28:59] compute. [29:00] And uh it used I think something like uh [29:03] you know like like a few a few million [29:05] tokens and it ran for like a few hours. [29:07] And it produced four power quests [29:10] that reduce the eye time by 50%. [29:13] And so I I landed those last night. And [29:15] you know like this is work, you know, [29:16] that would have taken days or you know [29:18] weeks or months in the past to do all [29:20] this kind of profiling and this is just [29:22] like, you know, it's just the next [29:23] bottleneck and we can use Claude for it, [29:24] too. [29:25] >> That's crazy. So you basically, I mean, [29:28] the way you just described all [29:29] everything since we started is like just [29:31] keep going after the next bottleneck, [29:32] keep going after the next bottleneck. So [29:34] far in the base model is just keep like [29:36] just has the underlying capabilities to [29:38] be able to progressively solve it. Um so [29:40] that's really cool. I think um [29:42] it's actually a good segue into the next [29:45] question that I wanted to ask, which is [29:46] like what is the next big thing for you [29:49] and your team? Like what is your vision [29:50] for the next year? I mean, kind of [29:52] mentioned like just solving bottlenecks [29:53] and bottlenecks um as they as you come [29:55] across, but like what is the vision for [29:57] Claude code over the next year? [29:59] >> Yeah, so okay, as a caveat, we plan on [30:02] like a weekly or monthly cycle. [30:05] We don't have a one-year plan. [30:07] >> [laughter] [30:07] >> Um this space is changing too fast. So [30:09] like the exponential is the exponential [30:12] is crazy. You just like you have to hang [30:13] on and plan like a little bit at a time. [30:17] Um broadly, the direction for us is very [30:19] similar to the direction from before, [30:22] you know, like from the last year or [30:23] from the last two years. It's we want to [30:25] be the most capable uh agent. We want to [30:28] work anywhere. So wherever your team [30:31] works, Claude works. [30:33] You don't have to like switch to our, [30:35] you know, full stack to to use it. [30:37] And we want to let people experience the [30:41] capabilities that the new model brings [30:44] in a way that other products don't [30:45] really let you experience. And this is [30:48] something that we realized a couple [30:49] years ago, you know, song 3.5 was a [30:51] quite a big leap in coding, but we felt [30:54] like there weren't really a lot of [30:55] products that let you fully experience [30:57] that week. [30:58] And so Claude code was like a way to get [30:59] at that. It was that the idea was like, [31:01] okay, no more source code, you're just [31:02] using an agent. That's the way that you [31:04] experience this. And as we think about [31:06] the model over the next few months, over [31:07] the next year, it's going to get even [31:10] better at long running work. [31:12] Um you know, like Claude is already by [31:14] far the best at long running work. That [31:16] lead is going to increase, I think. [31:18] The code is going to become more secure. [31:19] It's going to become higher quality. [31:22] And the model is going to become even [31:24] better aligned. [31:25] So whatever your intent is as the user [31:28] of the model, as an engineer or a [31:30] product manager or a designer that's [31:32] using the model, the model will be even [31:34] better at expressing that intent. And so [31:36] like we're going to be kind of like [31:38] looking at these capabilities. We're [31:39] going to be looking at like what are the [31:40] products that we can build [31:42] to let people experience this in the [31:44] easiest way possible. [31:47] >> Nice. [31:48] Um Reza asks a question here that I [31:51] thought was really good, too. Coding in [31:52] large-scale projects is not the biggest [31:54] problem. Maintenance is. [31:56] How should the code be maintained in [31:58] long term? Like how do you guys deal [31:59] with maintenance? [32:00] >> Yeah, so with something that I've been [32:02] experimenting with is uh actually using [32:04] like loops for maintenance. [32:05] >> Loops for maintenance. Can you share [32:07] more? [32:07] >> Yeah, so like so one example is um you [32:10] know, like you you can have Claude code [32:11] running in a loop to be like [32:13] uh look at the code base and improve the [32:16] architecture. [32:18] Or look at the code base and uh find [32:21] places where the test suite is, you [32:23] know, flaky and improve it. So, you [32:27] know, to get rid of the flakes. Or find [32:29] instances of tests that are not useful [32:31] that we can just like delete. Um or, you [32:33] know, like look at the code base, look [32:34] for duplicated abstractions and unify it [32:37] into a single abstraction. And so these [32:39] are actually like all loops that I have [32:41] running. [32:42] >> Do you So like in those cases do you [32:44] check or review what the code does [32:46] before they delete or make any changes [32:48] or you're just kind of they just send [32:50] out PRs and you're just like reviewing [32:51] them after they run the loop? [32:53] >> Yeah, it's the second one. So I just [32:54] look at the PRs. [32:55] >> You just look at it the change after [32:56] they made it. [32:57] >> Exactly, exactly. For problems like this [32:58] it's actually like quite easy I think [33:00] for Claude to kind of wrap its head [33:01] around these these shape problems so [33:03] it's usually quite good. [33:05] >> Yeah. [33:05] >> If you use the latest model and if the [33:06] result isn't good, all you have to do is [33:08] say, you know, like look for [33:10] opportunities to improve the quality of [33:11] the code base and then just add the [33:13] magic words [33:14] use a workflow. [33:15] >> I thought you were going to say make no [33:16] mistakes. [33:18] >> [laughter] [33:19] >> I thought that was going to be the [33:20] answer. [33:21] >> But yeah, it's like essentially like you [33:22] say use a workflow and it'll throw more [33:23] test time compute at it and it'll give [33:25] you a much better result. [33:26] >> Yeah. That's really cool. Workflows is a [33:28] pretty new concept. I think I saw an [33:29] announcement about it. I don't know how [33:30] many people here are familiar with it [33:32] but it seems like another one that we [33:34] should be watching out for. Like is [33:35] there is there a quick summary of the [33:37] difference between workflows and loops [33:38] or is it kind of like the same thing? [33:40] >> Um yeah, it's like it's fairly [33:42] different. So the way I would think [33:43] about it is, you know, like there's [33:45] these traditional scaling laws in AI and [33:48] you know, there's this like scaling laws [33:49] paper a while back that kind of [33:51] introduced this idea that the way that [33:53] transformer scale and the way that LLM [33:55] scale is it's a function of the the [33:57] data, the size of the neural network, [33:59] and the amount of compute that used to [34:00] train the neural network. And so like [34:02] this is this kind of exponential [34:03] property of the model. This is why [34:05] intelligence keeps increasing [34:06] exponentially is because of these three [34:08] scaling factors. [34:10] Over the last couple years what's [34:11] happened is we've actually added a [34:12] fourth factor which is test time [34:13] compute. And essentially what this is [34:15] what test time compute is actually just [34:17] a fancy way of saying how many tokens [34:19] does the model generate. That's it. So [34:21] there's a way to like make it so the [34:23] model can productively generate more [34:24] tokens [34:25] in order to achieve a better outcome. [34:28] There's a few ways to do this. One is [34:29] effort settings. And so you know, for [34:32] Claude models, there's like low effort, [34:34] medium, high, extra high, max. This is a [34:36] way to configure how many tokens [34:37] essentially you want the model to [34:38] output. This is tuning the test time [34:40] compute behavior. The more tokens, the [34:42] better the result. [34:45] The second way to do it, which we just [34:46] introduced, is dynamic workflows. And [34:47] this uses Claude to essentially write a [34:50] little kind of like program that's [34:52] running actually in a virtual machine to [34:54] orchestrate other Claude's [34:56] to solve a problem. It's a new form of [34:59] test time compute that we're still just [35:00] exploring, but essentially it's a way [35:02] for Claude to, you know, launch dozens, [35:05] hundreds, thousands of agents to get [35:08] work done. [35:10] >> Wild. [35:11] Awesome. [35:12] Um okay, next question. What are some of [35:15] the hard problems that Fable has had a [35:17] hard time to solve? [35:19] >> Yeah, I think that, you know, like our [35:20] models are not perfect. And there's a [35:23] lot of, you know, places where they [35:24] still need to improve. [35:26] Um one of the places is product sense. [35:30] So, I still come up with better product [35:32] ideas than Fable does. [35:34] >> So, idea generation. [35:35] >> Idea generation. [35:36] >> Yeah. [35:36] >> Yeah, it's not there yet. [35:37] >> that. Okay. [35:38] >> Um its code is now better than the code [35:40] I would have written. Its front end [35:41] design is better than my design. [35:44] Um another place where I think I'm still [35:47] a lot better than Fable is is [35:48] distributed system design. So, kind of [35:50] thinking through like, what are the [35:51] services? How do we organize it? How [35:53] does data flow? How do we like think [35:54] about load factors and things like that? [35:57] Um this is a place where I think Fable [35:58] is still there's still a lot of [36:00] opportunity to improve it. [36:01] >> How many more months before that's not [36:03] true anymore? [36:06] >> Um [36:06] >> Or weeks? Or days? [36:08] >> No, I I don't like giving predictions, [36:09] but I would I would say by probably by [36:11] the end of the year, it'll it'll be [36:12] quite good. [36:13] >> Okay. All right. [36:15] We heard it here. Um [36:16] we're approaching the last few minutes, [36:18] so I'm going to probably close this out [36:19] with this last question here. [36:21] This is a question from Andrew. He asks, [36:24] "How do you prevent engineers from [36:25] getting lazy and accepting everything [36:26] they output in Claude. [36:29] >> There's a couple ways to think about it. [36:31] Um [36:34] One I I think there's like maybe like [36:35] two parts to this question. [36:37] I think one part is [36:40] how do you make sure that the output is [36:41] really good and that people are kind of [36:42] doing the right thing. [36:44] Um one one way we think about this is [36:46] how do we get Claude to do the right [36:47] thing so you don't have to. [36:49] And like an example of this is um you [36:51] know like since the beginning we've had [36:52] these permission prompts for for Claude [36:54] code. And you know like the the prompt [36:56] like anytime Claude wants to run a [36:58] command on your computer, it asks you is [36:59] it okay to run this yes or no. [37:01] Um you know like can I run this bash [37:02] command? Can I use this MCP? Can I fetch [37:05] this URL in a browser? Yes or no. [37:07] And an engineer sitting there has to [37:09] approve it or decline it and say yes or [37:11] no. [37:12] And um [37:14] something that we found is over time it [37:16] felt like you get kind of like a little [37:18] lazy and you know at least for me I just [37:20] like kept saying yes. I wasn't really [37:21] reading the commands. [37:24] And I'm sure this is kind of true for a [37:25] lot of people. I don't know if like you [37:26] admit this to your boss, but [37:28] >> [snorts] [37:30] >> And and so like our security people [37:31] actually saw this and they were like hey [37:33] like there's a human in the loop. The [37:35] goal of that human in the loop was to [37:36] improve security. [37:38] But actually what's happening is that it [37:39] is hurting security because people are [37:41] just like they have this like prompt [37:42] fatigue. They just like keep saying yes [37:44] without actually reading the details. [37:46] And so the thing that this led us to [37:47] build is auto mode [37:49] which is a new permission mode in Claude [37:51] code. This is what we use internally at [37:52] Anthropic and actually now like the vast [37:54] majority of our users use it also. And [37:56] what this is is every permission prompt [37:58] that we route to a model [38:00] and the model decides yes or no based on [38:02] what you've said so far in that [38:04] conversation. [38:05] And not only is it more secure and we've [38:09] kind of shown that the results are [38:10] better than dangerous mode and better [38:12] than the default yes no permission mode [38:14] because of prompt fatigue. [38:15] But it's actually like kind of one less [38:16] thing I need to do as an engineer. [38:19] And so the thing that it unblocks is [38:20] very long running agents. Because you [38:22] don't have to sit there saying yes or [38:23] no, it means I can now run Claude for [38:26] hours or for days. And there's all sorts [38:29] of benchmarks that show that, you know, [38:30] like Claude is the best at these kind of [38:32] long-running tasks. [38:33] And of course, you know, like there's [38:34] years of research that went into making [38:36] auto mode working because like [38:38] uh that that made it work because like [38:40] if you look at, you know, a Claude [38:41] models, they're essentially not [38:42] resistant to prompt injection anymore. [38:44] They're they're not susceptible to [38:45] prompt injection anymore. [38:47] And this is a thing that I think [38:48] surprises people sometimes, but if you [38:49] look at our system cards, the success [38:51] rate at 100 attempts is like around 1%. [38:54] It's just by far the best in the [38:55] industry. [38:57] And when you take this and combine it [38:58] with a prompt injection classifier, [38:59] which we run for a large share of [39:01] traffic now, essentially the models are [39:03] not susceptible to this kind of attack [39:04] anymore. And what this enables us to do [39:06] is ship auto mode. And what this means [39:08] is that as an engineer, I don't have to [39:10] sit there and say yes or no. [39:11] So, this is I think like part one [39:14] answer to the question, which is [39:16] let Claude do more and figure out how do [39:19] you unblock Claude to do more safely [39:21] rather than trying to control yourself. [39:24] I think the second thing is kind of like [39:26] what is the feeling day-to-day as an [39:28] engineer when you're not writing the [39:30] code anymore? How do you still learn? [39:32] How do you still stay in the loop? And [39:34] actually one thing that I found really [39:35] powerful for this is output styles in [39:37] Claude code. [39:38] Whenever any new engineer joins our [39:40] team, we tell them to use the [39:41] exploratory output style. So, this is [39:43] just like {slash} config output style [39:45] equals exploratory. You run this in [39:47] Claude code or you can ask Claude to set [39:48] this for you. [39:49] And what it does is that anytime Claude [39:51] will make a change, it'll explain to [39:52] you, "Hey, here's how the architecture [39:54] works. Here's how this language works if [39:56] you haven't used it before. Here's how [39:57] this part of the code base works." It'll [39:59] explain to you so that you can learn. [40:01] And then there's also a learning output [40:02] style which you can use, and this is for [40:03] people that are not coders. [40:06] And it'll explain to them, "Hey, here's [40:07] like how this language works. Here's [40:09] like, you know, like at a very basic [40:10] level, it's going to teach you how to do [40:13] the thing instead of doing the thing." [40:15] So, it'll say, "Okay, in JavaScript, you [40:16] know, for example, here's how something [40:18] works. I'm not going to make the change [40:19] for you. [40:21] I'm going to walk you through it. Step [40:22] one is open this file and edit it in [40:24] this way. Step two is run this command. [40:26] Okay, I see you done that. Step three is [40:28] do this." So, actually, I think like [40:29] output styles and using Cloud even more [40:33] are a super powerful powerful learning [40:35] tool. And it helps me as an engineer [40:37] kind of understand what's going on even [40:40] as our stack changes as our infra [40:41] changes. And especially when I'm working [40:43] in new languages. [40:46] >> Awesome. [40:47] Well, we're at time. It's been Like I [40:50] said, it's a very interesting time in [40:51] our industry, and it's been a privilege [40:53] to have Boris here working on Cloud Code [40:55] share some of his thoughts. Um and yeah, [40:58] let's give a round of applause to them. [41:00] Thank you so much. [41:01] >> Yeah.