铃阅
❌

阅读视图

软件工程师当下该做什么

Scott Bolinger 2026-11-13 08:00 福建

AI 把 "写代码" 变成了廉价品,工程师的稀缺性正在从技术实现转向判断力、产品感与对人性的理解。

I've heard some people say that you should keep learning code and tech stacks to stay relevant as a SWE. I disagree.

我听到有人说,想要作为软件工程师不被淘汰,就应该不断学习代码和技术栈。我不敢苟同。

Each new model release is making those skills less and less valuable. Every day I feel more like a product person who manages Al, and the need for deep technical knowledge decreases. The moats I thought existed have all dried up, it's now better to prompt a model with a user story than a technical plan.

每一次新模型的发布,都在让这些技能愈发贬值。我日益觉得自己更像一个 "管理 AI 的产品人",对深厚技术功底的依赖正在减少。我曾以为存在的那些护城河,如今已尽数干涸 —— 比起写一份技术方案,直接用一个用户故事去提示模型反而更有效。我的工作所需的技能,正变得越来越不 "技术",而越来越 "人性"。

The skills I need for my job are becoming less and less technical, and more human.
Sometimes I get bummed out that Al is solving the problems I used to, like creating SaaS software. I get a lot of joy out of working hard on an app and seeing it come to life. Seeing the skills I learned become almost worthless is demotivating. Building a SaaS app used to be a hard problem, that's why I loved it. It's not a hard problem anymore, so I need to move to where there's hard problems again. I need to think bigger.

有时我也会怅然若失:AI 正在解决那些我曾引以为业的难题,比如开发 SaaS 软件。为一款应用殚精竭虑、看着它从无到有地诞生,曾是我莫大的乐趣。眼睁睁看着自己苦学的技能变得近乎一文不值,着实令人沮丧。开发 SaaS 应用曾是一道难题 —— 这正是我热爱它的原因。而如今它不再是难题了,所以我必须奔赴新的难题所在之处。我需要把格局放大。

One of my favorite books is the Beginning of Infinity, one of my takeaways is that there is no end to human innovation: "everything that is not forbidden by the laws of nature is achievable, given the right knowledge." When we create a new thing, 1000 other new things become possible. The invention of the computer made a lot of jobs obsolete, but it eventually created so many more.

我最喜欢的书之一是《无穷的开始》(The Beginning of Infinity),其中一个让我深受启发的观点是:人类的创新永无止境 ——"凡是自然法则未曾禁止之事,只要拥有正确的知识,皆可实现。" 每当我们创造出一样新事物,便会有一千样新的可能随之涌现。计算机的发明淘汰了许多职业,但最终催生出的职业远比消失的多得多。

Al is an incredible innovation that allows us to do more, which requires new thinking. My old ways of thinking tell me a SaaS app is a big thing, but it's not. Complex enterprise level software is now easier to make than a simple website was 5 years ago. Big now is thinking on a much larger scale, national, global, cosmic. If you had a team of 100 software engineers, what could you build? What about 1000? We now have that for pennies on the dollar, we have to think bigger than apps.

AI 是一项了不起的创新,它让我们得以成就更多,但这也要求我们换一种思维方式。按我旧有的思维,一个 SaaS 应用已算得上宏大,但事实并非如此。如今开发复杂的企业级软件,比五年前搭建一个简单网站还要容易。今天的 "宏大",意味着在更高的尺度上思考 —— 国家级、全球级,乃至宇宙级。倘若你手握一支百人的软件工程师团队,你能打造出什么?一千人呢?如今我们能以九牛一毛的成本获得这样的力量,我们的眼界必须超越 "应用" 本身。

We also need to think bigger about our range as engineers. We need to expand beyond technical skills, to understand the whole business stack: product, marketing, and sales.

我们还需要以更宏大的视野看待工程师的能力边界。我们必须突破纯技术的藩篱,去理解完整的商业链条:产品、营销与销售。

My approach to staying relevant now is to learn things Al can't help with: product positioning, creativity, delighting humans, psychology, marketing, etc. These are human problems Al can never solve on its own, because there are no simple answers or tests to train on. Al is great at pattern matching, but it will never understand what it's like to be a human. That is where our value is, and I'm doubling down.

我如今保持竞争力的方法,是去学习那些 AI 无能为力的领域:产品定位、创造力、取悦人心、心理学、市场营销等等。这些是 AI 永远无法独自解决的 "人的问题",因为它们没有标准答案,也没有可供训练的测试集。AI 擅长模式匹配,却永远无法体会身为人类是何种滋味。我们的价值正在于此 —— 而我,正在加倍下注。

来源:https://x.com/scottbolinger/status/2120897438001283512

阅读原文

跳转微信打开

  •  

【第3735】从月中断粮到绰绰有余:AI编程省Token全攻略

Daniela Baron 2026-07-31 09:10 日本

一份实用指南,介绍在日常使用 Claude Code 作为AI编程助手时,如何通过工具、设置和习惯来降低 token 消耗。

前言

用 Claude Code 写代码写到月中就被限流?本文分享一套经过验证的工具组合与使用习惯 —— 从压缩命令输出、精简模型回复,到审计项目配置文件、合理切换模型 —— 帮你在不牺牲开发效率的前提下,大幅降低 Token 消耗,告别月中断粮的窘境。今日前端早读课文章由 @Daniela Baron 分享,@木瑾编译分享。

用于解决实际工作中的如何降低企业级大模型 API / Agent 使用成本 问题,最值得借鉴的一点是:将静态上下文改为 “条件触发加载”(如优化 CLAUDE.md),避免无意义的全量历史重复发送。

译文从这开始~~

如今我几乎所有的工程工作都交给 AI 来完成:分析、设计、编码、代码审查、线上问题排查、撰写文档。公司团队用的是 Claude Enterprise 版,我一直以为这意味着不用操心用量和额度的问题。然而月中的某天,我正在一个会话中工作,Claude 突然弹出了这条报错:

您已达到组织的月度消费上限・请联系管理员前往 claude.ai/admin-settings/usage 提高额度

Claude Code token 耗尽提示

我在 Slack 上问了一嘴有没有人遇到同样的情况,结果发现团队里好几个工程师都在月中差不多同一时间撞上了这堵墙。有人告诉我,Claude 桌面端其实有个人用量仪表盘,而我完全不知道 Enterprise 版也有这个功能。工作区管理员也给每个人加了一些 token 额度,暂时缓了口气。但现在我能看到仪表盘、能实时观察消耗速度之后,很明显即便加了额度,也撑不到月底。

那一刻我意识到,这样下去不是办法。这篇文章记录了我后来摸索出的一套工具和技巧,成功降低了 token 用量,同时没有牺牲质量,也没有拖慢节奏。

监控用量

用量仪表盘

首先要知道的是,你可以直接查看自己的用量。在 Claude Desktop 中,点击左下角你的名字,然后依次进入 "设置" 和 "用量"。自从那次月中惊魂之后,我一直把这个页面开在旁边的窗口里。下面是我个人 Pro 版的截图,Enterprise 版操作流程类似:

Claude Desktop 用量概览与仪表盘

Claude Monitor

Claude Code Usage Monitor 是一个独立的命令行工具,能让你实时观察滚动 5 小时会话窗口内的消耗速率。它并不连接你的账户,所以显示的是估算值,不是真实数据。你可以告诉它你所在的套餐类型(没有 Enterprise 选项,但有个 "自定义" 套餐可以手动配置),它会展示一些信息,比如按当前速率预测你何时会耗尽额度。把它当作对消耗速度的直觉参考就好,别指望精确到个位数。它会聚合当前机器上所有活跃的 Claude Code 会话,所以显示的消耗速率和预测反映的是所有会话的总和,而非你当前正在操作的那一个。

我在 VS Code 里开了一个终端窗口专门跑这个工具,就放在 Claude Code 终端旁边。下面是示例截图:

Claude Code Usage Monitor 终端运行截图

输入 token 与输出 token

在介绍优化用量的工具之前,有必要了解一个基本概念:计费分为两个部分 —— 输入 token(发送给模型的所有内容:你的提示词、对话历史、加载的文件或上下文)和输出 token(模型生成并返回的内容)。两者的定价不同,输出 token 的单价通常高于输入 token。

工具

以下是我安装的几款专用工具,分别针对 token 管道的不同环节:输入、输出和搜索效率。

rtk

rtk(Rust Token Killer)用来节省输入 token。它充当常见命令行工具的代理。举个例子,当 Claude 执行 git log 这样的命令时,原始输出不会直接进入对话,而是由 rtk 拦截,执行真正的命令后返回一个精简版本。实际发送给模型的就是这个精简版本。

下面的截图展示了我某个项目的 git log 输出。左侧是原始输出(已截断,实际还有更多内容需要滚动),右侧是 rtk git log 的版本。可以看到精简了多少。

git log 经 rtk 压缩前后的输出对比

把这个效果乘以 Claude 在编码会话中通常执行的所有命令,节省的量相当可观。你可以用 rtk gain --daily 查看节省情况。例如:

rtk gain daily 输出,展示 token 节省量

节省量表格中的 "Input" 和 "Output" 列指的是命令输出在 rtk 压缩前后的大小,而非模型计费意义上的输入 / 输出 token。虽然用词相同,但含义完全不同:表格中的 "Input" 是 shell 命令的原始 stdout,"Output" 是压缩后实际发送给 Claude 的精简版本。

例如,表格显示 5 月 23 日那天我执行了 221 条命令,产生了 102.3K 的原始输出 —— 如果没有使用 rtk,这些内容会全部发送给模型。但 rtk 拦截并压缩了这些输出,最终只有 70.4K 被实际发送给模型。这意味着仅命令执行这一项就节省了 32.1K(31.4%)的输入 token。

Claude 是怎么知道要调用 rtk 的?

如果你好奇 Claude 如何知道使用 rtk:安装时会在用户级别的 ~/.claude/CLAUDE.md 中添加一条引用,像这样:

 @RTK.md

这个 @ 引用告诉 Claude 加载 RTK.md,其中包含何时以及如何将命令路由到 rtk 的具体指令。这样设置是为了让它在每次对话中都自动生效。

安装过程还会在同目录下生成 ~/.claude/RTK.md,包含实际的指令内容。我这边安装后的文件如下:

rtk 安装生成的 RTK.md 指令文件

Caveman

Caveman 用来节省输出 token。它改变了 Claude 的回复方式 —— 去掉废话、模棱两可的措辞和客套寒暄,只保留技术内容。这不仅仅是让回复变短,而是改变了回复的结构。Caveman 用片段式表达、要点列表和箭头链(→)取代长篇散文,并将文件名:行号这类关键信息前置,而不是埋在句子里。这种结构让每个 token 承载更多有效信息,而不仅仅是数量上的减少。

你可以在对话中途以 normal mode 开头发送提示来关闭它,对比 Claude 平时那种更啰嗦的输出风格。下面的截图展示了针对同一个提示 —— 询问某个分析项目中 referrer 归一化是如何工作的 —— 开启和关闭 caveman 时模型回复的对比。右侧是非 caveman 模式,用段落来解释流程;左侧是 Caveman 模式,用编号列表呈现同样的流程。Caveman 版约 424 个 token,普通版约 487 个(节省 13%),但真正的收益在于每条回复中有多少是实质内容,而非连接词和填充语。

token 节省量对比:caveman 模式 vs 普通模式

每个文件底部的 token 计数并非 caveman 自动添加的。在获得两种回复后,我让 Claude 用 "字符数除以 4" 的粗略方法估算了各自的 token 数,然后手动加上了这些数字用于对比。

/caveman-stats 可以给出当前会话输出 token 节省量的估算。它并不是真的在没有 caveman 的情况下重新向模型发送你的命令来做真实对比,而是基于其仓库中的基准数据进行估算。把这个数字当作粗略参考就好,不要视为精确的账单。

caveman-stats 输出,展示估算的 token 节省量

Caveman 的仓库声称在其测试提示上可减少高达 65% 的输出 token(本文中 13% 的例子只是一个数据点,并非该工具的上限),并引用研究表明,简洁受限的回答不仅能降低成本,还可能提升准确性。

Claude 是怎么知道要调用 caveman 的?

Caveman 以 Claude Code 插件的形式安装。你不需要每次开始对话时都记得输入 /caveman,因为该插件注册了两个钩子:一个 SessionStart 钩子在会话开始时自动开启该模式,一个 UserPromptSubmit 钩子在你发送的每条消息上重新应用它。具体的钩子配置可以查看 ~/.claude/plugins/marketplaces/caveman/.claude-plugin/plugin.json。

CodeGraph

CodeGraph 将你的代码库解析为由节点和边(符号及其关系)构成的图结构,存储在本地 SQLite 数据库中。当你提出结构性问题,比如 "什么调用了这个函数" 或 "如果我改了这里会影响到什么",Claude 可以直接查询图数据库,而不必通过搜索和逐文件阅读来拼凑答案。

虽然这个工具没有提供 token 节省报告,但据我理解,它的帮助在于查询数据库是一条更直接的路径,比起搜索和阅读文件来获取答案要高效得多,速度通常也更快。

下面是模型使用 CodeGraph 追踪 "分享计划" 流程的示例,跨越 controller、serializer 和营养计算代码,通过多次调用逐步锁定正确的入口点:

Claude 在对话中使用 CodeGraph

Claude 是怎么知道要调用 codegraph 的?

运行 init 命令后,CodeGraph 会在项目根目录下创建一个被 gitignore 的 .codegraph/ 目录,其中包含 codegraph.db。由于它只是一个 SQLite 文件,你可以用任何 SQLite 工具自行打开。例如,我用 DBeaver 打开并查看了 nodes 表的前几行:

在 DBeaver 中打开的 CodeGraph nodes 表

和 rtk 一样,CodeGraph 会将自身添加到项目级的 CLAUDE.md 中,确保在该仓库的每次会话中都可用。具体做法是在 ~/.claude/CLAUDE.md 文件末尾添加如下内容:

CodeGraph 添加到 CLAUDE.md 中的配置段

它还会运行一个后台进程,监听文件变化,在你编辑代码时保持图结构同步。你可以通过 ps aux | grep -i codegraph | grep -v grep 查看(此处仅展示 CPU/MEM 列):

 0.0  0.2  .../codegraph-darwin-arm64/node --liftoff-only .../codegraph.js serve --mcp

设置与习惯

这一节介绍我逐步养成的一些设置和习惯,进一步降低 token 用量。

默认使用 Sonnet

我以前默认用 Opus,然后试着记住在简单任务时切换到 Sonnet,但总是忘记,结果在不需要 Opus 的事情上白白烧了 Opus 级别的 token。后来我认识到 Sonnet 对日常大部分工作已经足够好了,所以现在它是我的默认选择,effort 设为 medium 而非默认的 high。

较新的 Sonnet 5 模型默认 effort 为 high,如果你进一步调到 xhigh 或 max,单次任务的成本可能反而超过直接用 Opus。如果你发现自己经常想用 extra-high 或 max effort,这大概说明你应该换模型,而不是拧大 effort 旋钮。关于 effort 与成本的权衡,详见:Claude Sonnet 5, Opus 4.8, Fable 5: when to use which。

将 advisor 设为 Opus

Claude Code 有一个 advisor(顾问)功能。将其设为 Opus 后,日常工作由 Sonnet 处理,遇到真正需要更强模型的问题时再委托给 Opus。使用 /advisor 进行设置。下面是 Sonnet 在任务进行中调用 advisor 的示例 —— 在收尾前捕获了一个未测试的边界情况:

Sonnet 在任务中途调用 advisor

效果就是大部分时间你享受的是更低的执行成本,因为 Sonnet 承担了大量工作,只有真正需要 Opus 的部分才按 Opus 计费。

精确限定提示词的范围

不是每个问题都需要把整个任务的历史记录全部加载进来。如果你只是在审查某个 PR 反馈中针对单个方法的意见,你不需要之前所有的规划讨论或每一次 commit。你能把相关内容限定得越窄,每轮对话中作为输入发送的内容就越少。这一点需要一些判断力,没有现成的命令可用,更多的是注意到你正在携带与当前问题毫无关系的上下文。

定期运行 /context

/context 会显示当前会话中加载到上下文窗口的所有内容。在较长的会话中值得经常检查,因为已加载的上下文算作输入 token,并且在该对话的每条消息中都会被重新发送。

在工作中运行这个命令,让我发现了单次收益最大的一个优化点,下面马上讲到。

审计你的 CLAUDE.md

我们团队项目级的 CLAUDE.md 随着时间积累了大量 @ 引用:前端文档、数据分析操作指南、Stripe 订阅详情、第三方集成指南等等。每个 @ 引用都会让 Claude 在每次会话中自动加载该文件的全部内容,哪怕它跟当前问题毫无关系。

我让 Claude 对这个文件做了审计,帮忙精简。第一轮筛查发现:有些 @ 引用是冗余的,因为项目中已经配置了相应的 Rails 专用技能。剩下的部分,解决方案是把 "始终加载" 的引用改写为条件式加载。例如:"当被问及订阅相关问题时,读取 path/to/subscriptions-doc.md。" 这样 Claude 只在问题确实相关时才会拉取该文件。

为了确保精简过程中没有丢失信息的完整性,我让 Claude 生成了一些示例提示词,在文件裁剪后运行这些提示来验证它仍然能找到与之前相同的细节。我还让 Claude 对比编辑前后的上下文大小,并把这些数字写在 PR 描述中,让团队成员能直观看到影响。下面是我提交的某个 PR 的片段,该 PR 编辑了项目级 CLAUDE.md 以减少其占用的上下文量:

CLAUDE.md 清理前后的总输入 token 节省量对比

如果你在团队中工作,这件事绝对值得做,因为节省的不只是你自己的 token。它会乘以每一个团队成员、每一次对话,持续到那个文件被精简为止。

频繁清理

Claude Code 在消息之间并不像你可能以为的那样保持状态。模型是无状态的,因此在对话中维持连贯性的唯一方式就是每次你提出新问题时重新发送整个对话。一个长时间运行的会话不只是在累积上下文 —— 每一条新消息的成本都比上一条更高,即使新消息本身很短。

完成一个任务或切换到新任务时,执行 /clear。即便任务还没完成,如果我换了一种思路来解决同一个问题,而之前的来回讨论已经没有参考价值了,我也会在中途就清理掉。

补充说明:Prompt 缓存在一定程度上降低了重发成本。对话中被缓存的部分重发时比全新输入便宜,但写入缓存本身仍有(较小的)成本,而且缓存条目会在一个 TTL 后过期,过期时间因套餐而异。文档中有更详细的说明,简而言之:缓存有帮助,但并不能消除长对话的累积成本。

真的有效吗?

读到这里你可能会想:花这么多功夫到底值不值,真的省下来了吗?就我的情况而言,答案是毫无疑问的 "值"。下面这张图(可以在 Claude Desktop 企业版的用量视图中找到)展示了我按模型分类的每日消费。可以清楚地看到六月中旬前后有一簇高消费日 —— 那是我开始优化之前 —— 随后在应用这些技巧之后,每日成本出现了明显的下降:

Claude Desktop 每日按模型分类的消费图表,显示六月中旬的高用量随后明显回落

尚未尝试的

还有几个在我关注列表上但还没来得及试的东西,看起来应该也会有帮助:

  • Headroom:另一款 token 效率工具,和 rtk、Caveman 属于同一领域。

  • Tool Search Tool:Anthropic 官方关于精简工具定义中 token 用量的指南。

  • /checkup(别名 /doctor):检测你配置中的低效之处,比如闲置的 MCP 服务器和技能。详见这篇 X 帖子。

总结

工具 / 技巧

节省的部分

作用

rtk

输入 token

在发送给模型之前压缩 CLI 命令输出

Caveman

输出 token

去除回复中的废话和客套,保留技术内容

CodeGraph

可能两者兼顾

通过图数据库回答代码结构问题,而非 grep / 逐文件阅读

Claude Monitor

不适用(仅提供可视化)

基于 5 小时滚动窗口的实时消耗速率仪表

默认 Sonnet + advisor → Opus

两者

默认使用更便宜的模型,仅在需要时升级到更强模型

精确限定提示词范围

输入 token

避免在聚焦的问题中加载无关历史 / 上下文

/context

可视化

显示当前加载到上下文窗口中的内容

审计 CLAUDE.md

输入 token

将始终加载的 @ 引用改为按需条件加载

频繁 /clear

输入 token

避免重发冗长且已无参考价值的对话历史

写在最后

如果你读到这里已经感到精疲力竭,我完全理解。学会高效使用 AI 工具,本身已经是软件工程工作方式的一次巨大转变。而就在你刚开始适应的时候,又来了一层新的负担:"另外,注意控制开销",外加一大串需要纳入工作流的额外事项。

我反复想到的一个类比是:高效节水洗衣机从设计上就用水更少。你不需要单独买个小装置拧到洗衣机上来让它省水,它天生就是那样的。我希望 token 效率最终也能以同样的方式内置到 AI 工具中,这样我们就可以少花时间盯着仪表盘,把更多精力放在交付真正为用户解决问题的产品上。

关于本文
译者:@木瑾
作者:@Daniela Baron
原文:https://danielabaron.me/blog/how-i-stopped-running-out-of-tokens/

这期前端早读课
对你有帮助,帮” 
赞 “一下,
期待下一期,帮”
 在看” 一下。

阅读原文

跳转微信打开

  •  

【第3734期】告别漫长等待:三步将 Playwright CI 流水线提速 80%

Jakob Norlin 2026-07-29 09:05 日本

无需复杂分片,通过缓存浏览器镜像与并行度优化,轻松将 Playwright CI 运行时间缩短至 5 分钟内。

前言

每次推送干等数分钟,浏览器重复下载,测试逐个串行 —— 问题不在用例而在配置。本文用缓存、并行、按需选浏览器三项改动,把 GitHub Actions 上的 Playwright 从三分钟压到一分钟内,无需分片,一个下午落地。

今日前端早读课文章由 @Jakob Norlin 分享,@飘飘编译。

用于解决我实际工作中的 前端 E2E 自动化测试流水线耗时过长 / 卡顿 问题,最值得借鉴的一点是:“将依赖分为‘二进制大文件’与‘OS 系统包’分层处理”:利用锁文件 Hash 缓存大文件,同时保留极轻量的 install-deps 保证环境完整性,用最小代价消除重复下载。

译文从这开始~~

GitHub Actions 流水线将 Playwright 测试拆分为多个并行的浏览器测试任务,每个任务最终都以成功的对勾结束。

你推送了一个提交,打开 Pull Request,然后等着。Actions 页面在那儿干转三四分钟,一个测试都没跑起来。等测试终于开始了,又是一个接一个地串行执行,整个任务耗费的时间远超你这次改动本身应得的等待。

如果你的流水线就是这副样子,罪魁祸首通常有两个,而且都不是你的测试套件本身。

第一个是浏览器安装。Playwright 自带了 Chromium、Firefox 和 WebKit 的专用构建版本,而默认的工作流每次运行都会把它们全部重新下载一遍。在典型的 GitHub 托管 Runner 上,这通常意味着 300 到 500 MB 的二进制文件,以及大约 30 到 90 秒的等待 —— 每次推送都要重复一遍,而这些文件几乎从不变化。具体数字因 Playwright 版本和 Runner 而异,本文后面的基准测试实测为 42 秒。

第二个是并行度。脚手架生成的配置默认将 CI 限制为单个 Worker,于是测试几乎逐个串行执行,哪怕 Runner 上还有空闲的 CPU 核心在那儿闲着。

这两个都是配置问题,不是套件问题,一个下午就能解决。

而且,你并不需要分片(sharding)。分片是把测试套件分散到多个并行的 CI 任务上跑,确实是个有用的手段,但它解决的是大多数团队尚未遇到的问题。对于一组运行较快的测试,只需缓存浏览器二进制文件并调整并行度,就能在单个 Runner 上将总时间压到五分钟以内,无需分片。当然,测试越慢,触及这个天花板就越快。

本文将完整走一遍这套配置。读完之后,你会清楚时间究竟花在了哪里,拥有一个能在每次 PR 时给出有效反馈的工作流,并且知道什么时候分片才真正值得引入。

基准线:Playwright 默认工作流到底在做什么

运行 npm init playwright@latest 时,它会提示你是否添加一个 GitHub Actions 工作流。大多数人选了 "是",于是 .github/workflows/playwright.yml 里就出现了下面这个文件。几乎所有人的起点都是它,所以在动手改之前,值得仔细看一看。

 name: Playwright Tests
 on:
   push:
     branches: [main, master]
   pull_request:
     branches: [main, master]
 jobs:
   test:
     timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - name: Install dependencies
         run: npm ci
       - name: Install Playwright Browsers
         run: npx playwright install --with-deps
       - name: Run Playwright tests
         run: npx playwright test
       - uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
         with:
           name: playwright-report
           path: playwright-report/
           retention-days: 30

这个配置能跑。它会执行你的测试,交给你一份报告。问题在于,绝大部分时间都耗在了每次推送都重复的相同初始化和串行测试执行上。

下面是这个工作流在一个公开仓库上的真实运行结果,测试套件包含大约 40 个用例。这些都是轻量级测试,跑得比大多数真实项目快,所以请把这些数字当作用来对比各项优化的固定基准,而非对你自己运行时间的预测。

基准运行总耗时:3 分 18 秒。

40 个测试跑了三分多钟。现在来看看时间究竟花在了哪些步骤上:

基准任务各步骤耗时。Checkout、Node 安装和依赖安装各只需约一秒,几乎全部时间集中在两个步骤上。

那些轻量步骤确实很轻。Set up job、checkout、Node 安装、npm ci 都在零到一秒之间,完全不值得去动。整个运行时间全部集中在两个步骤里。

第一个是 Install Playwright Browsers,耗时 42 秒。这一步下载 Chromium、Firefox 和 WebKit,外加浏览器所需的系统依赖库,而且每次运行都会重复,不管这些浏览器有没有变化。展开这一步的日志,你能看到二进制文件一个个被拉下来。

第二个是 Run Playwright tests,耗时 2 分 25 秒。这个数字更大,而对于一个 40 个用例的测试套件来说,实在太久了。原因就是并行度 —— 或者说,缺乏并行度。脚手架生成的 playwright.config.ts 里写着 workers: process.env.CI ? 1 : undefined,意思是在 CI 环境中只用一个 Worker。测试几乎逐个串行执行,哪怕 Runner 上有空闲核心也白搭。

所以,两个瓶颈就这样明晃晃地摆在第二张截图里,而且它们彼此独立。一个是重复的下载开销,通过缓存浏览器二进制文件即可解决;另一个是串行执行,通过开启并行即可解决。接下来两节将按这个顺序逐一攻破。

有一点值得时刻记在心里:大家执着追求的单元测试速度,很少是拖慢流水线的真正元凶。测试外围的初始化和编排才是 —— 而这恰恰是这两项优化所针对的问题。

速度优化一:缓存浏览器二进制文件

基准测试中的安装步骤耗时 42 秒,原因是 Runner 在运行第一个测试之前就要拉取近 400 MB 的浏览器二进制文件。这些文件只有在你更改 Playwright 版本时才会变化,因此每次推送都重新下载纯属无意义的重复劳动。只需缓存一次,此后每次运行都从缓存恢复而非重新下载,这样就能把那 42 秒的步骤缩短为几秒钟 —— 在你升级 Playwright 版本之前,每次 PR 都是如此。

Playwright 将浏览器安装在 ~/.cache/ms-playwright,在 Linux Runner 上对应的实际路径是 /home/runner/.cache/ms-playwright。基准测试截图中每行下载日志的末尾都能看到这个路径。这就是你要缓存的目录。

缓存键使用 package-lock.json 的哈希值。锁文件是 Playwright 版本的一个方便代理 —— 虽然不完美:升级 Playwright 会改变哈希值,从而正确地使缓存失效,但任何不相关的依赖变更也会导致哈希变化,造成一次本不必要的缓存未命中。对大多数仓库来说,偶尔多一次慢运行是一个可以接受的代价,换来的是一行搞定的缓存键。

接下来是大多数教程忽略的细节,也是缓存方案通过代码审查后却在 CI 中翻车的原因。缓存存储的是浏览器二进制文件,而非浏览器运行所需的操作系统级库,因为那些库是通过 apt 安装到系统全局的,根本不会进入 ~/.cache/ms-playwright。所以在缓存命中时,二进制文件是有了,但系统库缺失,测试会报错:Host system is missing dependencies to run browsers。解决办法是在缓存命中时仍然安装那些系统库,只是跳过浏览器下载。

缓存命中时,actions/cache 会在任务开始时自动将 ~/.cache/ms-playwright 恢复到磁盘上,因此在任何安装步骤执行之前,二进制文件就已经就位了。

这就引出了两个条件步骤,它们在每次执行时都会运行,而不是只在第一次运行。缓存未命中时,playwright install --with-deps 在一个步骤中同时下载浏览器和系统库,这个分支只在缓存键变化时才会再次触发。缓存命中时,则每次都改为运行 playwright install-deps,只安装系统库。这不是跑一次就永远跳过的一次性步骤。apt 仍然需要在每个全新的 Runner 上确认包已就位 —— 因为每个任务都从一台干净的机器启动,什么都没装 —— 但速度很快,因为不涉及下载,只是做一次依赖检查,除了那些库本身以外其他条件都已满足。

这里假设 Runner 能正常访问 apt 的软件包镜像;如果是网络受限或自托管的 Runner,请先确认这一点。

 steps:
   - name: Cache Playwright browsers
     id: playwright-cache
     uses: actions/cache@v4
     with:
       path: ~/.cache/ms-playwright
       key: ${{ runner.os }}-playwright-${{ hashFiles('package-lock.json') }}
   - name: Install Playwright browsers and system dependencies
     if: steps.playwright-cache.outputs.cache-hit != 'true'
     run: npx playwright install --with-deps
   - name: Install OS dependencies for browsers
     if: steps.playwright-cache.outputs.cache-hit == 'true'
     run: npx playwright install-deps

缓存步骤上的 id 让两个安装步骤能够读取 cache-hit 的值,从而选择正确的分支。第一次运行时缓存未命中,下载所有内容并填充缓存。之后每次运行都会命中缓存、跳过下载,而由于键绑定了锁文件,当你升级 Playwright 时整个缓存会自动失效 —— 无需手动更新任何东西。

还有一种替代方案完全不用缓存:在 Playwright 官方 Docker 镜像 mcr.microsoft.com/playwright 中运行任务,该镜像预装了浏览器和系统包,不过你仍需自行安装 Playwright npm 包。代价是每次任务都要拉取那个大镜像,所以你只是把浏览器下载换成了镜像拉取,并非真正消除了开销。这在视觉回归测试中比较常见 —— 因为渲染一致性很重要 —— 但它是为可信的测试目标设计的,不适用于不可信的站点。对大多数测试套件来说,缓存方案更轻量。

缓存在首次运行之后就把安装步骤从关键路径上移除了。剩下的是基准测试中那个更大的数字 ——2 分 25 秒的测试执行时间,下一节来解决它。

速度优化二:使用 Worker 并行运行测试

缓存把安装步骤从关键路径上移除了,但基准测试中那个更大的数字还杵在那里:40 个测试跑了 2 分 25 秒,几乎逐个串行执行。这种慢不是 Playwright 本身的问题,而是 Playwright 在严格执行生成配置的指令。

罪魁祸首就是 playwright.config.ts 中的这一行:

 workers: process.env.CI ? 1 : undefined,

脚手架有意这样设置,理由是对于未知的 CI 环境,单 Worker 是最安全的默认值。代价是无论 Runner 实际有多少核心,CI 中的每次运行都被强制压到单个 Worker,这就是基准测试如此缓慢的原因。

在本地环境中,值为 undefined,意思是让 Playwright 使用可用核心的 50%,而非一个固定数字。这只是脚手架对本地机器的默认选择,并非放之四海而皆准的最优值,应该把它当作起点而非一成不变的设定。如果你的本地机器有更多空闲核心,或者测试套件足够轻量、提高并行度也不会出问题,你同样可以在本地将 undefined 覆盖为一个明确的数字或百分比 —— 方式与本节下面为 CI 所做的调整完全一样。

这里有两个关键改动,作用各不相同。第一个是 fullyParallel: true。默认情况下,Playwright 在不同测试文件之间并行,但同一文件内的测试按顺序执行。如果你的测试分散在许多文件中,这个默认行为已经能让 Worker 保持忙碌。但如果测试集中在少数几个大文件里,仅靠文件级并行会让大部分 Worker 闲置,而 fullyParallel 正是解决这个问题的 —— 它允许单个文件内的测试也分配到不同 Worker 上执行。第二个是用基于百分比的 Worker 数量替换硬编码的单 Worker 上限,这样 CI 就能随可用核心数伸缩,而非被钉死在一个上。

 export default defineConfig({
   fullyParallel: true, // 顶层设置,应用于所有 project
   workers: process.env.CI ? "50%" : undefined, // 顶层设置,不要放在 project 内部
   // 你现有的配置项保持不变:
   use: {/* ... */},
   projects: [/* chromium, firefox, webkit */],
 });

这两个配置项都位于 defineConfig 的顶层,与 use 和 projects 平级,不嵌套在任何单个 project 内部,因此它们对整个测试套件生效。

将 CI 设为 50% 而非固定数字,是一个合理的起点,但不是保证最优的值。它能随你实际分配到的 Runner 进行伸缩,而非假定特定的核心数,但正确的数值仍取决于你的 Runner 规格以及测试消耗的内存,所以在调高之前请先实测。这是原始指导中值得放慢脚步仔细斟酌的部分,因为你读到的大多数建议都假设了错误的机器配置。

你会反复看到一个假设:GitHub 的免费 Runner 是 2 核的。对私有仓库确实如此,但公开仓库现在免费获得 4 核 Linux Runner,这个差异完全改变了计算。在 2 核 Runner 上,undefined 解析为 1 个 Worker,意味着默认实际上就是串行的,你必须手动调高才能看到任何并行效果。在 4 核 Runner 上,同样的 undefined 开箱即给你 2 个 Worker,还有继续提升的空间。前面的基准测试运行在公开仓库上,所以那里的慢完全是 process.env.CI ? 1 这个覆盖造成的,而非核心不够。

Runner

核心数

50% 对应

值得尝试

私有仓库,ubuntu-latest

2

1 个 Worker

明确设为 2

公开仓库,ubuntu-latest

4

2 个 Worker

'75%' 或 '100%',然后实测

更大规格的 Runner

8

4 个 Worker

'75%' 及以上,空间更充裕

请把这张表当作起点而一个固定数值。从 50% 开始,观察你的测试套件实际的总耗时,然后逐步提高,直到运行时间不再缩短或测试开始变得不稳定。不存在唯一正确的数字,因为它取决于你的核心数、测试的负载程度,以及每个浏览器实例吃掉多少内存。

最后一点也是不应该做的事。将 Worker 数大幅超出核心数 —— 比如在 2 核 Runner 上设置 workers: 4—— 并不会换来速度提升。每个 Worker 驱动着自己的浏览器实例,一旦它们开始争抢同样的两个核心和同一块内存,你换来的不是更快的运行,而是内存压力和那些在串行执行时根本不存在的间歇性失败。

开启 fullyParallel 并解除 Worker 上限后,4 核 Runner 上的测试执行时间从串行基准线大约减半,加上安装步骤已被缓存,两项优化叠加就是把整个任务压到五分钟以内的关键。下一节将通过精确控制每次推送实际运行哪些浏览器,进一步压缩时间。

速度优化三:只运行你需要的浏览器

基准测试的数字其实藏着一个东西没有明说。npm init 生成的默认配置不只是运行你的测试 —— 它会在 Chromium、Firefox 和 WebKit 三个浏览器上分别跑一遍,因为脚手架为每个浏览器都定义了一个 project。所以那 40 个测试实际上是每次推送执行 120 次,三个浏览器引擎各跑一轮。那 2 分 25 秒的测试时间中,有相当一部分是同样的断言在另外两个浏览器上多执行了两遍 —— 而这些浏览器很少能发现第一个没捕捉到的 bug。

如果你的产品并不需要在每次变更时都保证所有浏览器正常工作,一个务实的做法是按事件类型分层。每次 Pull Request 只跑 Chromium—— 因为这里的反馈循环需要快,而且大多数渲染和逻辑 bug 本来就会在 Chromium 上暴露 —— 然后把完整的三浏览器扫描留给合入 main 或夜间定时任务,那时你负担得起额外的时间,而且确实需要在代码上线前获得跨浏览器信号。Pull Request 保持迅捷,覆盖率并没有丢失,只是挪到了它真正值回票价的时机。

限定为单一浏览器只需一个标志 --project=chromium,然后根据触发运行的事件进行切换:

 on:
   pull_request:
   push:
     branches: [main]
 jobs:
   test:
     runs-on: ubuntu-latest
     steps:
       # checkout、setup-node、缓存和安装步骤沿用前面章节的配置
       - name: Run Playwright tests
         run: |
           if [ "${{ github.event_name }}" = "pull_request" ]; then
             npx playwright test --project=chromium
           else
             npx playwright test
           fi

在 Pull Request 上只运行 Chromium。推送到 main 时则走到 npx playwright test,运行配置中的所有 project。这样所有东西都保持在一个任务里,与本文一贯采用的单 Runner 方案保持一致。

这些都不影响本地运行;条件判断依据的是 CI 事件,所以在你的机器上执行 npx playwright test 仍然照常运行完整的浏览器集合。

如果你希望在 main 上让三个浏览器作为独立的并行任务运行,而非在同一个任务中共享 Worker,可以用条件矩阵来实现:

 jobs:
   test:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
         project: ${{ github.event_name == 'push'
           && fromJSON('["chromium", "firefox", "webkit"]')
           || fromJSON('["chromium"]') }}
     steps:
       # 相同的初始化步骤
       - run: npx playwright test --project=${{ matrix.project }}

推送到 main 时会展开为三个任务,每个浏览器一个;Pull Request 则收缩为单个 Chromium 任务。代价是 main 上消耗更多 CI 分钟数,所以只有当完整扫描慢到并行运行各浏览器能节省可观的实际等待时间时,这才值得。任务数始终限定在三个,不会滑向分片那种开放式的任务拆分。

完整矩阵是否值得运行,最终取决于你的用户构成。如果相当比例的用户在使用 Safari 或 Firefox,或者产品涉及大量布局,就在 main 上保留它。如果用户几乎全部使用基于 Chromium 的浏览器,放到夜间任务就够了。关于 WebKit 有一点需要注意:Playwright 在 Linux 上运行的 WebKit 构建跟踪的是 WebKit 的主开发分支,往往领先于 Apple 在 Safari 中实际发布的版本,而且缺少 Apple 自有的平台集成。Linux 上 WebKit 测试通过是布局和 JavaScript bug 的良好信号,但不能证明页面在 Safari 中显示正确。当这个区别很重要时,你需要 macOS Runner—— 那是独立于本工作流的另一个决策。

在 Pull Request 上仅跑 Chromium,叠加缓存和并行化之后,每次 PR 运行的测试执行量降为原来的三分之一,浏览器来自缓存,跨多个 Worker 并行。这套组合拳就是让百来个测试保持在五分钟以内的关键。接下来要确保的是:当测试失败时,你能看清原因 —— 也就是在 Runner 消失之前把 HTML 报告取出来。

将 HTML 报告作为 GitHub Actions Artifact 上传

Playwright 每次运行都会生成一份 HTML 报告,但在 CI Runner 上,这份报告写入的机器在任务结束的瞬间就会被销毁,所以默认情况下它随 Runner 一起消失,你永远看不到。许多团队是在第一次 CI 失败时才发现这个问题 —— 当他们想找到红叉背后的细节时,发现已经什么都打不开了。解决办法是在任务退出前将报告作为 artifact 上传 —— 基准工作流其实已经在做这件事了 —— 同时再加一个 reporter,让你无需下载任何东西就能直接看到失败信息。

上传本身只需一个步骤,关键路径是 playwright-report/,这是 Playwright 默认写入 HTML 报告的位置:

 steps:
   - name: Upload Playwright report
     uses: actions/upload-artifact@v4
     if: ${{ !cancelled() }}
     with:
       name: playwright-report
       path: playwright-report/
       retention-days: 14

if: ${{ !cancelled() }} 这个条件在这里起着关键作用。没有它的话,这一步只在前面所有步骤都通过时才运行 —— 这完全是反着来的,因为你最需要报告的恰恰是失败的那次运行。这个条件确保无论测试通过还是失败都上传报告,只有在你手动取消任务时才跳过。关于 retention-days,活跃开发中 14 天是合理的默认值,因为你主要查看近期的运行;对于发布分支,设为 30 天比较值得,因为你可能需要在几周后回溯某次构建。无论哪种,artifact 过期后就不再占用存储额度。

Artifact 给了你完整的报告,但需要几次点击:下载 zip 文件、解压、然后在本地启动服务 —— 因为直接打开 HTML 文件是不行的。报告通过 HTTP 加载数据,所以你需要执行 npx playwright show-report path/to/playwright-report,它会启动一个本地服务器并正确打开报告。当你需要深入查看 trace 时这个流程没问题,但对大多数失败来说,这样的摩擦成本过高了。

这就是第二个 reporter 发挥作用的地方。Playwright 自带一个 github reporter,它会将失败信息以内联注解的形式直接写入 GitHub Actions 界面,所以失败的断言会显示在运行摘要中,以及 diff 里对应的那一行旁边,全程无需下载。你把它加在 HTML reporter 旁边而非替换它,这样深入排查时仍有完整报告可用,而日常情况下直接看内联视图即可:

 export default defineConfig({
   reporter: [["html"], ["github"]],
   // ... 其余配置
 });

两者配合之后,失败的运行会在摘要中标注出什么坏了、在哪里坏的,而完整的 HTML 报告仍作为 artifact 附着在那里,供你在某次失败需要查看 trace、截图和步骤时间线时使用。这套组合让失败真正变得可读:大多数时候你根本不用离开 GitHub 页面,而当某个特定失败需要比注解所能展示的更多信息时,那个 zip 文件就在那里等着你。


github reporter 将失败以注解形式展示在运行摘要中,每条注解标明了测试名称及其所在位置。

至此,流水线在每次运行时都能产出可用的失败报告。下一节将把前面所有内容整合进一个完整的工作流文件,可以直接放入你的 GitHub 仓库。

完整的生产就绪工作流

前面四节的所有内容最终落在两个文件里。Worker 数量、fullyParallel 和两个 reporter 属于 playwright.config.ts,而缓存、PR 上只跑 Chromium 的策略以及 artifact 上传则属于工作流 YAML。以下是这两个文件的完整内容,附有行内注释,方便你理解每个部分的作用并适配到自己的仓库。

playwright.config.ts:

 import { defineConfig, devices } from "@playwright/test";
 export default defineConfig({
   testDir: "./tests",
   fullyParallel: true, // 在文件内部也并行执行测试,而不仅仅是跨文件并行
   forbidOnly: !!process.env.CI, // 如果不小心提交了 test.only,直接让构建失败
   retries: process.env.CI ? 2 : 0, // 仅在 CI 中重试不稳定的测试
   workers: process.env.CI ? "50%" : undefined, // 根据 Runner 规格伸缩 Worker 数;从这里开始实测并逐步调高
   reporter: [
     ["html"], // 完整报告,作为 artifact 上传
     ["github"], // 在运行摘要中生成内联注解
   ],
   use: {
     trace: "on-first-retry", // 测试重试时捕获 trace,用于调试失败
   },
   projects: [
     { name: "chromium", use: { ...devices["Desktop Chrome"] } },
     { name: "firefox", use: { ...devices["Desktop Firefox"] } },
     { name: "webkit", use: { ...devices["Desktop Safari"] } },
   ],
 });

.github/workflows/playwright.yml:

 name: Playwright Tests
 on:
   pull_request:
     branches: [main]
   push:
     branches: [main]
 jobs:
   test:
     timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
           node-version: lts/*
           cache: "npm" # 缓存 ~/.npm(安全的 npm 缓存),而非 node_modules
       - name: Install dependencies
         run: npm ci
       # 缓存浏览器二进制文件。此处假设使用 npm;锁文件作为 Playwright 版本的代理,
       # 因此在你更新 Playwright 时通常会自动失效。
       - name: Cache Playwright browsers
         id: playwright-cache
         uses: actions/cache@v4
         with:
           path: ~/.cache/ms-playwright
           key: ${{ runner.os }}-playwright-${{ hashFiles('package-lock.json') }}
       # 缓存未命中:同时下载浏览器和系统库
       - name: Install browsers and system dependencies
         if: steps.playwright-cache.outputs.cache-hit != 'true'
         run: npx playwright install --with-deps
       # 缓存命中:二进制文件已恢复,但系统库仍需安装
       - name: Install OS dependencies for browsers
         if: steps.playwright-cache.outputs.cache-hit == 'true'
         run: npx playwright install-deps
       # PR 上只跑 Chromium 以获得快速反馈;合入 main 时运行完整的浏览器集合
       - name: Run Playwright tests
         run: |
           if [ "${{ github.event_name }}" = "pull_request" ]; then
             npx playwright test --project=chromium
           else
             npx playwright test
           fi
       # 无论测试通过还是失败都上传报告,确保失败信息不会丢失
       - name: Upload Playwright report
         uses: actions/upload-artifact@v4
         if: ${{ !cancelled() }}
         with:
           name: playwright-report
           path: playwright-report/
           retention-days: 14

把这两个文件放进去,推送,第一次运行会填充缓存,之后每次运行都跳过下载。

如果你的测试需要诸如 base URL 或 API token 之类的配置,通过测试步骤的 env 块传入即可。非敏感值可以直接写在工作流中,而任何机密信息都应存储为仓库 Secret 并引用,而非明文写在文件里:

 steps:
   - name: Run Playwright tests
     env:
       BASE_URL: https://staging.example.com
       API_TOKEN: ${{ secrets.API_TOKEN }}
     run: # ... 同上

这就是全部配置了。对于大约 100 个测试以内的套件,到这里就可以停下。下一节讨论的是如何判断你是否真的已经超出了这套方案的承载力,这样你就能在确实需要时才有意识地引入分片,而非将其当作默认选项。

何时引入分片(何时不必)

分片是把你的测试套件拆分到多个并行运行的 CI 任务上,每个任务处理一个切片,最后再用一个步骤将各自的报告合并为一份。这是应对 Playwright 套件变慢的标准答案,确实有效,但它解决的是一个你尚未遇到的问题 —— 除非单个 Runner 确实已经力不从心。前面所有内容都是在让单个 Runner 跑得足够快,而对大多数测试套件来说,这就是全部。

决策规则很简单。先从 workers 和 fullyParallel 入手,将 Worker 数调到与你的 Runner 匹配,然后测量单 Runner 的最优时间。如果你已经把它调到极限仍然不够快,在分片之前先试试更大的 Runner:一台 8 核或 16 核的 GitHub 托管 Runner 能给你更多 Worker,而不用引入 merge-reports 步骤或维护分片数量。只有当一台 Runner—— 即使是更大规格的 —— 也无法在你的 PR 审查窗口内(通常约五分钟)完成时,才去考虑分片。下面的数字是粗略的起点,不是固定规则。你自己的盈亏平衡点取决于测试时长、Runner 硬件和套件的负载程度,而非仅仅是测试数量。

套件规模

单 Runner 耗时

怎么做

50 个测试以下

远低于 5 分钟

Workers 和 fullyParallel 足矣

50–200 个测试

大约 3 到 5 分钟

先换更大的 Runner,再考虑分片

超过 200 个测试,或 10 分钟以上

超出 PR 审查窗口

分片,或将运行移交给外部基础设施

一组重量级的端到端流程会比同等数量的轻量页面检查更快触及天花板,因为真正起决定作用的是运行时间。

分片换来的是总等待时间的缩短 —— 通过同时运行多个切片。它的代价也很实在:更多的 CI 分钟数(因为每次运行要为多台 Runner 付费)、一个用于拼接各份独立报告的 merge-reports 步骤,以及一个需要随套件增长而定期重审的分片数 —— 上个季度均匀的四路拆分,在套件翻倍后可能就不再均衡了。这些都不是不可逾越的障碍,但它们是你有意识承担的维护成本,而非运行稍慢就该迈出的默认下一步。

还值得了解的是,分片并非突破单 Runner 天花板的唯一途径。你可以完全跳过分片管理的开销,将套件放到专门为你并行化测试的基础设施上运行 —— 用 YAML 复杂度换取一个外部服务。这是否合适,取决于你有多想亲自掌控 CI 管道的每一环。

核心要点是:分片未必总是最佳方案。对绝大多数测试套件而言,一台跑得飞快的单 Runner 才是正确的配置,而引入分片的时机是你自己的数据越过了上面那条线的那一刻 —— 不要更早。当你确实需要时,Playwright 的分片文档详细说明了具体操作。

常见配置错误及如何避免

以下这些问题大多只是浪费你一个下午,而非直接搞崩什么东西,每一个都源于某个看起来合理、实则暗藏陷阱的默认设置。最常见的四个:

安装浏览器时没加 --with-deps。 单独运行 npx playwright install 只会下载二进制文件,不会安装浏览器运行所依赖的系统库,而 GitHub Runner 默认并不自带这些库。测试会报一个 "Host system is missing dependencies" 的错误,却对真正的原因只字不提。按照缓存章节的做法:缓存未命中时用 --with-deps,缓存命中时用 install-deps。

缓存 node_modules 而非 npm 缓存。 这是一个与前面浏览器二进制缓存不同的缓存,针对的是你的 npm 包而非 Playwright。恢复的 node_modules 可能带有特定平台的或构建不完整的依赖,与当前 Runner 不匹配,导致难以追踪的诡异故障。应该缓存 ~/.npm—— 通过在 setup-node 步骤中设置 cache: 'npm'(上面的完整工作流已经这样做了),然后让 npm ci 在每次运行时干净地重建 node_modules。

Worker 数设得超出 Runner 的核心数。 一旦 Worker 数量超过核心数,增加更多就不再有收益。超出之后,浏览器实例争抢同一块 CPU 和内存,速度没换来,反而换来了串行运行时根本不存在的不稳定性。让 Worker 数与 Runner 匹配,只在实测数据保持稳定的前提下才逐步调高。

忘记添加 github reporter。 没有它的话,失败的运行只告诉你有东西坏了,却不说是什么,逼你去下载并解压 artifact 才能一探究竟。在 ['html'] 旁边加上 ['github'],失败信息就会内联显示在运行摘要中,绝大多数情况下根本不需要碰那个 zip 文件。

总结

在 GitHub Actions 上实现快速的 Playwright 流水线并不需要分片。贡献最大的两项优化 —— 缓存浏览器二进制文件和针对 CI Runner 优化并行度 —— 都是一个下午就能完成的配置改动,一旦就位,它们在每一次 PR 上都在持续回报,而不是一次性的收益。这就是优化配置相比追求测试速度的隐性优势:节省的时间在团队此后的每一次运行中复利累积。

完整工作流中的单 Runner 方案在套件增长的相当长时间内都能胜任,而诚实的表述在这里很重要。当一个团队确实超出了这套方案的承载力时,那是一个在数据越线时有意识做出的扩展决策,而非说明之前哪里做错了。过早引入分片本身就是一种错误 —— 为你根本不会损失的时间付出了复杂度的代价。

一切的底层贯穿着一个值得铭记的理念。测试套件存在的意义是在每次推送时给出快速、可信的反馈,而本文中的每一项优化 —— 从缓存键到 Worker 数量再到内联 reporter—— 都是在为此服务。一条能在几分钟内给出清晰答案的流水线,才是人们真正信任并愿意等待的。而一条缓慢或嘈杂的流水线则会被忽视 —— 这悄无声息地辜负了你当初写测试的全部初衷。

如果你的套件已经越过了那条线,而你不想亲自维护分片数量、矩阵任务和报告合并,Endform 可以为你提供同样的并行化能力,无需自己搭建 CI 管道。

关于本文
译者:@飘飘
作者:@Jakob Norlin
原文:https://endform.dev/blog/playwright-github-actions

这期前端早读课
对你有帮助,帮” 
赞 “一下,
期待下一期,帮”
 在看” 一下。

阅读原文

跳转微信打开

  •  

【第3733期】用 Web Locks API 优雅解决跨标签页并发问题

Cesar Contreras 2026-07-27 09:00 日本

介绍了如何利用原生 Web Locks API 实现跨标签页并发互斥,高效解决大文件重复上传问题。

前言

大文件断点续传遇上多标签页,每个标签页都争着恢复同一个上传,重复请求接踵而至。localStorage 有竞态风险,BroadcastChannel 又过于复杂。本文分享如何用浏览器原生 Web Locks API 实现原子级跨标签页互斥,优雅杜绝重复上传问题。今日前端早读课文章由 @Cesar Contreras 分享,@飘飘编译。

用于解决实际工作中的 前端多标签页状态同步 / 资源竞争 问题,最值得借鉴的一点是:对用户主动触发的操作使用 “非阻塞锁”(有锁就持有,无锁也继续),而对系统自动恢复的操作使用 “条件锁”,既保障体验又不产生冗余。

译文从这开始~~

编程中的并发,是指同时管理和执行多个任务或进程的能力(或至少看起来如此),使程序保持响应迅速且高效运行。你可以把它想象成一位忙碌厨房里的大厨:他不会把每道菜从头到尾按顺序一道道做完,而是一边切着蔬菜,一边看着这口锅在炖煮、那口锅在烘烤 —— 同时推进着好几道菜的进度。

我是 OLX 的一名前端工程师,日常主要使用 React 和 Next.js,但我的技术背景其实是 Java 并发编程。开发多线程应用是件让人头疼的事,要跟锁、信号量打交道…… 还有我的 "最爱"—— 死锁(在大型代码库里简直是噩梦)。当我完全转向 Web 开发时,从没想过还会遇到类似的场景。

Web 开发已经演变成了一个极其强大的生态系统。从早期那个只有用 HTML marquee 做些花哨滚动动画的年代(这里有点玩笑的意思 😆),从 JQuery 一统天下的时代,发展到如今这个强大的环境 —— 你可以使用 Workers、用 WebGL 和 Canvas 做 2D 和 3D 动画、用 Service Workers 实现离线功能,等等不一而足。这充分说明,Web 如今已经能够应对真正复杂的挑战,遇到类似问题只是时间早晚的事。

问题所在

最近,我们在 OLX 面临了一个大文件上传的挑战。在处理上传时想要提供最佳用户体验并非易事,现实中大多数场景都要求用户留在页面上等待上传完成,但我们不想这样。由于文件体积可能非常大(最高达 20GB),我们希望用户可以自由地去做其他事情,即使关闭了浏览器或标签页再重新打开,上传也能自动继续,无需任何手动操作。为此,我们需要提供一种断点续传机制。

但麻烦也随之而来。如果用户打开了你应用的多个标签页会怎样?每个标签页都会尝试恢复并继续同一个上传任务。后果呢?多个重复的上传请求打到你的 S3 存储桶,带宽被白白浪费,产生不必要的处理成本,而用户则眼睁睁看着上传进度条毫无规律地跳来跳去,一脸困惑。

两个标签页各自恢复后,独立触发了同一个上传任务;由于缺乏协调,视频被上传了两次。

如果你正在现代 Web 应用中构建文件上传体验,大概率遇到过这个场景。今天,我将带你了解我们使用 Web Locks API 实现的一套稳健方案,来解决这个令人抓狂的协调难题。

不过,在深入讲解我们的解决方案之前,我们需要先理解同步与锁的概念。

首先,什么是锁?

锁是一种机制,用于确保共享资源(变量、对象、函数调用等)在同一时刻只能被一个调用者访问,并且每个调用者都能获取到最新的信息。你可以想象一个非常经典的场景 —— 一家银行在共享内存中存有多个账户,同时有多台 ATM 机在进行取款、存款和余额查询操作。如果没有协调机制(同步),结果将一团糟,如下图所示。

为了解决这个混乱局面,我们必须通过对账户的读写操作加锁来控制访问。这样一来,无论执行什么操作(取款、存款还是查询余额),第一个获得锁的调用者将独占资源,其他调用者必须等待,直到第一个持有者完成操作并释放锁。下图展示了对账户访问进行同步后的效果。

现在我们已经理解了同步和锁的工作原理,接下来让我们看看如何将它付诸实践 🚀。

跨标签页协调的技术全景

在深入我们的解决方案之前,先来看看在浏览器标签页之间协调操作有哪些可选方案:

方案一:localStorage + 轮询

这是一种 "经典" 做法,利用 localStorage 作为共享锁机制:

 // 简化示例 - 请勿在生产环境使用
 if (!localStorage.getItem('upload-lock')) {
   localStorage.setItem('upload-lock', Date.now());
   // 开始上传
 }

存在的问题:

  • 竞态条件:localStorage 的读写操作不是原子性的

  • 过期锁:如果标签页崩溃,锁会永远残留

  • 轮询开销:需要持续检查锁的状态

  • 事件局限:storage 事件只在其他标签页触发,当前标签页收不到

方案二:Broadcast Channel API

这种方式通过 Broadcast Channel API 在标签页之间发送消息来进行协调:

 const channel = new BroadcastChannel('upload-coordination');
 channel.postMessage({ type: 'REQUEST_UPLOAD_PERMISSION' });

面临的挑战:

  • 缺少互斥原语:你需要从零开始构建状态机

  • 竞态条件:同时发出的消息可能产生冲突

  • 协议复杂:需要手动处理心跳、崩溃检测和冲突解决

  • 容易出错:消息排序和时序问题非常常见

Web Locks API 登场:浏览器原生互斥锁

Web Locks API 恰好提供了我们所需要的东西:一个真正的、原子性的互斥锁系统,直接内置于浏览器中。它的优势在于:

  • 原子性锁获取 —— 没有竞态条件

  • 自动清理 —— 标签页关闭或崩溃时锁会自动释放

  • 非阻塞选项 —— 避免 UI 冻结

  • API 简洁 —— 无需实现复杂协议

  • 浏览器兼容性 —— 所有主流浏览器均已支持 😃

我们的实现:useUploadCoordinator

以下是我们通过自定义 React Hook 解决该问题的方式:

核心策略

针对两种场景采用两种不同的处理方式:

 // 1. 全新上传(用户主动发起):非阻塞
 // 尝试获取锁,但无论是否获取到都继续执行
 navigator.locks.request(LOCK_NAME,
   { ifAvailable: true },
   async (lock) => {
     if (lock) {
       // 持有锁直到上传完成
       await holdLockUntilComplete(abortController);
     }
     // 无论如何都继续上传 - 绝不阻塞用户
   }
 );
 // 2. 恢复上传:有条件执行
 // 只有获取到锁才继续
 navigator.locks.request(LOCK_NAME,
   { ifAvailable: true },
   async (lock) => {
     if (lock) {
       uploader.emit("restore-confirmed"); // 继续恢复上传
       await holdLockUntilComplete(abortController);
     }
     // 如果未获取到锁,静默跳过 - 另一个标签页正在处理
   }
 );
关键实现细节

锁的生命周期管理:

 const holdLockUntilComplete = (abortController: AbortController) => {
   return new Promise<void>((resolve) => {
     const cleanup = () => {
       // 移除所有监听器并 resolve(释放锁)
       uploader.off("complete", cleanup);
       uploader.off("error", cleanup);
       uploader.off("cancel-all", cleanup);
       resolve();
     };
     // 在任何终态事件发生时释放锁
     uploader.on("complete", cleanup);
     uploader.on("error", cleanup);
     uploader.on("cancel-all", cleanup);
     // 组件卸载时也释放锁
     abortController.signal.addEventListener("abort", cleanup);
   });
 };

浏览器兼容性与优雅降级:

 const checkWebLocksAvailable = (): boolean => {
   return typeof navigator !== 'undefined' && 'locks' in navigator;
 };
 // 降级处理
 if (!checkWebLocksAvailable()) {
   // 允许恢复操作继续(接受可能出现重复的风险)
   uploader.emit("restore-confirmed");
   return;
 }

实际收益

自从上线这套方案以来,我们看到了:

  • 跨标签页协调导致的重复上传归零

  • 更好的用户体验 —— 上传永远不会因协调逻辑而卡住

  • 基础设施成本降低 —— 不再有重复的处理和存储开销

  • 代码更简洁 —— 不再需要复杂的状态机或轮询逻辑

现在,我们的方案效果如下:

通过共享锁,只有第一个获取到锁的标签页会继续执行上传;第二个标签页检测到锁已被占用后,便悄然退让。

实际应用中的注意事项

适用场景:
  • 支持持久化 / 恢复的文件上传

  • 后台同步操作

  • 任何在同一时间只应在一个标签页中运行的单例操作

性能影响:
  • 极小 —— 没有轮询开销

  • 自动清理机制避免内存泄漏

  • 非阻塞设计确保 UI 始终流畅响应

测试策略:
  • 在所有目标浏览器中进行测试

  • 验证标签页意外崩溃时的行为表现

  • 确认在不支持该 API 的环境中能优雅降级

结语

跨标签页协调不必成为一场噩梦。Web Locks API 提供了一个稳健的、浏览器原生的解决方案,免去了自定义协调协议的复杂性和脆弱性。

在构建这套方案的过程中,我们总结出跨标签页协调成功的关键在于:

1、绝不阻塞用户操作 —— 对用户主动发起的操作使用非阻塞锁
2、安全地失败 —— 优雅降级胜过功能崩溃
3、保持简单 —— 善用平台原生能力,而非重新造轮子

Web Locks API 不仅仅适用于上传协调;任何时候你需要在标签页之间实现互斥,都值得考虑使用它。随着浏览器支持的持续完善,它正在成为现代 Web 开发者工具箱中越来越实用的利器。

关于本文
译者:@飘飘
作者:@Cesar Contreras
原文:https://tech.olx.com/handling-concurrency-on-the-web-with-web-locks-api-163b7e07eddd

这期前端早读课
对你有帮助,帮” 
赞 “一下,
期待下一期,帮”
 在看” 一下。

阅读原文

跳转微信打开

  •  

【开源】口播视频(Talking-head)AI 视频编辑器:pireel/pireel

原创 木瑾 2026-07-27 09:00 日本

一款纯前端运行、隐私优先且可被 AI Agent(MCP 协议)驱动的开源口播视频编辑器。

📌 项目:pireel/pireel

Pireel Studio editor

项目地址:https://github.com/pireel/pireel

🧩 核心作用

一个开源、无需后端的口播视频(Talking-head)AI 视频编辑器,支持分镜设计、花字图形、动态字幕、设计主题,并可在浏览器端通过 WebCodecs 直接导出视频。

❗ 解决的核心问题

解决了传统视频剪辑软件依赖云端服务器处理、用户隐私易泄露、订阅成本高以及跨端 / AI 协作门槛高的问题;它提供完全纯前端本地运行的轻量剪辑体验,并支持通过 MCP 协议让 AI Agent 直接驱动视频剪辑。

👥 适用人群

  • 自媒体创作者 / 口播博主:需要快速制作带花字、动态字幕及设计主题的口播短视频。

  • AI 开发者 & Agent 开发者:希望通过 MCP(Model Context Protocol)接入视频剪辑能力,实现自动化视频生成与编辑。

  • 注重隐私的用户:希望所有视频素材与草稿仅保存在本地(OPFS /localStorage),不上传任何云端服务器。

🔍 关键特性

  • 纯前端 / 无后端架构:草稿与视频数据全部保存在本地浏览器,无需注册账号或连接服务器。

  • AI Agent 原生驱动:支持通过 MCP 协议被 Codex、Claude Code 等 AI Coding Agent 直接调用控制。

  • 丰富的 Frame 丰富主题系统:内置多样化的视觉设计系统(如 Cinema, Neon, Y2K 等),可一键切换视频整体配色与排版风格。

  • WebCodecs 本地导出:利用现代浏览器(Chromium 等)的能力实现所见即所得的高效视频导出。

🚀 快速了解建议

1、优先阅读 README.md 中的 * Quick start,体验如何使用 npx skills add pireel/pireel-agent 将其接入 AI Agent。
2、本地运行体验:执行 pnpm install 与 pnpm dev 打开编辑器,拖入一段口播视频亲自感受纯前端剪辑与主题切换。

阅读原文

跳转微信打开

  •  

【早说】别急着教设计师用AI——先给他们一个敢当新手的地方

Sheila Kazan 2026-07-24 09:00 日本

当 AI 浪潮席卷而来,Slack 设计团队没有选择自上而下的培训,而是搭建了一个允许困惑、鼓励探索的学习社群

前言

当 AI 浪潮席卷而来,Slack 设计团队没有选择自上而下的培训,而是搭建了一个允许困惑、鼓励探索的学习社群。因为比工具更重要的,是让每个人都敢迈出第一步。

今日前端早读课文章由 @Sheila Kazan 分享,@飘飘编译。

用于解决实际工作中的 新技能团队普及 / 跨职能协同创新 问题,最值得借鉴的一点是:不要从工具 Enablement 开始,要从人开始。提供一个容许失败、没有评判的 “集装箱(Container)”,让走得快一步的人带着新手一起跑。

译文从这开始~~

不断听到的问题

"AI 到底怎么用?"

这个问题是在私信里悄悄打出来的,而不是当众问出口的 —— 这本身就说明了一切。我们的设计团队从不缺好奇心,缺的是一个可以安心当 "新手" 的地方。一个不懂不会被视为短板、反而恰恰是存在意义的空间。于是我们创建了这样一个空间。秉承 Slack 一贯的风格,我们 AI 的起源故事始于一个 Slack 频道和满腔热情。

2025 年初,整体氛围还是探索性的。AI 感觉像是远方地平线上一件酷炫的新事物,值得上手摸一摸。我们开了一个频道,给有兴趣的人安排了一些工具上手培训,也办了几场分享会。那时候的心态就是 "先玩玩看"—— 压力不大,好奇心很足。非常 Slack Design 的气质。

然后,2026 年来了。

AI 一夜之间不再是 "未来的事",而是 "眼前的事"。工程师已经跑起来了,跑得飞快。设计师必须跟上节奏 —— 是 "并肩跑",不是 "跟在后面追"。正是在这个节点上,"Builder Days"(共建日)应运而生:三天时间,设计师、工程师和产品经理放下各自的路线图,用 AI 一起动手造东西。团队的情绪从好奇悄然转变为一种带着紧迫感的共识:我们必须做好准备。

作为一名设计运营人员,我特别关注学习项目以及变革中的人性化层面,因此我看到了一个帮助的机会。不是要强加任何规定,而是创造一个空间,让充满好奇心的设计师能够真正、切实地做好准备,带着可以贡献的内容参加 Builder Days,而不仅仅是作为旁观者。

这就是那个故事。我们做了什么,学到了什么,哪些事情让我们感到惊讶,以及我们想告诉任何正在努力寻找自身定位的设计团队 —— 当一切同时开始变化时,该如何应对。

为设计而生,因设计而创

问题不在于学习机会太少,恰恰相反 —— 太多了。各种工具培训像潮水一样涌进日程安排,但几乎没有一个是为设计师量身定制的。大多数课程面向工程师,我们不过是顺便旁听而已。还有一个棘手之处:一切变化太快,周一写的操作指南,到周五就过时了。

于是我们决定搭建自己的 AI 赋能课程体系 —— 为设计师而生,由设计师打造。

这句话成了我们的北极星。从一位设计师同行口中听到 AI 工具能做什么,和从一位工程师那里听到,感受是截然不同的。这不是布道,而是一种 "许可"—— 对于团队中那些仍在观望、等待被说服的设计师来说,这个区别比我们预想的重要得多。

我们的课程并不精致。但说实话,这正是重点所在。

我们开设了一个名为 "会 Vibe 的设计师 & AI" 的周五系列活动,而最令人难忘的瞬间,从来不是精心准备的演示。它们发生在有人突然插嘴提问的时候,发生在有人大方共享屏幕(一堆标签页全暴露在外)的时候,发生在我们一起即兴摸索、实时解决问题的时候。没有脚本,只有大声说出来的好奇心。

我们学习的这个东西,变化之快远超任何指南的更新速度。所以,与其假装胸有成竹,不如拥抱那个真正管用的方法:提出问题,动手尝试,卡住了 —— 就去问 AI。

让 AI 教你怎么用 AI。这成了我们的信条之一。

三天,没有路线图,只管动手造

Builder Days 的设计初衷就是刻意开放的:来就行,找到你的跨职能搭档,用 AI 造点什么出来。概念上很简单,实践起来却不容易 —— 尤其当技术和协作模式同时都是全新的时候。

所以我们帮助设计师提前做好了准备。我们分享了其他设计师的思路和方法,让每个人都不必独自摸索。我们编写了一份《设计师 Builder Days 指南》—— 一站式资源手册,涵盖你会遇到什么、对你有什么期待、以及去哪里找灵感。手册里甚至还有一个术语释义板块,专为那些需要一个不讲行话的答案来回应 "等等,终端是什么?" 的人准备。

我们还重新定义了 "成功" 的标准。Builder Days 的目的不是让 AI 为你所用 —— 而是去了解它什么时候行、什么时候不行。找到边界,才是真正的意义所在。我们甚至专门为 Builder Days 开设了一个临时支持频道:卡住了就问,团队里马上有人来帮忙。没有评判,没有门槛。

而当一位设计师在令人抓狂的提示词循环里越陷越深,最终坦言自己只想出去 "摸摸草坪透透气" 的时候 —— 我们也把这算作一个发现。说到底,我们终究是人,这一点永远不能忘。

在 Builder Days 之前,学习是零星发生的。Builder Days 催生了一种不同的东西 —— 我们看到的场面既混乱又充满能量,二者势均力敌。那些一直潜水的设计师终于有了一个 "不得不动" 的推力;那些围绕 AI 整合观望了数月的团队,也再无退路,只能放手一试。有些东西搞砸了,但更多的东西以意想不到的方式给人惊喜。

然而,真正的学习发生在 Builder Days 之后。我们召集了一群经历各异的设计师,问他们到底学到了什么。答案坦诚而犀利,恰到好处地 "辛辣"。

  • 人的判断力不可妥协:AI 输出的速度越快,就越需要相应提升协调、沟通和人工把关的力度 —— 而不是减少。

  • 前期规划决定一切:表现出色的团队从第一天起就有清晰的计划 —— 明确的分工、共享的协作模式,以及尽早且频繁的进度同步。

  • "缰绳" 和模型同等重要:光有一个好模型远远不够。在 "缰绳" 上下功夫 —— 提示词、claude.md 配置、技能库和文档 —— 才是释放产品级 AI 产出的关键。

  • 协作模式正在发生转变:AI 正在将协作的重心从优化异步工作,转向投入更多时间在真正有价值的事情上:做决策、头脑风暴和共同构想。

有一位设计师用她的三天时间,试图理解自己与 AI 之间的关系。不是为了做出什么成果展示,不是为了优化某个工作流 —— 只是安静地坐在它面前,向它抛出那些难以回答的问题。她的结论?"这很复杂。"

你知道吗?这完全没问题。这同样是一个非常有价值的发现。并非每位设计师都带着一个可运行的原型或一个合并的 PR 离开。有些人带走的东西更难衡量,却更为重要:对自己与这项技术之间关系的一份更清晰的认知 —— 什么让他们兴奋,什么让他们不安,以及哪些问题仍需要自己去回答。

这就是构建学习文化的真谛:价值并不总是体现在产出上。有时候,它体现在那个 "容器" 本身。当人们知道有一个地方可以安放自己的困惑,他们就会带着困惑来。而当困惑被看见,它就变成了整个团队可以共同攻克的课题。

从社群开始

我们仍然走在路上。Builder Days 刚刚结束,频道里依然热火朝天。我们的 AI 学习项目会持续迭代,一切以团队的真实需求为导向。但如果只能给其他设计团队传递一句话,那就是:不要从工具开始,从人开始。找到你的初学者们,给他们一个可以毫无顾虑地保持好奇的地方。让他们身边坐着领先一步的人,而不是领先十步的人。然后给整个团队足够的、受保护的时间,一起练习。

工具会不断更换,但你围绕 "学习" 所建立的文化,才是真正能够复利增长的东西。而作为一个以 "为设计师铺路" 为己任的人,面对 AI 这个时代节点,我用的是自己唯一知道的方式来回应:从人开始。

关于本文
译者:@飘飘
作者:@Sheila Kazan
原文:https://slack.design/articles/we-didnt-teach-our-designers-ai-we-built-a-place-where-they-could-learn-it-together/

这期前端早读课
对你有帮助,帮” 
赞 “一下,
期待下一期,帮”
 在看” 一下。

阅读原文

跳转微信打开

  •  

【开源】一个用于 Codex 和 Claude Code 的通用 LLM 代理中间件:opencodex

原创 木槿 2026-07-24 09:00 日本

解决 Codex CLI / App 和 Claude Code 默认绑定/限制特定底层模型提供商的问题。

📌 项目:opencodex

项目地址:https://github.com/lidge-jun/opencodex

🧩 核心作用

一个用于 OpenAI Codex(CLI、App、SDK)和 Claude Code 的通用 LLM 代理中间件(Proxy),允许用户在 Codex 和 Claude Code 环境中自由使用任何大语言模型(如 Anthropic Claude、Google Gemini、xAI Grok、DeepSeek、Ollama 等)。

❗ 解决的核心问题

解决 Codex CLI / App 和 Claude Code 默认绑定 / 限制特定底层模型提供商的问题。原本用户如果想在 Codex 生态或 Claude Code 中尝试其他 LLM,往往受限于接口协议或无法直接切换模型;opencodex 通过在本地构建 Response / Messages 协议适配层,实现了零成本适配 40+ 种 LLM 提供商,同时还解决了多 ChatGPT 账号额度轮换(Pool)与会话保持(Affinity)的痛点。

👥 适用人群

  • 使用 Codex(CLI / App / SDK)或 Claude Code 进行辅助编程的开发者。

  • 希望在统一的 Codex / Claude Code 终端工作流中自由切换各类公有云 LLM 或本地模型(Ollama /vLLM)的工程师。

  • 拥有多个 ChatGPT / Codex 账号、需要自动轮换与配额管理的高阶用户。

🔍 关键特性

  • 全协议兼容:支持 Anthropic Messages、Google Gemini、Azure、OpenAI Chat/Responses 等 50+ 种适配器,无缝桥接任何 LLM。

  • ChatGPT 账号池管理:自动识别 5 小时 / 周度 / 月度额度,新会话自动分发至低用量账号,长会话自动保持(Affinity)不中断。

  • 无缝集成与静默启动:自动注入 Codex 配置与模型选择器,支持系统服务(launchd/systemd/Task Scheduler)或按需 Shim 模式启动。

  • 多模型协作(Subagent):支持在 Codex 子代理选择器中同时配置多种不同模型(如复杂任务路由给推理模型、简单任务路由给轻量模型)。

🚀 快速了解建议

  • 参阅 README 中的 Quick start:https://github.com/lidge-jun/opencodex#quick-start 章节,使用 npm install -g @bitkyc08/opencodex 进行快速安装。

  • 运行 ocx gui 启动本地 Dashboard,在可视化界面中一键添加并配置需要的 LLM Provider。

阅读原文

跳转微信打开

  •  

【第3732期】不必转投 jj,git history 让历史重写变得安全又优雅

Lalit Maganti 2026-07-22 09:00 日本

git history 命令值得更多关注

前言

git 2.54/2.55 新增了 git history 命令,提供 fixup、reword、split 三个子命令,可原子性地修改历史提交并自动变基相关分支,无需切换工具就能获得 jj 的部分核心体验。

今日前端早读课文章由 @Lalit Maganti 分享,@飘飘编译。

如果用于解决实际工作中的 并行开发多特性分支且需频繁修正历史提交 问题,最值得借鉴的一点是:善用 git history fixup 跨分支自动重写提交,避免人工逐个分支进行手动的 rebase。

译文从这开始~~

在 git 中同时处理大量并行改动是件痛苦的事。你不得不在各个分支和提交之间来回腾挪,还要运行那些令人胆战心惊的 rebase -i命令 —— 稍有差池,整个工作树就可能陷入半崩溃的状态。

jj 是 git 的一个替代方案,近来讨论度颇高,常被推崇为解决上述问题的良方。我完全认同 jj 试图解决的那些痛点,但它的解决方式始终没有真正打动我。过去一年半里,我每隔三个月就会花几天时间试用它,真心想把它融入自己的工作流,但最终总是放弃,回到 git 的怀抱。

这就轮到 git history 登场了。这是一个实验性命令,分两个版本发布:2.54(四月,包含 reword 和 split 子命令)和 2.55(六月,包含 fixup 子命令)。每次发布当天都会引发一阵热议,但据我所知,此后社区就鲜有讨论了。这实在可惜,因为在我看来,它已经能提供人们推崇 jj 时所列举的诸多优势,而且无需彻底改变你的工作流。更妙的是,它是 git 核心发行版的一部分,无需额外安装任何东西就能尝试。

它包含三个子命令:fixup、reword 和 split。

fixup

git history fixup修复了那个存在问题的旧提交,并自动将所有分支重新基于该提交进行分支重构,以使其保持一致。

你像往常一样用 git add暂存修复内容,然后运行 git history fixup <commit>将暂存的改动合入目标提交。这相当于 git commit --fixup加上自动压缩变基,但额外的精妙之处在于,它还会更新所有包含该提交的其他分支。

这一点比 git rebase --update-refs走得更远 —— 后者只移动你当前正在变基的范围内的引用。而 git history会找到并重写所有从该提交派生出的本地分支(同时也提供了仅限当前分支的选项)。另一方面,它在存在合并提交的情况下无法工作,对于某些 git 使用场景来说,这会是一个硬伤。

下面是实际操作示意:

执行前,已暂存了对 B 的修复:

提交 A、B(有 bug)、C 位于 feat-1 分支,D 位于 feat-2 分支,呈线性排列,暂存的修复位于顶端 D 之上。

执行 git history fixup B之后:

fixup 后:A 不变;B(已修复)、C 和 D 以新哈希重写,feat-1 和 feat-2 分支指针随之移动。

B*已经包含了修复的补丁。重写提交会产生新的哈希值,因此 C 和 D 会自动在其上重建为 C*和 D*,feat-1 和 feat-2 的分支指针也随之跟进。

所有三个子命令最重要的共同特性是原子性:它绝不会让你的工作树处于半崩溃的状态。它通过拒绝任何可能产生冲突的操作来实现这一点。

需要明确的是,这在功能上严格弱于 jj。jj将冲突视为一等公民,因此可以在变基过程中保留冲突状态,让你事后再行处理。git history 目前还做不到这一点,但文档中留下了开放的可能:

"这一限制是刻意为之的设计,因为历史重写操作并不打算具有状态性。一旦 Git 学会处理一等冲突(如果有那天的话),这一限制便可以解除。"

所以基本上,这个限制未来可能会改变 —— 很期待看到那一天的到来!

reword

git history reword用于更新旧提交的提交信息,并自动变基其上的所有内容。当你在迭代过程中设计发生变化,需要回头修改提交信息时,这个命令非常实用。

git history reword <commit>会打开编辑器,显示该提交的现有信息。你编辑保存后,整个提交栈会在其上重建,分支指针也随之跟进。它和 fixup 的工作方式如出一辙,只不过改的是提交信息而非文件内容。

由于只修改信息,reword(以及后面的 split)完全不会触碰你的暂存区或工作树;它纯粹在提交图上操作。因此,这两个命令都允许你重写一个未检出分支上的提交,而不会打扰你手头正在进行的工作。

执行前:

提交 A、B(信息为 "fix bug")和 C 位于 feat-1 分支。

执行 git history reword B之后:

reword 后:A 不变;B 以新信息 "fix null deref in parser" 重写,C 在其上重建。

只有 B 的信息发生了变化,但这仍然会产生一个新哈希,因此 C 会在其上重建为 C*,feat-1 也随之跟进。

split

git history split将一个提交拆分为两个,通过交互式选择来决定每个提交包含哪些内容。它相当于 git add -p,但无需配合 git rebase做各种体操动作。我发现它是三个子命令中最专用的一个,但在需要时堪称无价之宝。

具体来说,git history split <commit>会逐块展示该提交的 diff,让你逐一选择。你保留的代码块构成第一个提交,其余的归入第二个。

执行前,B 中混杂了两个不相关的改动:

提交 B 包含两个不相关的改动,位于 feat-1 分支上 A 和 C 之间。

执行 git history split B之后:

split 后:A 不变;B 被拆分为 B1 和 B2,C 在它们之上重建为 C*。

B 变成了 B1 和 B2,C 在这对提交之上重建为 C*。

结语

从 jj 的使用人数来看,我认为确实存在某种关键的思维转变是我尚未完成的。而且需要说明的是,git history 并没有完全弥合两者的差距:jj 仍然提供了带有便捷撤销功能的操作日志、将工作副本建模为提交、以及在变基过程中保留冲突的能力,这些都不是 git history 试图做的事情。

但就目前而言,git history 在吸纳那些吸引人们转向 jj 的诸多特性方面迈出了一大步,而且它已经内置在我每天使用的工具中。从文档的写法来看,我有理由期待后续版本会带来更多改进!

关于本文
译者:@飘飘
作者:@Lalit Maganti
原文:https://lalitm.com/post/git-history/

这期前端早读课
对你有帮助,帮” 
赞 “一下,
期待下一期,帮”
 在看” 一下。

阅读原文

跳转微信打开

  •  

【开源】既简单又强大的版本控制系统:jj

原创 情封 2026-07-22 09:00 日本

一个既简单又强大的版本控制系统,兼具独立设计的先进特性,且原生兼容 Git 存储后端。

📌 项目:jj-vcs/jj (Jujutsu)

Jujutsu (jj) 是一个原生兼容 Git 的新一代版本控制系统,通过自动保存修改、将冲突保存为 Commit 以及全量撤销操作,彻底消除了 Git 暂存区(Index)与复杂的冲突重试负担。

项目地址:https://github.com/jj-vcs/jj

🧩 核心作用

Jujutsu(命令行工具为 jj)是一个既简单又强大的版本控制系统,兼具独立设计的先进特性,且原生兼容 Git 存储后端。

❗ 解决的核心问题

传统的 Git 在日常开发中存在工作区暂存区(Index)概念繁琐、分支切换与变基(Rebase)容易中断、冲突处理复杂且难以恢复等痛点。Jujutsu 通过以下机制解决这些问题:

  • 工作区即 Commit:取消暂存区和 stash 概念,对文件的修改会自动增量提交并修正,无需频繁手动 commit 或 stash。

  • 冲突作为一等公民:允许将冲突直接记录在 Commit 中,即使有冲突也可以继续合并或变基,后续统一解决。

  • 全量操作日志与撤销:记录所有仓库操作(包括 pull/push/rebase 等),支持一键撤销(Undo),大幅降低误操作风险。

  • 自动变基(Auto-rebase):当修改历史 Commit 时,其所有后代提交会自动完成 rebase 和冲突传播。

👥 适用人群

  • 觉得 Git 命令行体验复杂、暂存区和历史重写(Rebase)门槛高的开发者。

  • 需要频繁重构历史、进行 “基于 Patch” 开发工作流的高级开发者。

  • 希望在保持现有 Git 远程仓库(如 GitHub/GitLab)协作的前提下,提升本地版本控制效率的工程团队。

🔍 关键特性

  • Git 高度兼容:使用 Git 仓库作为物理存储层,可无缝对接现有 Git 远程服务及相关工具。

  • 匿名分支与简洁 UX:不必为每一个微小的修改专门创建分支名称。

  • 强大的撤销机制:提供完备的操作日志(Operation log),随时恢复到过去的仓库状态。

  • 并发与分布式安全:针对 Dropbox 或 S3 等同步环境进行了容错设计,不会因并发读写导致仓库损坏。

🚀 快速了解建议

  1. 访问 Jujutsu Homepage 阅读 README 中的项目介绍与设计理念。

  2. 按照官方文档中的 Getting Started 指引完成安装并尝试 Tutorial,体验 jj的工作流。

  3. 如果已有 Git 使用经验,可优先阅读 Git comparison 了解 jj与 git命令的对应关系。

阅读原文

跳转微信打开

  •  

【第3731期】每次都可以放心遵循的视觉设计法则

Anthony Hobday 2026-07-20 09:00 日本

一套源于优秀设计实践、能闭眼套用且保证视觉及格线以上的28条硬性视觉法则。

前言

好的设计不靠灵感,而靠法则。从色彩明度、元素间距到字体搭配与投影处理,这些经过反复验证的准则涵盖了视觉设计中最核心的决策。你不必每次都恪守它们 —— 如果有充分的理由,尽管打破。但遵循它们,永远不会出错。

今日前端早读课文章由 @Anthony Hobday 分享,@飘飘编译。

用于解决实际工作中的【UI 系统规范化与设计走查】问题,最值得借鉴的一点是:测量必须符合数学尺度比例(基于 8px 步长等),并对阴影和间距制定绝对物理公式(如模糊值 = 两倍距离),从而将感性的视觉直觉转化为可复制、易走查的理性工程标准。

译文从这开始~~

你不必每次都恪守这些法则。如果你有充分的理由打破其中任何一条,尽管去做。但每次遵循它们,永远不会出错。

1、用近黑和近白代替纯黑与纯白

纯黑与其他颜色搭配时,往往会产生令人不适的强烈对比;纯白则过于刺眼。请使用接近黑色和接近白色的色值来替代。本文后续提到的 "黑" 与 "白",均默认你已遵循了这一条。

2、为中性色注入一丝彩色

中性色通常指黑、白、灰。如果你的界面中使用了某种彩色,不妨在中性色中融入少许该色调,这会让整体配色显得更加和谐统一。若使用 HSB 色彩模式,饱和度控制在 5% 以内即可。

3、对重要元素使用高对比度

所谓重要元素,是指按钮、正文内容,或任何需要用户注意到的部分。较高的对比度能让元素更抓人眼球 —— 这正是重要元素所需要的。而那些不需要用户特别留意的元素(如结构性元素、投影),则可以将对比度降到最低。

4、设计中的一切都应有据可循

你应当对设计中的每一个细节都做到心中有数 —— 留白、对齐、大小、间距、颜色、阴影,无一例外。如果有人随手指向你设计中的任意一处,你都应该能说出它为何是这个样子。做不到这一点,你的设计就不会有浑然一体的感觉。

如果你是设计新手,可以把这条法则当作自我检视的提示 —— 去发现那些你尚未深思熟虑的地方。

5、视觉对齐往往优于数学对齐

设计软件可以帮你实现数学意义上的精确对齐,但有些形状并不适合这种对齐方式。例如,某些不规则图形的视觉重心与几何中心并不重合。很多时候,你需要凭肉眼去调整,直到看起来 "对了" 为止。

凭眼睛对齐需要一定的练习,但只要你经常这样做,很快就能掌握这种感觉。

6、字号越大,字距与行高越小;字号越小,则反之

这条法则适用于所有文本。字号越大,字母之间和行与行之间所需的间距就越小;反之亦然。如果忽视这一点,大号文字会显得松散零落,小号文字则会拥挤不堪。

7、容器边框应同时与容器和背景形成对比

举个例子:假设你有一张带有 1px 边框的卡片,卡片背景较深,而它所在的页面背景更深。此时,这条 1px 边框的亮度应当比两者都高,而不是取二者之间的某个中间值 —— 否则容器的边缘看起来不够清晰利落。浅色背景同理:1px 边框应当比两个背景色都更深。

下方示例中,左侧为错误做法,右侧为正确做法。

8、每个元素都应与其他元素对齐

对齐帮助我们感知事物之间的关联。如果某个元素与其他任何元素都没有对齐关系,它就会显得格格不入,仿佛不属于这个设计。理想情况下,每个元素都应依据某种逻辑与其他元素对齐。

9、调色板中的各颜色应具有明显不同的明度

当颜色之间存在明度差异时,它们不仅在色相上,更在明暗层次上彼此区分。这会带来更优秀的配色方案,因为各颜色之间不会相互争抢视觉注意力。

10、为中性色注入彩色时,应统一使用暖色或冷色,切勿混用

如果你同时用暖色和冷色去调和中性色,整体色彩将缺乏统一感。

下方示例中,左侧的背景使用了暖色调而前景使用了冷色调;右侧则统一使用了暖色调的背景与前景。

11、尺寸数值之间应存在数学关联

元素之间的间距以及元素本身的大小,都应遵循某种比例尺度。这将使设计呈现出和谐统一的观感。在下方示例中,所有元素均采用 8 的倍数。基于比例尺度建立的水平和垂直网格,能帮助你确保图片等元素的尺寸恰到好处。

12、元素应按视觉重量排列

如果你有一组元素排成一行或一列,其中一些视觉分量比其他的更重(比如两个按钮和三个链接),你应当将它们排列成三角形的递减态势 —— 视觉最重的元素排在最前,最轻的排在最后,依次递减。有一点需要注意:视觉最重的元素应当位于外侧边缘。例如,如果你的元素紧靠设计的右边缘,那么最重的元素就应当贴着右边缘放置。按重量或大小有序排列的元素,看起来会更加舒适。

13、使用水平网格时,请采用 12 列

如果你打算将设计划分为纵向列,请使用 12 列网格。12 列网格可以灵活拆分为 1 列、2 列、3 列和 4 列,给你提供了极大的布局弹性。

14、间距应存在于高对比度的节点之间

当你在设计中度量元素之间的距离时 —— 比如你希望落地页内容块之间保持 100px 的垂直间距 —— 间距应当从一个高对比度的节点量到下一个。因为我们的眼睛是通过对比度来识别元素边界的,所以我们会本能地期望间距存在于对比度变化的节点之间。

举个例子:白色背景上的黑色段落文字,对比度节点就是上一段的末尾和下一段的开头。但如果你在某段白色文字的背后加了一块黑色背景,那么间距就应当从上一段的末尾量到黑色背景的起始处,再从黑色背景的起始处量到段落文字的开头。

15、离用户越近的元素应越亮

屏幕上的元素越靠近用户,就应该越明亮。这条法则在浅色模式和深色模式下都适用,因为它符合现实世界中光线的运作方式。

下方示例中,左侧为错误做法,右侧为正确做法。

16、投影的模糊值应为偏移值的两倍

例如:如果你创建的阴影在 Y 轴方向偏移 4 像素,那么模糊值就应设为 8 像素。随着元素 "靠近" 观者,适当降低阴影的不透明度也是个好做法。这样看起来自然,因为元素越接近光源,其阴影就会越模糊、越淡。

17、简繁相宜:简置于繁上,或繁置于简上

复杂的背景(例如多彩的渐变填充)搭配简洁的前景(例如纯文字)效果最佳;反之,复杂的前景元素放在简洁的背景上也同样出色。简对简可以,但容易显得平淡。复杂对复杂则应尽量避免 —— 这很难驾驭,而且会让画面杂乱不堪。

18、容器颜色的明度应控制在合理范围内

背景与容器之间的明度差异,在深色界面中应控制在 12% 以内,在浅色界面中应控制在 7% 以内。这里的百分比指的是 HSB 色彩模式中的明度值。

这一结论基于我对约 100 个设计精良的网站所做的研究,逐一比对了容器与背景的明度关系。

19、外边距应大于或等于内边距

在容器中,内边距是容器内各元素之间的间距,外边距是元素与容器边缘之间的间距。外边距应当大于或等于内边距。关联性越强的元素应该靠得越近 —— 容器内的元素彼此之间的关联,显然强于它们与容器本身的关联。

20、正文字号不应小于 16px

16px 是大多数浏览器的默认字号。低于此值的文字会变得难以阅读,因此正文最好避免使用更小的字号。超出 16px 越多,可读性就越好。

如果你自己编写代码,可以使用你偏好的任何像素等效单位。

21、每行字数控制在 70 个字符左右

60 个字符或 80 个字符都无伤大雅,但如果偏离太远,就可能出现微妙的可读性问题。

22、按钮的水平内边距应为垂直内边距的两倍

标准按钮的形态是宽大于高。如果你希望用户一眼就能辨认出某个元素是按钮,最好遵循这一惯例。在下方示例中,标签上下的内边距为 30px,左右的内边距为 60px。

23、字体最多使用两种

第二种字体是强化设计理念的好机会,也能为设计增添一些变化。但很少有必要使用两种以上 —— 过多的字体反而会让设计显得视觉混乱。

24、圆角嵌套要正确

有时你会遇到两层或多层圆角嵌套的情况。如果想让它们看起来和谐,内层圆角半径应等于外层圆角半径减去两者之间的间距。在下方示例中,外层圆角半径为 30px,间距为 20px,因此内层圆角半径为 10px。

25、不要将两条硬分割线紧邻放置

背景色的过渡、容器的边缘、分隔线都会形成硬性的视觉分割。你不应让两条或更多硬分割线彼此相邻。在下方示例中,红色标注的部分即为问题所在。多重硬分割会造成视觉杂乱,夺人眼球。在示例中,我去掉了背景色过渡,使硬分割仅来自容器边缘。

26、深色界面中不要使用阴影

在深色界面中很难让阴影发挥作用。要么背景色需要足够亮才能显出阴影,要么阴影本身需要足够生硬才能凸显 —— 而这比阴影应有的存在感强了太多。况且在暗处还能看见阴影,本身也不太合乎逻辑。

27、不要混用不同的纵深表现手法

在整个界面中应始终使用同一种纵深表现手法。如果你的主导航栏用了柔和的投影,那么其他地方也应使用柔和投影,不要突然换成硬边 / 抽象投影,或干脆不加投影。这些手法中的任何一种都可以,但混用会显得不一致、不专业。

28、降低图标与文字搭配时的对比度

图标在视觉上往往比与之搭配的文字更重。当图标与文字配对时,应适当降低图标与背景的对比度。在下方示例中,我通过调整透明度来实现这一点,但你也可以直接将图标颜色调浅或调深。

关于本文
译者:@飘飘
作者:@Anthony Hobday
原文:https://anthonyhobday.com/sideprojects/saferules/

这期前端早读课
对你有帮助,帮” 
赞 “一下,
期待下一期,帮”
 在看” 一下。

阅读原文

跳转微信打开

  •  
❌