Ming(✸,✸)

学习，探索。

[AI超元域 @AISuperDomain]

你以为装一堆 Agent Skills 是增强？

其实可能是在给每一次 Prompt 交“上下文税”。

今天看到一个很实用的开源项目：deadskills。

它专门帮你找出 Claude Code / Codex 里那些“装了但几乎没用过”的 Skills。

每个 Skill 的名称、描述都会被塞进上下文里，即使你根本没调用它，也会持续消耗 Token。

deadskills 会本地读取你的使用记录，告诉你：

哪些 Skills 真的被用过
哪些 90 天没动过，已经变成 zombie
哪些从安装后就没调用过，属于 dead skills
每个 Skill 大概给你增加了多少 Token 成本
最重要的是：
本地运行
无需登录
无遥测
运行时不联网

一行命令就能看报告：

npx deadskills

如果你经常折腾 Claude Code、Codex、Agent Skills，这个工具很适合定期跑一次。
AI Agent 时代，真正贵的不只是模型调用费，还有你看不见的上下文负担。

https://t.co/U45vE7o6UL

[Ming(✸,✸) @lam_lee]

@mycuzzin12_2009 @ZeroZ_JQ 为什么 enio 有搞头？

[Vincent @Vincent_AINotes]

家里吃灰的 iPhone 或 iPad，居然还能给 Mac 当副屏。

OpenDisplay 装好后，Mac 会把它认成一块正经显示器，窗口能直接拖过去。插线能用，Wi-Fi 也能连，触控、双指滚动、横竖屏切换都有。

免费开源，也没有订阅。地址放下一条👇

[riba2534 @riba2534]

整理了一下我自己觉得李笑来写的好的几本书，网上流传的版本大多是影印版，阅读体验极差，我整理后做成了精校数字版的开源电子书：https://t.co/SvgCV98fVp
- 《财富自由之路》2017年
- 《韭菜的自我修养》2018年
- 《让时间陪你慢慢变富》2020年
- 《财富的真相》2023年
- 《思考的真相》2024年
- 《专注的真相》2024年
如有侵权，请联系我随时删除。

[Avi Chawla @_avichawla]

Stanford researchers did it again.

They just built the agent-native version of Git.

When an agent works on a longer task, the run builds up a lot of state.

This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.

Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.

The tests start failing, and the run goes off track, although everything through step eight was correct.

By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.

The other options are a person stepping in to redirect it or restarting the whole run from step one.

That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.

The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.

It records what the agent said and which tools it called, but not the live state underneath.

That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.

Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.

Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.

Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.

Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.

Going back to a previous step is then a single call that forks from that commit and continues from the exact state.

The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.

Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.

In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.

Not everything is reversible though.

Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.

Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.

They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.

It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.

If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.

Shepherd Repo: https://t.co/5e8W5oxY6F

(don't forget to star it ⭐ )

That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.

Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.

Read it below.

[LinearUncle @LinearUncle]

推荐一个开源最强的本地跨 AI的session管理器：AgentsView。

它会把 Claude Code、Codex、Cursor 等工具的历史记录统一索引起来，让你快速搜索旧对话、查看项目记录、统计 token 和成本等。

全平台客户端支持（甚至支持web & CLI）。
地址在评论区。

[Ming(✸,✸) @lam_lee]

@trq212 too dumb to need fable

[Lonely @Lonely__MH]

🚀牛逼！Hermes Agent 的浏览器扩展来了

安装之后，直接在浏览器侧边栏就可以处理：

- 任意页面实时聊天

- 一键切换本地模型，Grok / GPT / Claude 随心切换

- 支持页面视觉分析 + 截图

- 本地或远程 Gateway 都能连接

最关键是直接对接你的 Hermes runtime：tools、skills、memory、MCP 全部继承，无缝衔接

社区开源，浏览器体验起飞✈️

传送门👉🏻：https://t.co/5kldRzEuJ8

[Andrew Ng @AndrewYNg]

“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d like to share my 3 key loops, shown in the image below, for building 0-to-1 products. These loops guide not just how I build software, but also how I decide what software to build.

Agentic coding loop: Given a product specification and optionally a set of evals (that is, a dataset against which to measure performance), we can have an AI agent write code, test its work, and keep iterating until the code is bug-free and meets its specification. This idea of closing the loop took off around the end of last year, and it has been a game changer in enabling coding agents to work longer productively without human intervention. For example, over the weekend, I was building an app for my daughter to practice typing, and my coding agent could easily work for around an hour, using a web browser to check what it had built multiple times before getting back to me, without needing my intervention.

The engineering loop executes quickly. Every few minutes, the coding agent might build and test a new version of the software. I hear frequently from developers who are finding new ways to engineer more effective engineering loops. This is an active area of invention!

Developer feedback loop: In this loop, a developer examines the current product and steers the coding agent to improve it. Last year, a lot of developers (including me) were acting as the QA (quality assurance) function for our coding agents, manually finding bugs and then asking the agent to fix them. But with coding agents much more able to test their own code, the amount of time we need to spend on this function has decreased significantly. This allows us to make higher-level product decisions, such as what key features to offer, where the UI needs improvement, and so on.

The developer-feedback loop operates over time intervals between tens of minutes and hours — that's how frequently a developer might review a product and give feedback. In the case of the typing app, I changed my mind a few times about the visual design, what cat costumes she can unlock as she learns (she loves cats), and the user flow for a grown-up to log in and steer the child's learning experience.

When a developer has a clear vision for what to build, it is still a lot of work to translate that vision into a specification for a coding agent to implement. Further, after the developer has seen an implementation, they might update (or perhaps clarify) the spec to steer it toward what they want. If you find that the system repeatedly runs into certain problems, building a set of evals for the agent becomes useful.

AI-native teams are increasingly using AI to help shape product direction, for example, automating the gathering and analysis of usage data, summarizing written and verbal customer feedback, or carrying out competitive analysis. However, for pretty much all the products I’m involved in, I see humans as having a significant context advantage over current AI systems — we know a lot more than the AI system about the users and the context the product has to operate in — and thus humans play a critical role. Many people describe this human contribution as “taste,” but I prefer to think of it as humans having a context advantage, since that gives us a clearer path to helping AI systems get better. This also speaks to why this step can’t be automated: So long as the human knows something the AI does not, human-in-the-loop is needed to to inject that knowledge into the system.

External feedback loop: This includes a wide range of tactics like asking a few friends for feedback, launching to alpha testers, or putting the code into production with A/B testing. These tactics are usually slow, rarely taking less than hours and sometimes taking days or even weeks. This data informs the developer vision, which in turn continues to drive the detailed product spec, which in turn drives the coding agent.

With coding agents speeding up software development, more engineers are starting to play a partial product management role. For many engineers who are growing into this role, the hardest part is shaping the product vision and striking a balance between building (bridging the gap between vision and spec) and getting user feedback to evolve the vision. It is important to do both!

I will write more about how to do this in future posts, but for now, I find it encouraging that engineers are playing an expanded role (just as product managers and designers now do more engineering).

[Original text: The Batch]

[Line @0xLinehigher]

非常建议每一个选择计算机系的大学生，在大学时期将cs336啃完，不开中文字幕，只开英文字幕。啃完之后，你对LLM的理解和英语能力至少在国内前百分之1%。

这门课超过国内任何一所大学里面计算机的课程。

《Stanford CS336: Language Modeling from Scratch》 是一门斯坦福大学计算机科学系的课程，这门课每一年春季都会有，每一年都会在油管免费开放。

里面的内容非常前沿而且实用，目前油管上的版本是25年的版本，第一节课提到的模型已经是GPT-4。而与此同时，国内的计算机课程还在用着至少5年前的PPT。

依稀记得，我的第一节C语言课程，PPT的里面的演示系统是XP...

啃完CS336，你会收获LLM的全栈技术栈，从数据收集，清洗，模型训练，优化，评估到部署，Transforemer架构，注意力机制，各种目前最新的机器学习训练方法

这门课的目标就是从头让你手搓一个LLM，亲手实现完整的pipeline。

两位主要讲师：
1、Percy Liang
MIT 本科 + MEng，UC Berkeley 博士（2011）。曾在 Google 做 post-doc，后加入 Stanford 任教。

2、Tatsu
Harvard 本科（统计与数学），MIT 博士（co-advised by Tommi Jaakkola 和 David Gifford），之后在 Stanford 做 Percy Liang 和 John Duchi 的 post-doc

耐心啃完这个，所有计算机课程几乎都不需要上了...因为在过程中必然会遇到很多不懂的点，边学边查，然后顺带就把学校关于机器学习和深度学习的专业课给学完了。

如果刚上大一，可以先看cs50，然后再到cs336，先稍微打点计算机的基础。

与此同时，一定要把线性代数学好，将高数丢了都要把线性代数学好，线性代数是机器学习的底层DNA。

如果线性代数没有学好，会比较难理解神经网络，相当于没学好加减乘除就想去求导。

[向阳乔木 @vista8]

字节火山引擎大会上洪定坤的分享，有几点值得参考：

1. 用原型驱动开发：用 AI 生成可交互原型替代 PRD，基于这个讨论，提前暴露分歧。

2. AI Development系统化：AI写 Spec → 功能实现→ Browser Use 验证→自动提交上线

3. Harness 基建：上下文工程 + 架构约束 + 团队知识 Memory + 技术债梳理 ，能把可交付性从 40~60 分提到 80 分

原文见评论

[宝玉 @dotey]

如果你 token 多的用不完，又没啥好玩的事情，给你一个项目 decode-codex 玩玩：反编译 Codex App 代码

这个项目当前就两个 Skills：

1. codex-app-ref-refresh skill
解包已安装的 https://t.co/huJYxhc2y5（app.asar）到 ./ref 并格式化./ref/

2. deobfuscate-javascript skill
把 ref/webview/assets 里打包的 JS 反混淆成命名有意义的可读代码./restored/

用法很简单，确保你安装了 Codex App。

先使用 codex-app-ref-refresh skill 把里面的代码解包提取出来。

然后使用 deobfuscate-javascript skill 把提取出来的代码变成可以正常阅读的代码，这一步要配合 /goal，不然还原不了多少文件。

项目地址：https://t.co/9eYnWmQWWU

建议 fork 到自己的Repo，自己测试。

[Adam Shao @AdamShao]

正式开源我的漏洞挖掘工具：https://t.co/wCNN7rb4bq

这是一个基于 AI Agent 的全自动漏洞挖掘工作流，你只要告诉 AI 你要找什么项目的漏洞，它就会自动下载代码和文档，深度审计代码，发现可疑漏洞，自动在本地和线上验证漏洞，最后生成报告。

Alpha leak: 如果你有很多 AI token 用不完，你可以给 agent 一个 goal，让它去各大白帽平台搜索赏金任务，寻找漏洞，获得赏金。

[极客杰尼 @seekjourney]

挖到宝了！这个 codex 教程截图和步骤真够详细的，堪称喂饭级。

https://t.co/qB9JPWQmLQ

[Paul Solt @PaulSolt]

https://t.co/XJQvXEC4oq

[Xiangyi Li @xdotli]

sharing my personal library on evals 1/n

i put together the highest quality blogs, podcasts, papers, and projects on evals. additions are welcome!

[Kun Chen @kunchenguid]

many people asked me to make a video about my complete agentic engineering workflow

excited to share it's finally here!!!

it took me about 20 hours in total to record this 45 minutes of walkthrough - it covers everything i do to ship production quality code at an average 40+ PRs/day velocity

hope this can be a useful reference to everyone exploring good ways to use AI. and would appreciate a reshare with anyone you think might benefit from this!

enjoy! https://t.co/oA0UCrBvqo

[BearTalk @Bearlagcy]

https://t.co/V3Aw0aGeDg

[Vercel @vercel]

Introducing eve, an agent framework.

𝚊𝚐𝚎𝚗𝚝/
𝚊𝚐𝚎𝚗𝚝.𝚝𝚜
𝚒𝚗𝚜𝚝𝚛𝚞𝚌𝚝𝚒𝚘𝚗𝚜.𝚖𝚍
𝚝𝚘𝚘𝚕𝚜/
𝚜𝚔𝚒𝚕𝚕𝚜/
𝚜𝚊𝚗𝚍𝚋𝚘𝚡/
𝚜𝚌𝚑𝚎𝚍𝚞𝚕𝚎𝚜/

Like Next.js, for agents.
https://t.co/ezUIGLkSqG

[lifcc @mylifcc]

Vercel AI SDK 7 刚更新：HarnessAgent 现在可以用统一 API 直接运行 Claude Code、Codex、Pi 等成熟的 agent harnesses。

核心一句话： Write the agent once. Use the best harness available. 以前我们能随意换模型，现在连整个 agent runtime（skills、sandbox、sessions、permission flows、compaction、sub-agents 等）都能标准化切换了。

这对想长期做生产级 agent 系统的开发者，是个值得关注的信号。 （目前 experimental，API 后续可能有 breaking changes）