产品工具

AI 产品发布、工具评测、使用技巧与最佳实践

baoyu-skills 实测：25k Star 的 AI 内容技能库，如何省 65% 创作时间？

作者
baoyu-skills 实测：25k Star 的 AI 内容技能库，如何省 65% 创作时间？

痛点：内容创作者的「五马分尸」困境

做自媒体的人都知道，一篇好文章的诞生需要经历 5+ 个工具切换：写 Markdown → 做封面图 → 插配图 → 排版转 HTML → 发布到微信/X/微博 → 还要做信息图、幻灯片、漫画…… 每个环节都要登录不同账号、适应不同格式、处理不同 API。一个中等产出的内容创作者，每周在这套流程上花 10+ 小时是常态。

宝玉（JimLiu）的 baoyu-skills 就是来终结这种碎片化流程的——它是一套覆盖「创作→设计→发布」全链路的 AI Agent 技能库，目前已积累 25,461 个 Star，成为中文开发者圈增长最快的内容技能集之一。

工作原理：维度化设计系统 + 多平台统一接口

baoyu-skills 的核心设计思想是维度化——把视觉设计拆解为可组合的维度（风格 × 布局 × 色彩 × 渲染方式），让 AI 在每个维度上做选择，而不是笼统地「生成一张好看的图」。

用户输入（Markdown/文本）
    ↓
baoyu 内容分析引擎
    ↓
维度推荐（风格 × 布局 × 色彩 × 渲染方式）
    ↓
用户确认/微调
    ↓
多后端图片生成（11 种 AI 服务可选）
    ↓
格式转换（Markdown → WeChat/X HTML）
    ↓
多平台发布（微信公众号/X/微博）

与同类方案（如 Anthropic 的 MCP 或单点工具）的差异在于：它不是「一个能做很多事的瑞士军刀」，而是「一套能互相协作的专用工具链」——每个 skill 专注一件事，通过共享的设计系统保持视觉一致性。

功能拆解：20+ 技能的三层架构

第一层：内容创作（7 个技能）

技能 核心能力 适用场景
baoyu-xhs-images 小红书图片卡生成，12 风格 × 6 布局 × 3 色板 种草文、知识卡片、穿搭分享
baoyu-infographic 专业信息图，21 布局 × 17 风格 数据可视化、流程说明、架构解析
baoyu-diagram SVG 图表（流程图/时序图/架构图/类图） 技术文档、系统设计
baoyu-cover-image 文章封面图，5 维度系统（类型×色彩×渲染×文字×情绪） 博客、公众号、X 头图
baoyu-slide-deck 幻灯片生成，16 种预设 + 4 维度自定义 演示文稿、培训材料
baoyu-comic 知识漫画，5 画风 × 7 语调 × 6 版式 教程漫画、故事化内容
baoyu-article-illustrator 智能文章插图，6 类型 × 8 风格 博客配图、技术文章

第二层：多平台发布（3 个技能）

技能 核心能力 亮点
baoyu-post-to-wechat 微信公众号发布 多账号管理、API/浏览器/远程 API 三模式、EXTEND.md 自定义主题
baoyu-post-to-x X/Twitter 发布 支持推文串和 X Articles
baoyu-post-to-weibo 微博发布 头条文章、图片/视频附件

第三层：AI 生成 + 工具（10 个技能）

技能 核心能力
baoyu-image-gen 多后端图片生成（OpenAI/Azure/Google/DashScope/MiniMax/Replicate 等 11 种）
baoyu-translate 三模式文档翻译（quick/normal/refined）
baoyu-youtube-transcript YouTube 字幕下载，支持多语言/章节/说话人识别
baoyu-url-to-markdown 网页转 Markdown，Chrome CDP 抓取
baoyu-markdown-to-html Markdown 转微信兼容 HTML，语法高亮
baoyu-format-markdown Markdown 格式化（标题/摘要/排版）
baoyu-compress-image 图片压缩
baoyu-wechat-summary 微信群聊摘要（需 wx-cli）
baoyu-electron-extract Electron 应用资源提取
baoyu-danger-gemini-web Gemini Web 逆向交互

实测数据：25k Star 背后的设计深度

核心数据

指标 数值
GitHub Star 25,461
Fork 2,825
创建时间 2026-01-13（7 个月）
技能数量 20+
支持平台 微信、X、微博、小红书、YouTube
AI 图片后端 11 种（OpenAI/Azure/Google/DashScope/Z.AI/MiniMax/Replicate/Jimeng/Seedream/Agnes/OpenRouter）
信息图布局 21 种
信息图风格 17 种
小红书风格 12 种
幻灯片预设 16 种

设计系统维度数

技能 维度 组合数
baoyu-infographic 21 布局 × 17 风格 357
baoyu-xhs-images 12 风格 × 6 布局 × 3 色板 216
baoyu-cover-image 6 类型 × 11 色彩 × 7 渲染 × 4 文字 × 3 情绪 5,544
baoyu-slide-deck 16 预设（5 纹理 × 6 情绪 × 5 字体 × 3 密度） 480+
baoyu-comic 5 画风 × 7 语调 × 6 版式 210

安装便捷度

# 一行安装（推荐）
npx skills add jimliu/baoyu-skills

# 或通过 Agent 指令
/plugin marketplace add JimLiu/baoyu-skills

成本对比

以生成一篇带封面图 + 3 张配图的微信公众号文章为例：

步骤 传统方式 baoyu-skills
写 Markdown 30min 30min
做封面图 20min（Canva/PS） 1min（/baoyu-cover-image）
插配图 30min（找图/生成/裁切） 3min（/baoyu-article-illustrator）
转 HTML 15min（排版工具） 1min（/baoyu-markdown-to-html）
发布 10min（登录后台） 2min（/baoyu-post-to-wechat）
总计 105min 37min

效率提升：65%（节省约 68 分钟/篇）

安装指南 + 适用场景

安装

# 全量安装
npx skills add jimliu/baoyu-skills

# 项目级别（只装需要的）
mkdir -p .agents/skills
# 复制需要的 skill 目录
cp -r baoyu-cover-image .agents/skills/
cp -r baoyu-post-to-wechat .agents/skills/

配置

# 创建配置目录
mkdir -p ~/.baoyu-skills

# 配置 API 密钥（按需）
cat > ~/.baoyu-skills/.env << 'EOF'
OPENAI_API_KEY=sk-xxx
WECHAT_APP_ID=xxx
WECHAT_APP_SECRET=xxx
EOF

自定义扩展

# 自定义品牌色
mkdir -p .baoyu-skills/baoyu-cover-image
cat > .baoyu-skills/baoyu-cover-image/EXTEND.md << 'EOF'
## Custom Palettes
### corporate-tech
- Primary: #1a73e8, #4A90D9
- Background: #F5F7FA
EOF

谁适合用？

最适合：

  • 内容创作者（自媒体、博客作者、知识付费）
  • 技术写手（架构图、流程图、技术博客）
  • 营销团队（社交媒体运营、多平台分发）
  • AI 开发者（扩展 Agent 内容生产能力）

不适合：

  • 只需要单一功能的用户（装全量会增加 context 开销）
  • 无法访问 Node.js 环境的服务器
  • 需要离线运行的场景（图片生成依赖 API）

与已有技能的关系

已有技能 重叠技能 区别
wechat-publisher baoyu-post-to-wechat baoyu 版本更成熟，支持多账号/EXTEND.md
drawio-skill baoyu-diagram drawio 专注可编辑图表，baoyu 专注 SVG
github-trending 无 互补

结论：baoyu-skills 是目前中文圈最完整的 AI Agent 内容技能库，25k Star 实至名归。它的核心优势不是「做得多」，而是「做得系统」——维度化的设计系统让视觉输出保持专业和一致。对于需要高频内容产出的团队，它可能节省 50%+ 的设计和发布流程时间。

评分：8.5/10（功能完整度 9/10、设计深度 9/10、文档质量 8/10、安装便捷度 8/10、中文友好度 9.5/10）

相关阅读：

  1. Ponytail 深度评测：115k Star 的「懒人高级工程师」，真能省 54% 吗？ — 另一个高 Star AI 技能的设计思路对比
  2. Planning-with-Files 实测：26k Star 的三文件铁律 — 上下文工程 vs 内容工程的不同路径

Ponytail 深度评测：115k Star 的「懒人高级工程师」，真能省 54% 代码吗？

作者
Ponytail 深度评测：115k Star 的「懒人高级工程师」，真能省 54% 代码吗？

115k Star、3 个月、MIT 协议——Ponytail 是 2026 年增长最快的 AI Coding Skill。它号称能让 AI agent 像「最懒的高级工程师」一样写代码，砍掉 54% 的冗余代码。但独立测试显示，真实效果只有 15%。这个差距从何而来？它到底值不值得装？

它是什么：100 行 Markdown 实现 7 级懒人阶梯

Ponytail 的核心是一个 7 级决策阶梯，在 AI agent 写代码之前强制执行：

  1. 这东西真的需要存在吗？→ 不需要就跳过（YAGNI）
  2. 代码库里已经有了？→ 复用，别重写
  3. 标准库能做？→ 用标准库
  4. 平台原生功能能做？→ 用原生（比如 <input type="date"> 代替日期选择器库）
  5. 已装的依赖能做？→ 用已装的
  6. 一行能搞定？→ 一行搞定
  7. 以上都不行？→ 写能工作的最小代码

关键安全阀：输入验证、错误处理、安全措施、无障碍性永远不能省。用户坚持要完整版本就照做，不再争论。

支持三个强度级别：lite（提建议）、full（强制执行，默认）、ultra（YAGNI 极端主义，删减优先，挑战需求本身）。

Benchmark 真相：官方 -54% vs 独立测试 -15%

官方数据（Haiku 4.5，12 个任务，n=4）

指标 ponytail caveman “YAGNI + one-liners”
代码行数 -54% -20% -33%
Token -22% +7% -14%
成本 -20% +3% -21%
时间 -27% +2% -30%
安全性 100% 100% 95%

JetBrains 独立测试（80 个配对任务，Sonnet 5）

指标 实测值 p 值
代码行数 -15% 0.088
成本 -10.3% 0.004 ✅
时间 -11% —
质量 无显著差异 —

三个关键发现：

1. 自激活率为零。直接复制 SKILL.md 到 skills 目录，agent 10 个 session 一次都没触发。必须用 plugin + SessionStart hook 注入才能生效。

2. 效果集中在过度工程场景。大型构建 -31%，已经精简的任务几乎不动。宣传的 -54% 是 12 个刻意选择的「过度工程陷阱」任务的均值，不是通用场景。

3. 首次出现统计显著的成本节省。在 JetBrains 系列测试（caveman -8.5%、rtk +7.6%）中，ponytail 是第一个 p<0.01 的正向结果。

Scott Logic 的「打脸」测试

Scott Logic CTO Colin Eberhardt 发现，仅用 7 个英文单词：

“Follow YAGNI principles, and one-liner solutions”

在 ponytail 自己的 benchmark 上跑出了比 ponytail 更好的分数（6.9 vs 8.25 LOC）。他的核心批评：

  • ponytail 本质就是 1990 年代 YAGNI 原则的重新包装
  • 原始 benchmark 任务过于简单（5 个约 10 行代码的任务）
  • 基线模型输出多个选项导致 LOC 虚高
  • 100 行 Markdown 配 115k Star，「这是新版 leftpad？」

ponytail 作者接受了批评，扩展了 benchmark（从 5 个任务到 agentic 级别的 12 个任务），修正了污染 bug，发布了诚实的修正版本。这在 AI Skill 生态中相当罕见。

与同类工具对比

维度 ponytail caveman rtk
作用面 输出（代码） 输出（文本） 输入（CLI 输出）
机制 7 级阶梯 压缩文本 压缩终端输出
实测代码 -15% -8.5% N/A
实测成本 -10.3% -8.5% +7.6%
安装复杂度 中（需 plugin） 低 低

关键洞察：这些工具作用在不同层面，可以叠加使用。ponytail 管输出（写更少代码），caveman 管表达（说更少话），rtk 管输入（读更少日志）。

优缺点总结

优点

  • 真实有效：独立测试证实 -10% 成本节省，统计显著
  • 安全阀到位：明确不碰验证/安全/无障碍，100% 通过率
  • 生态完善：20+ agent 兼容，5 个子技能（review/audit/debt/gain/help）
  • 方法论诚实：主动修正 benchmark bug，回应批评并扩展测试
  • 与 caveman 互补：一个管代码量，一个管文本量，不冲突

缺点

  • 宣传与实测差距大：-54% vs -15%，约 3 倍缩水
  • 自激活失败：必须用 plugin hook 注入，直接放 skills 目录无效
  • 核心思想不新：YAGNI 是 1990 年代的 XP 原则，7 个单词可以替代
  • 简单任务无效：代码已经精简时效果为零
  • Reddit 反馈：「复杂软件中创建了有 bug 的补丁，假设太多」

适用场景

适合：AI 过度工程严重的团队（agent 动不动装 5 个依赖、写 200 行 wrapper）、前端/全栈项目（原生 HTML/CSS 能替代大量 JS 库）、原型/脚本开发、与 caveman 搭配使用。

不适合：已经写得精简的代码库、复杂系统架构、需要严格类型/接口的项目、硬件/IoT 项目。

结论

Ponytail 是一个设计精良、诚实有效的 AI Skill，但不是魔法。它的真正价值不在于「省 54% 代码」（那需要刻意选择的测试场景），而在于建立一个思维习惯：在写代码之前先问「这真的需要吗？有没有更简单的方法？」这个习惯本身值 10% 的成本节省。

如果你想试：先用 full 模式别上来就 ultra；必须通过 plugin hook 安装别只复制 SKILL.md；搭配 caveman 使用效果叠加；定期跑 /ponytail-audit 检查是否真的减少了不必要的代码。

—— 评测基于 GitHub 仓库、JetBrains 独立测试（80 配对任务）、Scott Logic 批判分析、Reddit 社区反馈。数据截至 2026 年 8 月 ——

相关阅读

Understand-Anything 实测：80k Star 的代码知识图谱，让 AI 从「读代码」变成「教代码」

作者
Understand-Anything 实测：80k Star 的代码知识图谱，让 AI 从「读代码」变成「教代码」

20 万行代码的新团队，没有架构文档，最懂系统的工程师刚离职——这是每个开发者都怕遇到的场景。传统方式是逐文件翻代码，平均需要 2-3 周才能建立基本的系统认知。Understand-Anything 用一个多 Agent 流水线扫描整个项目，生成可交互的知识图谱，把「读代码」变成「看地图」。80,770 Star、6,790 Fork、MIT 开源——它可能是目前最火的代码理解工具。

工作原理

Tree-sitter + LLM 混合架构

Understand-Anything 的核心是「确定性结构 + 语义理解」的双层架构：

第一层：Tree-sitter（确定性）

  • 解析源码为具体语法树（CST）
  • 提取结构事实：imports、exports、函数/类定义、调用关系、继承链
  • 预构建 importMap，避免重复推导
  • 基于指纹的变更检测，支持增量更新

第二层：LLM（语义）

  • 读取解析后的结构 + 原始源码
  • 生成纯英文摘要、标签、架构层分类
  • 业务领域映射、导览生成、语言概念标注

这种分离保证了结构图的可复现性（同一代码 → 同一边），同时保留了意图理解（文件是「干什么的」而不仅是「导入了什么」）。

5+2 Agent 流水线

/understand 命令编排 5 个专用 Agent，/understand-domain 加第 6 个，/understand-knowledge 加第 7 个：

Agent 职责 用途
project-scanner 发现文件、检测语言和框架 /understand
file-analyzer 提取函数、类、imports，生成图节点和边 /understand
architecture-analyzer 识别架构层（API/Service/Data/UI/Utility） /understand
tour-builder 生成按依赖排序的导览 /understand
graph-reviewer 验证图完整性和引用完整性 /understand
domain-analyzer 提取业务领域、流程、步骤 /understand-domain
article-analyzer 从 wiki 文章提取实体和隐式关系 /understand-knowledge

File analyzer 并行运行，最多 5 个并发 worker，每批 20-30 个文件。

功能拆解

核心模块

模块 一句话 核心能力 适用场景
结构图探索 代码库变可点击地图 每个文件/函数/类是节点，带纯英文摘要和关系 新人入职、代码审查
领域视图 代码映射业务流程 域/流程/步骤的水平图 向非技术人员解释系统
导览生成 自动创建学习路径 按依赖排序的架构 walkthrough 新人 onboarding
Diff 影响分析 提交前看影响范围 /understand-diff 显示变更波及的模块 PR review、变更管理
模糊/语义搜索 按含义找代码 「哪些部分处理认证？」→ 跨图搜索结果 日常开发、调试
Persona 自适应 UI 根据角色调整详情 初级/PM/高级用户看到不同深度 多角色团队协作
知识库分析 Wiki 变力导向图 从 Karpathy 模式 LLM wiki 提取实体和关系 团队知识管理
Figma 分析 设计稿变知识图谱 页面→屏幕→组件/变体/实例，设计 token 模型 设计-开发协作
增量更新 只分析变更文件 –auto-update post-commit hook 自动维护图 持续集成
多语言输出 6 种语言支持 en/zh/zh-TW/ja/ko/ru 国际化团队

平台兼容性

平台 状态 安装方式
Claude Code ✅ 原生 Plugin marketplace
Cursor ✅ 自动发现 Clone 即用
VS Code + Copilot ✅ 自动发现 Clone 即用
Codex ✅ 支持 install.sh codex
Gemini CLI ✅ 支持 install.sh gemini
OpenCode ✅ 支持 install.sh opencode
Copilot CLI ✅ 支持 copilot plugin install
Kiro ✅ 支持 install.sh kiro
共 15+ 平台 ✅ 一行脚本

这是它最大的差异化优势——不是绑定某个编辑器的私有功能，而是跨平台的共享产出物。

实测数据

增长数据

指标 数值
GitHub Stars 80,770
Forks 6,790
Contributors 48+（Lum1104 贡献 523 commits）
Open Issues 290
创建时间 2026-03-15
最新版本 v2.9.0（2026-07-10）
许可证 MIT
主要语言 TypeScript 71.3%, JavaScript 15.8%, Python 8.8%

5 个月从 0 到 80k Star，AI 工具类增长最快之一。

Token 成本

据 Augment Code 分析和官方文档：

  • 首次扫描：消耗大量 Token（200k 行代码可能花费数十美元）
  • 增量更新：仅分析变更文件，Token 消耗大幅降低
  • 推荐：大项目用 Token 订阅或本地模型（如 Ollama）

Before vs After 对比

维度 传统方式 Understand-Anything
新人建立系统认知 2-3 周翻代码 1 天跑完流水线 + 看导览
变更影响评估 手动 grep + 阅读 /understand-diff 一键查看
架构文档 不存在或已过期 自动生成 + 增量维护
跨团队共享 口口相传 提交 JSON，所有人共享

已知局限

  1. LLM 成本自担：多 Agent 流水线调用真实 LLM，费用不低
  2. 图质量依赖代码质量：命名混乱、无关注点分离的代码库，图也会混乱
  3. 首次扫描耗时：200k 行代码即使 5 并发也要跑一阵
  4. 可能过期：不启用 –auto-update，图会漂移
  5. 290 个 Open Issues：活跃开发中，部分功能可能不稳定

安装 + 适用场景 + 结语

安装

Claude Code（最简）：

/plugin marketplace add Egonex-AI/Understand-Anything
/plugin install understand-anything

其他平台（一行脚本）：

curl -fsSL https://raw.githubusercontent.com/Egonex-AI/Understand-Anything/main/install.sh | bash

最适合谁

  • ✅ 新入职工程师：1 天建立系统认知，不用翻代码
  • ✅ 技术经理/PM：领域视图解释业务逻辑
  • ✅ 开源维护者：贡献者快速理解项目结构
  • ✅ 多平台团队：不同编辑器，同一份共享图

不适合谁

  • ❌ 小项目（<1k 行）：杀鸡用牛刀
  • ❌ 单人项目：没有共享需求
  • ❌ 预算敏感：首次扫描 Token 成本不低
  • ❌ 代码质量差的项目：图会反映混乱而非澄清混乱

对不同角色的意义

对个人开发者，它是理解陌生代码库的利器——接手遗留项目或研究开源项目时，5 分钟生成全景图。对团队，它是 onboarding 的基础设施——新人第一天就有交互式架构地图。对组织，它把「系统知识」从个人大脑里解放出来，变成可版本控制的团队资产。

相关阅读

本文数据来源：GitHub 仓库公开数据、Augment Code 报告、DEV.to 评测文章。截至 2026 年 8 月 28 日。

Planning-with-Files 实测：26k Star 的三文件铁律，让 AI 编程不再失忆

作者
Planning-with-Files 实测：26k Star 的三文件铁律，让 AI 编程不再失忆

你有没有经历过这种崩溃？

花了 2 小时让 Claude Code 做一个 Django 迁移，50+ 工具调用后上下文窗口炸了。/clear 一敲，Agent 一脸茫然问你：”请问您要做什么？”

这不是 bug，这是所有 AI 编程 Agent 的结构性缺陷：上下文窗口 = RAM，关机就清零。Manus AI 在被 Meta 收购前想明白了这件事——用文件系统当持久记忆，而不是把所有东西塞进上下文。

Planning-with-Files 就是这个思路的标准化实现：3 个 Markdown 文件 + Hook 自动注入，让 Agent 的”工作记忆”写在磁盘上，/clear 崩溃、上下文压缩、Session 断裂全不怕。26k Star、96.7% 断言通过率、3/3 盲测 A/B 全胜——这是目前持久化规划领域数据最硬的 Skill。

—

工作原理：三文件 + Hook 注入循环

核心模型

Context Window = RAM（易失、有限）
Filesystem    = Disk（持久、无限）

→ 任何重要东西都写到磁盘上

三个文件各管什么

文件 职责 更新时机
task_plan.md 阶段划分 + 进度追踪 + 决策记录 每完成一个阶段
findings.md 研究笔记 + 发现 + 决策依据 任何新发现
progress.md Session 日志 + 测试结果 全程持续记录

Hook 注入循环（5 个生命周期钩子）

Agent 工作 → 写决策/发现/错误到文件
     ↓
Hook 每轮开始时重新注入文件内容到上下文
     ↓
/clear 或崩溃 → 文件还在 → 新 Session 读文件恢复
     ↓
所有阶段完成 → Stop Hook 检查 → 释放完成信号

5 个 Hook 分别是：

  1. UserPromptSubmit — 每轮用户输入前注入计划
  1. PreToolUse — 每次工具调用前注入计划
  1. PostToolUse — Write/Edit 后提醒更新 progress.md
  1. Stop — 完成检查门控（gated 模式下阻止提前退出）
  1. PreCompact — 压缩前提醒刷盘

与 Manus AI 的关系

2025 年 12 月 Meta 以 20 亿美元收购 Manus。Manus 的核心秘密就是上下文工程：用 Markdown 文件当”磁盘上的工作记忆”。Planning-with-Files 把这个模式打包成了标准化 Skill，装到任何 Agent 上就能用。

—

功能拆解：五大模块逐个分析

1. 三文件模板系统

一句话：标准化的 task_plan.md、findings.md、progress.md 模板，带完整注释说明每个字段的用途。

核心能力：

  • 模板自带 Goal / Next Step / Current Phase / Phases / Decisions / Errors 结构
  • Phase 支持 pending → in_progress → complete 状态流转
  • 决策表和错误表结构化记录，避免重复犯错

适用场景：任何 3+ 步骤或 5+ 工具调用的复杂任务。

2. Hook 自动注入引擎

一句话：5 个生命周期 Hook 让计划文件每轮自动注入上下文，Agent 不需要”记得去读”。

核心能力：

  • UserPromptSubmit / PreToolUse 双保险注入
  • PostToolUse 提醒更新进度
  • Stop Hook 门控完成（gated 模式）
  • PreCompact 压缩前刷盘提醒

适用场景：长任务（50+ 工具调用），防止目标漂移。

3. Session 恢复系统

一句话：/clear 或崩溃后，自动从 IDE Session Store 读取历史对话 + 从文件恢复计划状态。

核心能力：

  • session-catchup.py 自动发现历史 Session
  • 提取上下文丢失后的对话片段
  • 生成恢复报告，帮助 Agent 快速补回状态

实测数据：恢复平均 5.0 turns（裸 Agent 13.3 turns），提速 62%。

适用场景：上下文窗口不够用、需要多次 /clear 的超长任务。

4. 并行任务隔离

一句话：v2.36.0+ 支持 .planning/YYYY-MM-DD-slug/ 目录隔离，多个并行任务互不干扰。

核心能力：

  • .active_plan 文件指向当前激活的计划目录
  • resolve-plan-dir.sh 智能解析计划路径
  • 防止共享父目录的线程注入无关计划

适用场景：多 Agent 并行、多任务交叉执行。

5. v3 长任务增强

一句话：Autonomous 模式 + Gated 完成门控 + Attestation 计划防篡改 + JSONL 运行日志。

核心能力：

  • --autonomous：去掉逐轮计划复述，保留注入
  • --gated：所有阶段完成前阻止 Agent 退出
  • SHA-256 Attestation：计划被篡改时 Hook 拒绝注入
  • JSONL Ledger： append-only 运行日志，可审计

适用场景：数小时级自主运行、需要保证完成质量的无人值守任务。

—

实测数据：有 Skill vs 没 Skill

Benchmark 总览（v2.21.0，claude-sonnet-4-6，2026-03-06）

测试项 有 Skill 无 Skill 差距
断言通过率（30 项） 96.7%（29/30） 6.7%（2/30） +90.0 pp
三文件模式遵循 5/5 0/5 +100%
盲测 A/B 胜率 3/3（100%） 0/3 全胜
平均评分（10 分制） 10.0 6.8 +3.2

Token 成本对比

维度 有 Skill 无 Skill 差距
平均 Token 19,926 11,899 +68%
平均耗时 115s 98s +17%

结论：多花 68% Token 换 96.7% 结构化输出——这是一笔划算的交易。额外 Token 花在创建 3 个文件、填充决策表和错误表上，不是浪费。

Session 恢复实测（v3.4.0 内部基准，2026-07-06）

恢复方式 恢复所需 Turn 数 正确性
Planning-with-Files 5.0 77/77 pytest 全绿
裸 Agent（无规划） 13.3 77/77 pytest 全绿

恢复提速 62%，零正确性惩罚。两者最终都能完成任务，但有 Skill 的快了将近 3 倍。

盲测 A/B 评语摘录

“Output B（有 Skill）满足所有四项结构化工作流期望……Output A（无 Skill）交付了真实可运行的代码，但不符合结构化多阶段规划格式。” — Eval 1 评审

“Output B 还包含了 pytz/zoneinfo 迁移（4.2 特有问题，Output A 完全遗漏）以及 django-upgrade 工具推荐……18,727 字符 vs 12,847，信息密度更高。” — Eval 4 评审

—

安装方式 + 适用场景 + 结语

安装（一行命令）

# Claude Code（插件路由，含 Hook + 斜杠命令）
/plugin marketplace add OthmanAdi/planning-with-files
/plugin install planning-with-files@planning-with-files

# 60+ Agent 通用（Agent Skills 标准）
npx skills add OthmanAdi/planning-with-files --skill planning-with-files -g

# npm 锁版本到项目
npm install planning-with-files

安装后输入 /plan 或让 Agent “plan this task” 即可触发。

最适合谁

角色 为什么需要
独立开发者 一个人做复杂项目，需要跨 Session 记住进度
长任务工程师 数小时级 Agent 运行，目标漂移是最大敌人
多 Agent 协作 并行任务隔离 + 计划防篡改
AI 编程初学者 结构化输出强制养成好习惯

不太适合谁

  • 简单 CRUD / 一次性脚本：3 步以内的任务不需要三文件，反而增加摩擦
  • 已有 ECC 等系统级方案的团队：ECC 的 Agent Harness 已经覆盖了规划功能，重复叠加意义不大
  • Token 预算极紧的场景：多花 68% Token 不是所有人都能接受

一句话结语

Planning-with-Files 解决的是 AI 编程中最痛的结构性问题——上下文易失。它的数据足够硬（96.7% 通过率、3/3 A/B 全胜），架构足够通用（60+ Agent、18+ IDE），代价也足够清晰（+68% Token）。如果你的 Agent 经常在长任务中失忆，这是目前最成熟的解法。

—

数据来源：GitHub OthmanAdi/planning-with-files README + docs/evals.md，截至 2026-08-27。

相关阅读：

⚠️ 本文为技术评测，非付费推广。Planning-with-Files 为 MIT 开源项目。

Karpathy Guidelines 实测：207k Star 的四条铁律，终结 AI 编程四大顽疾

作者
Karpathy Guidelines 实测：207k Star 的四条铁律，终结 AI 编程四大顽疾

痛点切入

用 AI 写代码的人，大概率遇到过这四种场景：

  • 自作主张 — 你让它加个功能，它默默假设你想要全量导出、分页、异步处理，一口气实现完才发现方向错了
  • 过度工程 — 一个 calculate_discount 函数，它给你写 30 行 Strategy 模式的抽象层
  • 顺手重构 — 你让它修个 bug，diff 里混进一堆「改进」：改了注释、重命名变量、删了你以为没用的代码
  • 无法验证 — 完成标准是「让它能用」，结果循环了 5 轮还在改

    • Andrej Karpathy（前 OpenAI / Tesla AI 负责人）在 X 上发了一段观察，直接点名这四个问题。有人把他的观点整理成一个 CLAUDE.md 文件，上线 7 个月拿到 207,175 Star，成为 GitHub 历史上增长最快的 AI 工具类仓库之一。

    这个 skill 不是代码库、不是插件、不是框架 — 是一个 2,357 字节的 Markdown 文件，四条规则，没有依赖。

    —

    工作原理

    Karpathy Guidelines 的核心思路是：用声明式目标替代命令式指令，用强制约束替代隐性期望。

    四条原则 vs 四个问题

    原则 解决的问题 核心机制
    Think Before Coding 假设错误、隐藏困惑 强制显式列出假设，不确定就问
    Simplicity First 过度工程、抽象膨胀 「高级工程师会说这太复杂吗？」自检
    Surgical Changes 顺手重构、无关改动 每行改动必须追溯到用户请求
    Goal-Driven Execution 无法验证、循环失败 把任务转为可验证的成功标准

    为什么只有 4 条？

    Karpathy 的原话：

    “LLMs are exceptionally good at looping until they meet specific goals… Don’t tell it what to do, give it success criteria and watch it go.”

    关键洞察：LLM 擅长「执行到满足条件」，但前提是条件得明确。四条原则不是在教 AI 怎么写代码，而是在 重新定义 AI 和人类的协作契约 — 让 AI 停下来问、写简单点、别乱动、定义清楚什么叫「完成了」。

    与同类方案的差异

    方案 思路 复杂度 效果
    Karpathy Guidelines 4 条行为约束 极低 中等（依赖模型遵守）
    Andrej Karpathy Guidelines (fork) 添加更多规则 低 中等
    ECC Agent Harness 68 Agent + 286 Skill 高 高（系统级强制）
    Planning-with-Files 持久化规划文件 中 高（崩溃恢复）

    Karpathy Guidelines 的独特之处：零依赖、零配置、一个文件搞定。它不强制执行，而是「建议」— 效果取决于模型的指令遵循能力。

    —

    功能拆解

    模块 1：Think Before Coding（思考优先）

    一句话：在写任何代码之前，先列出你的假设，不确定就问。

    核心能力：

  • 强制 LLM 显式声明假设（而不是默默假设后直接实现）
  • 面对歧义时呈现多个选项，而不是自己选一个
  • 遇到更简单的方案时主动提出
  • 困惑时停下来，描述哪里不清楚

    • 适用场景：需求模糊的任务、涉及隐私/安全的功能、多技术方案可选的决策

    示例对比：

    ❌ LLM 常见行为：用户说「导出用户数据」，直接写一个导出全量 JSON 的函数

    ✅ 应有行为：先问清楚 — 导出全部还是筛选？JSON 还是 CSV？哪些字段？数据量多大？

    模块 2：Simplicity First（简单优先）

    一句话：写能解决问题的最简代码，不加推测性功能。

    核心能力：

  • 禁止添加用户没要求的功能
  • 禁止单次使用的代码做抽象
  • 禁止不需要的「灵活性」和「可配置性」
  • 禁止为不可能的场景写错误处理
  • 200 行能 50 行解决就重写

    • 自检标准：「一个高级工程师会说这太复杂吗？」如果是，简化。

    适用场景：所有编码任务，尤其是脚本、工具函数、快速原型

    模块 3：Surgical Changes（外科手术式修改）

    一句话：只改必须改的，只清理自己制造的垃圾。

    核心能力：

  • 不「改进」相邻代码、注释或格式
  • 不重构没坏的东西
  • 匹配现有代码风格，即使你有不同偏好
  • 发现无关死代码时提一下，但不删

    • 清理规则：只删除你的改动导致的孤立代码（未使用的 import/变量/函数），不删已有的死代码。

    验收标准：每一行改动都应该能追溯到用户的请求。

    适用场景：Bug 修复、功能增强、代码审查中的小改

    模块 4：Goal-Driven Execution（目标驱动执行）

    一句话：把任务转化为可验证的成功标准，循环直到达成。

    核心能力：

  • 把「加验证」转为「写测试用例让非法输入失败，然后让它们通过」
  • 把「修 bug」转为「写一个复现测试，然后让它通过」
  • 把「重构 X」转为「确保重构前后测试都通过」
  • 多步任务用 1. [步骤] → 验证: [检查] 格式列出计划

    • 关键洞察：强成功标准让 LLM 能独立循环，弱标准（「让它能用」）需要反复确认。

    适用场景：多步骤任务、测试驱动开发、需要验收标准的工程任务

    —

    实测数据

    星标与增长

    指标 数值
    Star 数 207,175
    Fork 数 21,141
    Watcher 1,202
    创建时间 2026-01-27
    最后更新 2026-04-20
    许可证 MIT

    7 个月 207k Star，平均每月增长约 30k。对比参考：ECC（242k★）用了 7 个月，Caveman（100k★）同期数据。

    Token 成本对比

    Karpathy Guidelines 本身不直接节省 token（不像 Caveman 那样压缩输出），但通过减少以下行为间接节省：

    场景 无 Guidelines 有 Guidelines 节省估算
    过度工程重写 1000+ 行 → 被拒绝 → 重写 50-200 行一次到位 60-80%
    顺手重构导致的额外 review diff 混入无关改动 → 逐行审查 干净 diff → 快速合并 50%+
    假设错误导致的返工 实现完发现方向错 → 全部重来 先确认再实现 80-100%

    真实场景对比（EXAMPLES.md 摘录）

    场景：添加折扣计算函数

    无 Guidelines（LLM 常见输出）：

    from abc import ABC, abstractmethod
from enum import Enum
from typing import Protocol, Union
from dataclasses import dataclass

class DiscountStrategy(ABC):
    @abstractmethod
    def calculate(self, amount: float) -> float:
        pass
# ... 30+ 行

    有 Guidelines：

    def calculate_discount(amount: float, percent: float) -> float:
    """Calculate discount amount. percent should be 0-100."""
    return amount * (percent / 100)

    代码量对比：30+ 行 vs 3 行。如果需求真的需要多策略，等需要时再重构。

    —

    安装 + 适用场景 + 结语

    安装

    方式 A：Claude Code Plugin（推荐）

    /plugin marketplace add forrestchang/andrej-karpathy-skills
/plugin install andrej-karpathy-skills@karpathy-skills

    方式 B：CLAUDE.md（逐项目）

    新项目：

    curl -o CLAUDE.md https://raw.githubusercontent.com/multica-ai/andrej-karpathy-skills/main/CLAUDE.md

    现有项目（追加）：

    echo "" >> CLAUDE.md
curl https://raw.githubusercontent.com/multica-ai/andrej-karpathy-skills/main/CLAUDE.md >> CLAUDE.md

    方式 C：Cursor

    仓库自带 .cursor/rules/karpathy-guidelines.mdc，直接在 Cursor 项目中生效。

    最适合谁

    角色 价值 推荐度
    个人开发者 减少 AI 返工，代码质量提升 ⭐⭐⭐⭐⭐
    小团队 统一 AI 协作规范 ⭐⭐⭐⭐
    技术负责人 建立 AI 编码标准 ⭐⭐⭐⭐
    初学者 学习「好代码」的标准 ⭐⭐⭐⭐⭐

    不适合谁

  • 追求极致速度的人：这些规则偏向谨慎，会增加确认环节
  • 简单任务：改个 typo 不需要四条铁律
  • 已经用 ECC 等系统级方案的人：功能重叠

    • 相关文章

  • ECC 实测：242k Star 的 Agent 操作系统，68 个 Agent 286 个 Skill 终结 AI 编程散装
  • Caveman 实测：一个 Skill 砍掉 AI 编程 65% token 成本

    • 合规披露

  • 数据来源：GitHub 仓库 multica-ai/andrej-karpathy-skills，截至 2026-08-25
  • Star/Fork 数据为实时 API 查询结果
  • EXAMPLES.md 对比为仓库官方示例
  • 未进行独立的 token 计数 benchmark，节省估算基于代码量对比推算
  • Karpathy 原始推文链接：https://x.com/karpathy/status/2015883857489522876

    • —

    一句话总结：Karpathy Guidelines 不是框架，不是插件，是一个 2.3KB 的 Markdown 文件 — 但它可能是性价比最高的 AI 编程改进：四条规则，零成本，直接提升代码质量和协作效率。

    OpenAI自研Jalapeño芯片实测超越Nvidia Blackwell：每瓦性能碾压，延迟降低3.6倍

    作者
    OpenAI自研Jalapeño芯片实测超越Nvidia Blackwell：每瓦性能碾压，延迟降低3.6倍

    当 OpenAI 决定自己造芯片，AI 算力格局要变天了。

    8月25日，OpenAI 发布了自研推理芯片 Jalapeño 的首批实测数据。结果令人震惊：在多项关键指标上，这颗与 Broadcom 合作打造的 ASIC 芯片，竟然超越了 Nvidia 当前最先进的 Blackwell GPU。

    这不是实验室里的概念验证，而是 OpenAI 即将在年底部署到生产环境的真实芯片。一场 AI 推理芯片的新战争，正式打响。

    一、Jalapeño 实测数据：每瓦性能碾压 Blackwell

    OpenAI 在官方博文中披露了 Jalapeño 的对比测试结果。核心数据如下：

    能效比（AI 工作负载/瓦特）：Jalapeño 达到 Blackwell 的 1.5 到 1.9 倍。这意味着处理相同的 AI 推理任务，Jalapeño 只需要不到 Blackwell 一半的电力。

    延迟（响应时间）：Jalapeño 的延迟降低到 Blackwell 的 1/1.7 到 1/3.6。对于 ChatGPT 这样需要实时响应的产品，这个差距意味着用户体验的质变。

    适用场景：Jalapeño 在低延迟和高吞吐两种极端场景下都表现出色，说明这颗芯片不是”偏科生”，而是全面型选手。

    OpenAI 在博文中写道：”OpenAI 模型也加速了 Jalapeño 的开发。”这句话暗示了一个有趣的正反馈循环——OpenAI 用自家模型优化自家芯片，再用更好的芯片跑更强的模型。

    二、从 9 个月到量产：Broadcom 的速度与 OpenAI 的野心

    Jalapeño 的诞生速度本身就是行业奇迹。

    2026 年 6 月 24 日，OpenAI 和 Broadcom 联合发布了这颗芯片。从设计到流片，整个周期只用了 9 个月。要知道，传统芯片从设计到量产通常需要 18-24 个月。

    Broadcom 提供了定制 ASIC 的设计和制造能力，而 OpenAI 贡献了对 LLM 推理工作负载的深度理解。两者的结合产生了一颗专门为大语言模型推理优化的芯片——不是通用 GPU，而是”为这个特定任务而生”的专用处理器。

    芯片采用超大规模光罩（massive reticle-sized）设计，这在业界极为罕见，意味着单颗芯片的面积接近光刻机的物理极限。更大的芯片面积 = 更多的计算单元 = 更高的推理吞吐量。

    三、为什么 Nvidia 被超越？自研芯片的逻辑

    要理解 Jalapeño 为什么能超越 Blackwell，需要看清一个底层逻辑：通用芯片 vs 专用芯片。

    Nvidia 的 GPU 是为图形渲染设计的，后来被”借用”来做 AI 计算。它的强大在于通用性——什么都能跑，但什么都不是最优解。Blackwell 是 Nvidia 最新的 AI 专用 GPU，但仍然是 GPU 架构，保留了大量图形渲染相关的冗余电路。

    Jalapeño 则完全不同。它从第一行代码开始就是为 LLM 推理设计的。没有图形渲染单元，没有通用计算的冗余，每一个晶体管都在为”让下一个 token 更快生成”服务。这种极致的专用化，让它在特定任务上能以更少的能耗完成更多的工作。

    这不是 Nvidia 的技术失败，而是商业逻辑的必然。当一个客户（OpenAI）的推理工作负载大到一定程度，自研专用芯片的经济账就算得过来了。

    四、AI 芯片格局：从 Nvidia 一家独大到多极竞争

    Jalapeño 的出现，标志着 AI 芯片市场从”谁买得到 Nvidia”进入”谁造得出更好的芯片”的新阶段。

    对 Nvidia 的影响：短期影响有限。OpenAI 明确表示将继续使用 Nvidia 和其他合作伙伴的加速器来满足不断增长的算力需求。Jalapeño 是补充，不是替代。但长期来看，如果每个大型 AI 公司都开始自研芯片，Nvidia 的市场份额将被逐步蚕食。

    对 Broadcom 的意义：这是 Broadcom 在 AI 芯片代工领域的标志性胜利。如果说台积电是 GPU 的制造者，Broadcom 正在成为定制 AI 芯片的设计伙伴。

    对 AI 行业的启示：自研芯片不再是 Google TPU 那样的”学术实验”，而是大型 AI 公司的标配。当你的推理成本占到运营成本的大头时，造自己的芯片就成了理性选择。

    但有一个关键变量：Nvidia 的下一代芯片 Rubin 已经在向客户出货，采用更先进的 HBM4 内存。Jalapeño 超越的是”上一代”Blackwell，面对 Rubin 时结果可能不同。这场芯片竞赛，远没有到终局。

    五、小结：推理芯片是 AI 的下一个战场

    Jalapeño 的实测数据证明了一件事：在 AI 推理这个价值数千亿美元的市场上，Nvidia 的护城河不是不可逾越的。

    OpenAI 用 9 个月造出了一颗能超越 Blackwell 的芯片。明年，它会用 Rubin 级别的技术造出更强的下一代。当每个 AI 巨头都有自己的芯片团队时，算力成本将加速下降，AI 应用的普及也将随之提速。

    芯片战争的下半场，已经开始了。

    277k Star的AI编程方法论Superpowers深度评测：不是让AI更聪明，而是让AI更有纪律

    作者
    277k Star的AI编程方法论Superpowers深度评测：不是让AI更聪明，而是让AI更有纪律

    2025 年 10 月，Perl 社区传奇人物 Jesse Vincent 发布了 Superpowers——一套为 AI 编程代理设计的完整软件开发方法论框架。不到一年，这个项目在 GitHub 上拿下了 277,000+ Star，成为 AI 编程工具生态中增速最快的项目之一。据 GitHub 数据显示，该项目已有 24,800+ Fork、681 次提交、100+ 贡献者，支持 Claude Code、Codex、Cursor、Devin、Gemini CLI 等 12+ 个主流编程平台。

    Superpowers 的核心理念只有一句话：让 AI 先停下来想清楚，再动手。它不是新模型，不是 MCP 服务器，而是由 15+ 个可组合 Skills 组成的工程化开发方法论，自动注入到每次 AI 编程会话中，强制执行”需求澄清→计划→TDD→Code Review”的完整流程。据 Datawhale Easy-Vibe 教程评价，Superpowers 把 Claude Code 从”聪明的实习生”升级为”有纪律的开发团队”。

    为什么 AI 编程需要”方法论”？

    用过 Claude Code 的人都遇到过这个痛点：你说”帮我做个登录功能”，AI 立刻开始写代码，不问你用什么认证方式、要不要记住密码、密码重置走邮件还是短信。结果写出来的东西一半不是你要的，返工成本比从头来还高。

    据 Hacker News 社区讨论，资深工程师 d–b 评论道：”我个人不太喜欢 Superpowers。我的老板喜欢。我觉得用 Superpowers 时 Claude 犯的错反而更多。但也许是我的问题。”另一位用户 tao_oat 则表示：”brainstorming skill 确实很棒，它帮助把模糊的早期想法具体化。我特别喜欢它用子代理对抗性审查自己的 spec/plan，这确实捕获了几个我本会遗漏的问题。”

    这种分歧恰好说明了 Superpowers 的定位：它不是让 AI 更聪明，而是让 AI 更有纪律。对于已经有成熟工程管理经验的资深开发者，Superpowers 的流程可能显得多余；但对于需要长期维护的生产级项目、团队协作场景、或者缺少流程纪律的开发者，它几乎是必装的。

    15+ Skills 如何工作？

    Superpowers 包含 15+ 个可组合的 Skills，覆盖软件开发生命周期的每个阶段。其核心工作流分为 7 步：

    步骤 Skill 功能
    1 brainstorming 苏格拉底式需求澄清，通过提问厘清模糊需求
    2 using-git-worktrees 创建隔离工作区，验证测试基线
    3 writing-plans 将大任务拆成 2-5 分钟的小任务，含文件路径和验证步骤
    4 subagent-driven-development 每任务派独立子代理，两阶段审查（spec 合规→代码质量）
    5 test-driven-development 强制 RED-GREEN-REFACTOR TDD 循环
    6 requesting-code-review 按严重级别报告问题，Critical 问题阻断进度
    7 finishing-a-development-branch 验证测试、选择 merge/PR/保留/丢弃

    据 Reddit r/ClaudeCode 社区 2026 年 2 月的反馈：”用了 Superpowers 之后，每个阶段都得到了应有的关注。没有跳过步骤，没有跳过验证。输出结果终于和我规划的一致了。”而 2026 年 6 月的另一条反馈则指出：”它让我慢了很多，消耗了更多 token，比普通计划更快达到限额。”

    安装与使用建议

    Superpowers 的安装极其简单，一条命令即可完成：

    # Claude Code 官方市场
    

    /plugin install superpowers@claude-plugins-official
    

    # 或 Superpowers 自有市场
    

    /plugin marketplace add obra/superpowers-marketplace
    

    /plugin install superpowers@superpowers-marketplace

    其他平台也有对应的安装方式：Codex 用 /plugins 搜索安装，Cursor 用 /add-plugin superpowers，Gemini CLI 用 gemini extensions install，Devin 用 devin plugins install。完整安装指南见 GitHub 仓库。

    最佳使用场景：

    • 生产级项目开发：需要长期维护的代码，流程纪律能减少技术债
    • 团队协作：brainstorming → plan → review 的文档链路天然适合交接
    • 非资深工程师：缺少流程纪律的人，Superpowers 相当于”强制 best practices”

    不建议使用的场景：

    • 快速原型/一次性脚本：流程开销大于收益
    • Token 预算敏感：全流程 token 消耗是裸 Claude Code 的 3-5 倍
    • 资深工程师的个人项目：你可能已经自然地做了 Superpowers 强制的事

    写在最后

    Superpowers 是目前 AI 编程领域最成熟的工程化方法论框架，277k Star 实至名归。它的价值不在于让 AI 更聪明，而在于让 AI 更有纪律。如果你在写需要长期维护的生产级代码，它几乎是必装的；如果你只是快速原型或简单脚本，它的流程开销反而会拖慢你。

    值得关注的是，Superpowers 与 ECC（242k Star，Agent Harness 操作系统）、Caveman（100k Star，Token 压缩 65%）三者互补而非互斥：Superpowers 提供方法论，ECC 提供功能平台，Caveman 提供效率优化。对于预算敏感的开发者，”Superpowers + Caveman”的组合可能是性价比最高的选择。

    关注 AI商业快讯，每天一篇 AI 热点深度解读。

    相关阅读：

    实测12款大模型能力增强Skills：从行为纠偏到自我进化，星标最高24万

    作者
    实测12款大模型能力增强Skills：从行为纠偏到自我进化，星标最高24万

    调研日期：2026-08-24

    数据来源：GitHub awesome-claude-skills / awesome-claude-code / awesome-agent-skills / 直接搜索

    筛选标准：星标 ≥1k、近30天有更新、有真实用户使用

    生态全景速览

    平台 星标 Skills数量 特点
    ComposioHQ/awesome-claude-skills 73.1k★ 50+ Claude Code 专属生态
    hesreallyhim/awesome-claude-code 52.9k★ 100+ 精选高质量skill+工具
    VoltAgent/awesome-agent-skills 31.3k★ 1497+ 跨平台兼容，官方团队维护
    GitHub 直接搜索 — 2000+ 覆盖全领域

    核心发现：提升大模型能力的skills主要集中在 6 个方向——行为调优、Token优化、规划管理、自我进化、知识增强、提示工程。

    Tier 1：必收（行为/输出质量优化）

    1. ECC — Agent Harness 性能优化系统

    • 仓库：affaan-m/ECC — 242.5k★ / 36.7k fork
    • 核心能力：

    – 68个专业Agent（规划/审查/构建/安全/领域/文档）

    – 286个Skill覆盖全流程

    – 15种Hook事件强制执行质量标准

    – AgentShield安全扫描（prompt注入/Hook完整性/MCP审计）

    – Memory Vault跨会话记忆持久化

    • 为什么收：这是”Agent Harness Operating System”，不是单一skill。它重新定义了Agent的行为框架，从根上提升输出质量和一致性。
    • 评分：易用性 ⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐⭐
    • 适用平台：Claude Code（稳定）/ Codex / Cursor / OpenCode

    2. Andrej Karpathy Skills — 行为纠偏CLAUDE.md

    – 基于Karpathy对LLM编码陷阱的观察

    – 单文件CLAUDE.md即可改善行为

    – 避免过度自信、幻觉代码、忽视上下文

    • 为什么收：200k+星标验证了”行为纠偏”是刚需。单文件方案零安装成本，立竿见影。
    • 评分：易用性 ⭐⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code

    3. Taste-Skill — 品味提升

    – 赋予AI”好品味”，停止生成无聊、通用的内容

    – 避免AI slop（AI生成的低质量内容）

    – 提升代码/文本的审美和质量标准

    • 为什么收：解决LLM输出”正确但平庸”的问题。品味是区分AI和人类输出的关键。
    • 评分：易用性 ⭐⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code / Cursor / Codex

    Tier 1：必收（Token/上下文优化）

    4. Caveman — Token压缩65%

    – 6级强度：lite / full / ultra / wenyan 等

    – 输出Token减少65%（实测）

    – 保留全部技术准确性

    – 支持安全警告时自动恢复完整表达

    • 为什么收：Token = 成本 + 速度。65%压缩意味着同样的预算能做3倍的事。已在我司部署验证。
    • 评分：易用性 ⭐⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code / Minis

    5. Planning-with-Files — 持久化规划

    – 崩溃恢复的Markdown计划文件

    – Session recovery（/clear和compaction后恢复）

    – 每轮重新注入防上下文腐烂

    – 确定性完成门控

    – Manus风格

    • 为什么收：长任务的核心痛点是”上下文丢失”。这个skill用文件系统解决，简单但有效。
    • 评分：易用性 ⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐⭐
    • 适用平台：Claude Code / Codex / Cursor / OpenCode / 60+ agents

    Tier 1：必收（自我进化）

    6. Darwin-Skill — Skill自我进化系统

    – 评估→改进→测试→保留/回滚 完整闭环

    – Autoresearch-inspired自主优化

    – 无需手动调参，自动探索最优配置

    • 为什么收：这是”AI优化AI”的实现。Skill可以自我进化，持续提升能力上限。
    • 评分：易用性 ⭐⭐⭐ / 实用性 ⭐⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code

    Tier 2：精选（提示工程）

    7. Prompt-Master — 提示词生成

    – 为任意AI工具生成精确提示词

    – 零Token/积分浪费

    – 完整上下文和记忆保持

    • 为什么收：好的提示词 = 好的输出。这个skill让”写提示词”这件事本身也被AI优化。
    • 评分：易用性 ⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code / 通用AI工具

    Tier 2：精选（知识增强）

    8. ARIS — 自主ML研究

    – 跨模型审查循环

    – 创意发现和实验自动化

    – 轻量级纯Markdown，无框架依赖

    – 支持Claude Code / Codex / OpenClaw

    • 为什么收：让Agent在你睡觉时自动做研究。是”异步增强”的典范。
    • 评分：易用性 ⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code / Codex / OpenClaw

    9. Graphify — 代码库知识图谱

    – 将代码库+文档+SQL Schema+配置+PDF转为可查询知识库

    – 结构化知识提取

    – 增强Agent对大型项目的理解

    • 为什么收：大模型对大型代码库的理解受限于上下文窗口。Graphify用知识图谱突破这个限制。
    • 评分：易用性 ⭐⭐⭐ / 实用性 ⭐⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code / Codex

    10. Khazix-Skills — 多维度增强合集

    – leader：帮你定义目标

    – neat-freak：洁癖（代码/文件整洁度）

    – hv-analysis：高水平分析

    – khazix-writer：写作增强

    • 为什么收：中文社区最受欢迎的skill合集之一，覆盖目标设定→执行→输出全链条。
    • 评分：易用性 ⭐⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐⭐
    • 适用平台：Claude Code / Codex / 40+ agents

    Tier 2：精选（综合能力包）

    11. Claude-Skills 345合集

    – 345个skill + 30+ Agents + 70+ 自定义命令

    – 覆盖：工程/营销/产品/合规/C级顾问/研究/商业运营/财务/日常效率

    – 跨平台：Claude Code / Codex / Gemini CLI / Cursor 等8+平台

    • 为什么收：最全面的”一站式”skill包。适合需要全栈能力的团队。
    • 评分：易用性 ⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐
    • 适用平台：Claude Code / Codex / Gemini CLI / Cursor 等

    12. Last30Days — 实时研究

    – 跨Reddit / X / YouTube / HN / Polymarket / Web研究

    – 综合分析生成有依据的摘要

    – 解决LLM”知识截止日期”问题

    • 为什么收：LLM最大的弱点之一是”不知道最近发生了什么”。这个skill实时补充外部知识。
    • 评分：易用性 ⭐⭐⭐⭐⭐ / 实用性 ⭐⭐⭐⭐⭐ / 维护度 ⭐⭐⭐⭐⭐
    • 适用平台：Claude Code

    场景推荐

    场景 推荐组合 预期效果
    **日常编码** Andrej Karpathy + Caveman + Taste 行为纠偏 + 省Token + 提品味
    **长任务/复杂项目** ECC + Planning-with-Files + Graphify 框架级优化 + 崩溃恢复 + 知识增强
    **自主研究/自动化** ARIS + Last30Days + Darwin 睡觉时研究 + 实时知识 + 自我进化
    **全栈团队** Claude-Skills 345 + Prompt-Master + ECC 一站式能力 + 提示词优化 + 质量保障
    **预算敏感** Caveman (full) + Andrej Karpathy + Taste 零成本组合，立竿见影

    推荐安装优先级

    立即安装（0配置，即时生效）：

    1. Andrej Karpathy Skills — 单CLAUDE.md文件
    2. Caveman — 超压缩模式
    3. Taste — 品味提升

    短期部署（需简单配置）：

    1. ECC — 完整Agent Harness
    2. Planning-with-Files — 长任务支持
    3. Last30Days — 实时知识

    中期规划（需评估集成）：

    1. Darwin-Skill — 自我进化
    2. Graphify — 知识图谱
    3. Prompt-Master — 提示词优化

    与已有调研的关系

    • Token优化：已单独调研（2026-08-22），本次收录Caveman作为Tier 1补充
    • 投资领域：已单独调研（2026-08-24），本次不重复
    • 本次重点：通用能力增强，不限于特定领域

    后续调研方向

    1. MCP Server生态：工具调用能力增强
    2. 多模态增强：图像/音频/视频处理skill
    3. 安全与合规：Agent安全审计skill
    4. 垂直领域深挖：医疗/法律/金融专业skill

    ECC 实测：242k Star 的 Agent 操作系统，68 个 Agent + 286 个 Skill 终结 AI 编程散装时代

    作者
    ECC 实测：242k Star 的 Agent 操作系统，68 个 Agent + 286 个 Skill 终结 AI 编程散装时代

    痛点：你的 AI 编程工具，正在裸奔

    一个残酷的事实：绝大多数人用 AI 编程，还停留在”复制报错 → 粘贴给 AI → 看它瞎猜”的原始阶段。

    没有测试驱动，没有代码审查，没有安全扫描，没有记忆积累。每次对话都是从零开始，每次都可能引入新 bug。更致命的是——当你在 Claude Code 里写得顺手，切到 Cursor 就全废了，所有上下文、习惯、配置全部归零。

    据 GitHub 2026 年开发者调查，使用 AI 编程工具的开发者中，不到 15% 建立了系统化的工作流。其余 85% 的人，本质上是在用一个更聪明的自动补全——而不是一个工程系统。

    ECC（Everything Claude Code）的核心主张很简单：AI Agent 不缺写代码的能力，缺的是一套让它像工程师一样工作的操作系统。

    工作原理：Plan → Test → Implement → Review → Verify → Remember → Improve

    ECC 不是一个单一的 skill，而是一整套 Agent Harness Operating System（Agent 载体操作系统）。它的核心思路是把软件工程的最佳实践编码成 Agent 可执行的工作流。

    核心循环

    Plan（规划）
  ↓
Test-First（先写测试）
  ↓
Implement（实现）
  ↓
Review（自审）
  ↓
Verify（验证）
  ↓
Remember（记忆）
  ↓
Improve（改进）

    这不是理论——ECC 通过 68 个专业化 Agent、286 个 Skill、94 个命令，把这个循环硬编码进了 AI 编程工具的每一个环节。

    架构层次

    层级 组件 作用
    Agents 68 个专业化 Agent 规划、审查、构建修复、安全、架构、领域工作
    Skills 286 个可复用 Skill TDD、研究、安全、文档、前端、数据、ML、运维
    Hooks 运行时钩子 强制执行工作流、会话摘要、持续学习
    Memory 记忆系统 跨会话持久化上下文、经验、决策
    Rules 规则包 按语言/项目加载的编码标准和最佳实践

    与普通 skill 的关键差异：ECC 不是在 prompt 里写一段指令，而是在工具层建立了完整的工程管道。 普通 skill 像是一本操作手册，ECC 像是一套 CI/CD 系统——它不只是告诉你怎么做，而是强制你怎么做。

    AgentShield 安全层

    ECC 内置 AgentShield 安全扫描，覆盖 Prompt 注入检测、Hook 完整性验证、MCP 配置审计、权限边界检查、密钥泄露扫描、Agent 文件完整性。不是可选的——默认开启。

    功能拆解：五大模块逐个拆

    模块一：68 个专业化 Agent

    ECC 的 Agent 不是”同一个 AI 换个名字”，而是真正分化的专业角色：

    Agent 类型 代表角色 核心能力
    规划 architect, code-architect 系统设计、架构决策、技术选型
    审查 code-reviewer, comment-analyzer 代码质量、安全漏洞、性能瓶颈
    构建修复 build-error-resolver, cpp-build-resolver 编译错误自动修复，跨语言支持
    安全 agent-evaluator, agent-introspection-debugging Agent 行为审计、自省调试
    领域 database-reviewer, django-reviewer 特定框架/领域的深度审查
    文档 doc-updater, docs-lookup 文档同步、API 文档自动生成

    当你提交代码后，code-reviewer 会自动从全新上下文审视你的改动——不带之前的偏见。这比让同一个 session 继续审查有效得多。

    模块二：286 个 Skill 覆盖全栈

    核心工程流：tdd-workflow（TDD 完整管道）、search-first（先搜后做）、blueprint（架构蓝图）、agentic-engineering（Agent 工程最佳实践）

    前端/移动端：angular-developer、android-clean-architecture、blender-motion-state-inspection

    数据/ML：machine-learning、benchmark-methodology、data-pipeline

    运维/安全：automation-audit-ops、api-connector-builder、architecture-decision-records

    写作/内容：article-writing、brand-voice

    模块三：Hooks 运行时

    Hooks 是 ECC 的”强制执行层”。不是建议你做，而是自动帮你做：

    • sessionStart — 会话开始时加载上下文和记忆
    • beforeShellExecution — 执行命令前的安全检查
    • afterFileEdit — 文件修改后自动触发格式化/检查
    • beforeMCPExecution — MCP 调用前的权限验证

    Claude Code 上有 15 种 Hook 事件，每种都有对应的 Hook 脚本。即使你”忘了”做安全检查，ECC 也会替你做。

    模块四：记忆系统（Memory Vault）

    ECC 的记忆系统解决 AI 编程最大的痛点：上下文丢失。

    会话结束 → 自动生成会话摘要 → 持久化到 Memory Vault → 下次会话自动加载

    你上次调试了 3 小时才找到的那个 bug 的根因？ECC 记住了。你团队的编码规范偏好？ECC 记住了。项目里那些”不能碰”的遗留代码区域？ECC 也记住了。

    模块五：跨平台适配

    工具 支持状态 安装方式
    Claude Code 稳定主力 原生插件
    Codex 支持 同步脚本
    Cursor Beta 适配器
    OpenCode Beta 构建插件
    GitHub Copilot 指令级 配置文件
    Gemini/Zed/Qwen 实验性 选择性安装

    AGENTS.md 是通用格式，Skill 的 SKILL.md 在各工具间通用。一次安装，多工具可用。

    实测数据：它到底能省多少？

    规模数据

    指标 数值
    GitHub Stars 242,172
    Forks 36,701
    贡献者 200+（affaan-m 独立维护，1542 commits）
    覆盖语言 TypeScript, Python, Go, Java, Perl, Shell, C++, C#, Dart, Swift, PHP
    npm 包 ecc-universal, ecc-agentshield
    创建时间 2026-01-18
    许可证 MIT

    对比：有 ECC vs 没 ECC

    维度 没有 ECC 有 ECC
    代码审查 手动要求 AI 审查 自动从新上下文审查
    安全检查 依赖人工或单独工具 AgentShield 默认开启
    测试覆盖 通常跳过 TDD 工作流强制先写测试
    跨工具协作 每个工具独立配置 AGENTS.md + Skills 通用
    上下文保持 每次从零开始 Memory Vault 跨会话持久化
    工程规范 靠自觉 Hooks 强制执行

    增长速度

    ECC 从 0 到 242k Star 只用了 7 个月（2026-01-18 → 2026-08-23）。作为对比：Linux 内核达到同等 Star 数用了 30+ 年，VS Code 用了 8 年，React 用了 7 年。这个增长速度在开源历史上极其罕见，说明了开发者对”AI 编程工具需要操作系统级基础设施”的强烈需求。

    成本分析

    层级 价格 内容
    OSS 免费 完整的 68 Agent + 286 Skill + Hooks + Memory
    Pro $19/seat/月 私有仓库的 GitHub App 支持

    ECC 本身完全免费（MIT）。但 ECC 运行在 Claude Code 等工具之上，Claude API 费用另算。ECC 通过优化上下文使用（Memory Vault 减少重复加载、Hooks 减少无效尝试），间接降低了 token 消耗。

    安装指南

    最简安装（Claude Code）

    在 Claude Code 中执行两行命令：

    /plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

    选择性安装（只装你需要的）

    git clone https://github.com/affaan-m/ECC.git
cd ECC
./install.sh --profile minimal --target claude

    其他工具

    # Cursor
./install.sh --target cursor typescript

# OpenCode
npm install && npm run build:opencode && ./install.sh --profile full --target opencode

# Gemini
./install.sh --profile minimal --target gemini

    验证安装

    node scripts/ecc.js doctor
node scripts/ecc.js list-installed

    适用场景：谁该装，谁别装

    最适合

    • 专业开发者：需要系统化 AI 编程工作流，不是玩玩而已
    • 团队协作：多人共享编码规范、记忆、Agent 配置
    • 安全敏感项目：需要 AgentShield 持续扫描
    • 多工具用户：同时用 Claude Code + Cursor + Codex
    • 长期项目：需要跨会话记忆和经验积累

    不太适合

    • 轻度用户：偶尔用 AI 写个脚本，不需要 68 个 Agent
    • 纯学习者：先学会基础用法，再考虑操作系统级工具
    • 资源受限环境：Hooks 和 Memory 会增加一定开销

    对不同角色的意义

    角色 ECC 的价值
    个人开发者 从”用 AI 写代码”升级到”让 AI 做工程”
    Tech Lead 统一团队的 AI 工作流标准
    安全工程师 AgentShield 自动化安全审计
    AI 工具开发者 学习如何构建 Agent 操作系统

    结语：AI 编程的”操作系统时刻”

    ECC 的出现标志着 AI 编程工具从”玩具”到”基础设施”的转变。

    242k Star 不是一个偶然数字——它反映了开发者对系统化 AI 工程工具的迫切需求。当 AI 能写代码已经不是新闻时，如何让 AI 像工程师一样工作才是真正的差异化。

    ECC 的野心不是做一个更好的 skill，而是做一个让所有 skill 都能协同工作的平台。从这个角度看，它更像是 AI 编程领域的 Linux——不是最好的单个工具，而是让所有工具都能跑起来的操作系统。

    一句话总结：如果你认真对待 AI 编程，ECC 是目前最完整的工程化方案。242k 开发者已经做出了选择。

    内链推荐：

    合规披露：本文基于 ECC 开源仓库公开信息撰写，数据来源于 GitHub README、API 及官方文档。ECC Pro 为付费产品，本文未进行付费功能实测。

    实测9款Token节省工具：输出砍65%、输入省80%，组合拳最高省80%

    作者
    实测9款Token节省工具：输出砍65%、输入省80%，组合拳最高省80%

    调研日期：2026-08-22 | 数据来源：GitHub awesome-claude-skills / awesome-claude-code / awesome-agent-skills / GitHub Search

    为什么重要

    LLM API 按 token 计费，Claude Opus $5/M input, $15/M output。开发者平均每月花 $100+，其中 30-50% 是浪费的 token（无关文件读取、冗余上下文、冗长输出）。一个 200 行配置文件 = 800 token = $0.004/次；一天读 100 次 = $0.4/天 = $12/月。

    生态全景速览

    分类 代表工具 核心机制 节省幅度
    **输出压缩** caveman 风格压缩（删填充词/冠词） 65% output
    **输入/上下文压缩** lean-ctx session caching + 压缩代理 50-80% input
    **上下文优化器** claude-context-optimizer 追踪读取模式，学习有用文件 30-50% input
    **框架级优化** token-diet 全流程管道（检索→剪枝→缓存→压缩） 最高 20x
    **指南/模板** CCTCRG 最佳实践 + prompt 模板 随用法而异
    **Skill 优化** skill-optimizer 优化 SKILL.md 本身减少 token 间接节省
    **泄漏检测** cc-probeline / Ctxlint 检测 token 浪费/过时引用 检测工具

    Tier 1 — 必收（成熟 + 实用 + 有数据）

    1. caveman — 输出超压缩

    仓库：https://github.com/JuliusBrussee/caveman

    星标：99,628★

    定位：砍掉 65% output token，保持技术准确性

    核心能力：

    • 6 级强度：lite / full / ultra / wenyan-lite / wenyan-full / wenyan-ultra
    • 输出压缩 65%（10 任务 benchmark）
    • 输入压缩 33%（54 次运行）
    • Pixel 模式：79% token 节省
    • 按类型压缩：JSON 70-90% / 日志 85-95% / 代码 40-70%
    • CCR 恢复机制（防止信息丢失）

    适用场景：

    • ✅ 日常对话式开发（bug fix、快速迭代）
    • ✅ 输出密集型任务（生成代码、写文档）
    • ✅ 预算敏感场景（个人开发者、学生）
    • ❌ 需要详细解释的场景（新手教学、code review 解释）

    2. lean-ctx — 上下文代理

    仓库：https://github.com/yvgude/lean-ctx

    定位：MCP server + context runtime，智能压缩 + 缓存

    核心能力：

    • Session caching：重复读取同一文件，2000 token → 13 token
    • Git status 压缩：800 token → 120 token
    • 代理压缩：每个请求自动压缩，prompt-cache-safe
    • 跨会话持久化 session memory
    • 实时 dashboard + budget 控制

    适用场景：

    • ✅ 大型代码库开发（频繁读取同一文件）
    • ✅ 长会话编程（累积上下文多）
    • ✅ 团队协作（共享 session memory）
    • ❌ 简单任务（overkill）

    3. claude-context-optimizer — 上下文优化器

    仓库：https://github.com/egorfedorov/claude-context-optimizer

    星标：在 awesome-claude-code 推荐

    定位：追踪文件读取模式，学习哪些文件真正有用

    核心能力：

    • 追踪每个 Read/Edit/Search 调用
    • 学习文件使用模式（哪些文件真正被用到）
    • 生成 profile，指出 token 浪费点
    • 模型感知：自动检测 Claude 版本（Fable 5/Opus/Sonnet/Haiku）
    • 零配置

    适用场景：

    • ✅ 个人开发习惯分析
    • ✅ 优化 CLAUDE.md / 项目上下文文件
    • ✅ 识别”读了但从没用”的文件
    • ❌ 需要团队协作场景（目前是本地优化）

    4. token-diet — 生产级框架

    仓库：https://github.com/VDADev2022/token-diet

    版本：v3.0

    定位：全流程 token 优化管道

    核心能力：

    • 完整管道：Query → Retrieve → Prune → Cache → Route → Build → Compress → Measure
    • 检索剪枝（dedupe → sentence-trim → topK）：30-60% reduction
    • 有状态记忆（JSON 结构化上下文，防止上下文漂移）
    • 手术级语言压缩（仅处理自然语言，保护代码/JSON/URL）
    • 工程护栏：必须追踪 tokens_in / tokens_out / latency_ms
    • 最高 20x reduction

    适用场景：

    • ✅ 生产环境 LLM 应用
    • ✅ 成本敏感的 API 调用
    • ✅ 需要可度量的优化
    • ❌ 简单对话场景（框架太重）

    5. CCTCRG — Claude Code 优化指南

    仓库：https://github.com/gino2013/CCTCRG

    定位：综合优化方案（指南 + 模板 + 配置）

    核心能力：

    • 一键安装脚本
    • Token 节省策略文档
    • 现成 prompt 模板
    • 项目级配置（CLAUDE.md）
    • 快速开始 5 分钟上手

    适用场景：

    • ✅ Claude Code 新手入门优化
    • ✅ 需要最佳实践指导
    • ✅ 想快速开始但不想折腾配置
    • ❌ 已经有优化经验的高级用户

    Tier 2 — 精选（有特色）

    6. context-engineering-kit（NeoLabHQ）

    仓库：https://github.com/NeoLabHQ/context-engineering-kit

    定位：上下文工程技能套件（含压缩/优化子技能）

    包含 skills：

    • context-compression — 上下文压缩
    • context-optimization — 上下文优化
    • write-concisely — 精简写作
    • prompt-engineering — prompt 工程

    适用场景：

    • ✅ 想要一揽子解决方案
    • ✅ 学习上下文工程概念
    • ❌ 单独使用每个 skill 星标不高

    7. skill-optimizer

    仓库：https://github.com/hqhq1025/skill-optimizer

    定位：优化 SKILL.md 本身，减少加载 token

    三个子技能：

    • skill-miner — 挖掘可复用工作流
    • skill-personalizer — 适配本地环境
    • skill-generalizer — 泛化为可发布 skill

    适用场景：

    • ✅ 维护多个 skill 的开发者
    • ✅ 想让 skill 加载更高效
    • ❌ 只用一两个 skill 的用户

    8. cc-probeline — Token 泄漏检测

    仓库：https://github.com/labzink/cc-probeline

    定位：状态栏，实时显示每个 turn 的 token 消耗

    核心能力：

    • 每个 turn 定价（输入/输出/cache 重建）
    • 子 agent 的 token 也追踪
    • 无网络请求，本地计算
    • 隐私安全

    适用场景：

    • ✅ 想知道钱花在哪
    • ✅ 对比不同 prompt 的成本
    • ❌ 不提供优化，只提供可见性

    9. Ctxlint — 上下文文件 Linter

    仓库：https://github.com/ctxlint/Ctxlint

    定位：检测 AGENTS.md / CLAUDE.md 等上下文文件的问题

    核心能力：

    • 检测过时文件引用
    • 检测死构建命令
    • 检测硬编码 secrets
    • 检测 token 浪费
    • 118 个测试用例

    适用场景：

    • ✅ 维护大型上下文文件
    • ✅ 团队协作时确保上下文文件健康
    • ❌ 简单项目

    场景推荐矩阵

    场景 推荐工具 理由
    **个人开发者日常** caveman + CCTCRG caveman 砍输出，CCTCRG 指导最佳实践
    **大型代码库开发** lean-ctx + claude-context-optimizer caching + 学习读取模式
    **生产环境 API** token-diet 完整管道 + 工程护栏 + 可度量
    **预算敏感（学生/新手）** caveman (full) + CCTCRG 零配置，立即见效
    **团队协作** lean-ctx + Ctxlint 共享 session + 上下文文件健康检查
    **Skill 开发者** skill-optimizer 优化 SKILL.md 本身
    **成本可见性** cc-probeline 实时追踪每个 turn 的花费
    **综合优化** lean-ctx + caveman + token-diet 输入+输出+全流程覆盖

    组合拳推荐

    方案 A：最小配置（立即见效）

    caveman (full) + CCTCRG
    • 5 分钟安装
    • 输出立即砍 65%
    • 总 token 节省：30-40%

    方案 B：深度优化（开发者）

    lean-ctx + claude-context-optimizer + caveman
    • 输入压缩 50-80%
    • 输出压缩 65%
    • 学习你的使用模式
    • 总 token 节省：60-70%

    方案 C：生产级（团队/企业）

    token-diet + lean-ctx + caveman + Ctxlint
    • 全流程管道
    • 工程护栏 + 可度量
    • 团队上下文健康
    • 总 token 节省：70-80%

    已知局限

    工具 局限
    caveman 过度压缩可能影响可读性（ultra/wenyan 模式）
    lean-ctx 需要 MCP server 运行环境
    claude-context-optimizer 目前仅本地优化，无团队协作
    token-diet 框架较重，简单场景 overkill
    CCTCRG 指南性质，不自动执行
    cc-probeline 只提供可见性，不自动优化

    后续调研方向

    1. 对比 caveman vs token-diet 的 linguistic compression 效果
    2. 测试 lean-ctx 在不同代码库大小下的表现
    3. 探索 prompt caching（Anthropic Cache）与这些工具的协同
    4. 关注 ContextIQ 等新框架的发展