Skill Mining: Extracting What Your Codebase Already Knows技能挖掘：提取代码库已有的知识
As the Head of Forward Deployed Engineering at Vercel, I drop into customer codebases for a living. Startups, enterprises, teams of two and teams of two hundred. The repository is always unfamiliar, the deadline is always real, and I am always the person who cloned it this morning.作为 Vercel 前沿部署工程部的负责人，我的工作就是深入客户的代码库。初创公司、企业、两人团队以及两百人团队。代码库总是陌生的，截止日期总是真实的，而我总是今天早上克隆它的人。
So is the agent.代理也是如此。
Port 5441, not 5432. .env.test, not .env.local. A filter flag you write from memory in three seconds, if you have been in this repo before. Neither of us has. That gap costs real time, and it compounds across every engagement.端口 5441，而不是 5432。 .env.test，而不是 .env.local。你在三秒内凭记忆写出的过滤标志，如果你之前在这个仓库里。我们俩都没有。这个差距会消耗真实时间，并且在每一次交付中累积。
Repos accumulate that kind of knowledge. The unwritten rule that money is always stored in cents, never floats. The folder a new feature is supposed to go in, enforced only when a reviewer catches you putting it somewhere else. The four-step dance to run a schema migration safely, which you get wrong exactly once and never forget again.仓库会积累这种知识。未成文的规则是金钱总是以分为单位存储，从不使用浮点数。新功能应该放入的文件夹，只有审阅者发现你放错位置时才会强制执行。安全运行模式迁移的四步舞蹈，如果你错一次，就再也忘不了。
None of that is in a file you can point to. It lives in commit history, in scattered validators, in review comments, in the heads of whoever has been here longest. It is the difference between someone who has worked in your repo for two years and someone who cloned it this morning.这些都不在你可以指向的文件里。它们存在于提交历史、分散的验证器、审阅评论以及在这里工作最久的人的脑中。它们是工作两年的人和今天早上克隆仓库的人的区别。
Every agent starts as the person who cloned it this morning. Brilliant and completely without context, every single time.每个代理都从今天早上克隆仓库的人开始。每一次都是才华横溢却毫无上下文。
Skill mining is how you fix that.技能挖掘就是解决这个问题的方法。
Mining, because the value is already in the ground挖掘，因为价值已经在地下
I picked the word deliberately. You are not inventing skills. You are extracting something that is already there.我特意挑选了这个词。你并不是在发明技能，而是在提取已经存在的东西。
A codebase is a sedimentary record of how a team builds software. Every commit is a decision. Every cluster of bug-fix commits around the same file is a sign that says this part is hard, and here is how we eventually got it right. Every convention the team follows is a pattern that an agent currently has to re-discover by reading three other files and guessing.代码库是团队构建软件的沉积记录。每一次提交都是一次决策。围绕同一文件的 bug‑fix 提交簇是该部分困难的信号，并且展示了我们最终是如何把它做好。团队遵循的每一条约定都是一种模式，代理目前必须通过阅读另外三个文件并猜测来重新发现。
That latent know-how has real value, and right now it is locked in a form only humans (and only some humans) can read fluently. Skill mining is the dig: you survey the terrain, find the rich seams, score them by leverage, and pull the valuable ones up into a form your agents can use directly.这些潜在的经验拥有真实价值，而现在它们被锁在只有人类（且只有部分人类）才能流畅阅读的形式中。技能挖掘就是这次挖掘：你勘测地形，找到富矿，按杠杆率打分，然后把有价值的矿石提取成代理可以直接使用的形式。
The form already exists. The open Agent Skills Specification standardized on a simple format: a folder with a SKILL.md file, a name, a trigger-rich description, and a body of instructions. Drop one into the right directory and any compliant harness loads it on demand when the description matches what you are doing. Claude Code, Codex, Antigravity, Cursor, Zed. The package manager (npx skills) and the registry at skills.sh handle distribution. The plumbing is solved. What has been missing is a disciplined way to figure out which skills are worth having for a given codebase.形式已经存在。开放的 Agent Skills Specification 采用一种简单格式：一个包含 SKILL.md 文件的文件夹，里面有名称、富含触发词的描述以及指令正文。把它放到正确的目录，任何符合规范的 harness 在描述匹配时都会按需加载。Claude Code、Codex、Antigravity、Cursor、Zed。包管理器 (npx skills) 和 skills.sh 注册表负责分发。管道已经就绪。缺失的只是一个系统化的方法来判断给定代码库哪些技能值得拥有。
That is the gap skill mining fills.这就是技能挖掘填补的空白。
The prompt that started it启动它的提示
This practice started, like a lot of good practices do, as a long prompt I kept reusing. Something like:这个实践像很多好实践一样，起初是一个我反复使用的长提示。类似于：
do a thorough review of this project’s codebase with the goal of building up a set of high-value agent skills, find existing ones to reuse where possible, create new skills only where something is bespoke or unique to this app, then define agents that leverage them to drive implementation, fixing, and improvements as a team.彻底审查该项目的代码库，目标是构建一套高价值的代理技能，尽可能复用已有技能，仅在应用独特或唯一的地方创建新技能，然后定义利用这些技能推动实现、修复和改进的代理。
It worked. But a one-off prompt is itself un-mined knowledge. So I turned it into a proper, repeatable skill with a defined loop, a scoring rubric, and templates. That skill is open source under MIT, installs cross-harness, and you can run it on your own repos today.它起作用了。但一次性的提示本身也是未被挖掘的知识。于是我把它做成了一个正式、可重复的技能，配上明确的循环、评分标准和模板。该技能在 MIT 许可证下开源，可跨 harness 安装，你今天就可以在自己的仓库上运行。
The rest of this post is what is inside it.本文其余部分就是它的内部内容。
The survey comes first, the scalpel comes later先做调研，后动手手术
Skill mining runs as seven phases. The first half is broad and parallel. You are surveying and judging. The second half is surgical and sequential. You are writing artifacts you will have to maintain, so restraint matters more than coverage.技能挖掘分为七个阶段。前半段宽泛且并行，你在调研和评估。后半段外科式且顺序，你在编写需要维护的产物，所以克制比覆盖更重要。
Survey, Detect, Score, Dedupe, Author, Compose, Verify. With two adversarial gates wired in between.调研、检测、打分、去重、编写、组合、验证。中间还有两个对抗性闸门。
Survey: map the territory before judging it调研：在评判之前绘制领土图
Before deciding anything, the agent builds a factual map. Languages, frameworks, package layout, the actual build/test/lint/deploy commands, and the hotspots. git log churn tells you which files change most often, and high churn means high leverage. A skill that speeds up work on the hottest files in the repo pays back faster than one for a corner nobody touches.在做任何决定之前，代理会构建一张事实地图。语言、框架、包结构、实际的构建/测试/检查/部署命令以及热点。git log churn 告诉你哪些文件最常改动，高 churn 意味着高杠杆。加速最热文件工作的技能回报比角落里没人碰的技能更快。
It also reads the pain markers: clusters of TODO/FIXME/HACK, files with the most bug-fix commits, recurring reverts, flaky-test annotations. Pain is signal. Pain that recurs is a skill waiting to be written.它还会读取痛点标记：TODO/FIXME/HACK 的聚集、bug‑fix 提交最多的文件、重复回滚、易失性测试注释。痛点是信号。重复出现的痛点就是等待被编写的技能。
If your harness can run subagents in parallel (Claude’s workflow engine, Codex’s parallel tasks), this is where you fan out: one explorer per subsystem, then converge. If it cannot, you iterate. The method is identical; only the wall-clock differs.如果你的 harness 能并行运行子代理（Claude 的工作流引擎、Codex 的并行任务），这里就可以分叉：每个子系统一个探索者，然后合流。如果不能，你就迭代。方法相同，唯一区别是实际耗时。
Detect: surface candidates everywhere they hide检测：在它们隐藏的所有地方显现候选项
Here is where most people get it wrong: they think skills means code patterns. The highest-leverage skills almost always live in the operational and tribal layers instead. The stuff nobody wrote down because everybody just knows it.大多数人犯的错误在这里：他们把技能等同于代码模式。最高杠杆的技能几乎总是存在于运营和部落层面。那些没人写下来的东西，因为大家都默认知道。
The mining loop sweeps a deliberate taxonomy: build/test/run incantations (the cheapest, highest-hit-rate skills in existence; every agent re-derives “how do I run this” on every task), domain rules and invariants (allowed state transitions, tenancy isolation, money handling, PII boundaries, enforced today only by scattered validators and reviewer memory), architectural conventions, review checklists (whatever your reviewers reliably catch is a skill), debugging playbooks, and migration and deploy recipes. Multi-step, error-prone, infrequent. Exactly the things people get wrong.挖掘循环遵循一个刻意的分类法：构建/测试/运行的咒语（现存最便宜、命中率最高的技能；每个代理在每个任务上都要重新推导“如何运行”），领域规则和不变量（允许的状态转换、租户隔离、金钱处理、PII 边界，如今仅由分散的验证器和审阅者记忆强制执行），架构约定，审阅清单（审阅者可靠捕获的就是技能），调试手册，以及迁移和部署配方。多步骤、易错、低频。正是人们常犯的错误。
For each candidate, the agent captures the evidence: the files, line ranges, and commit history that prove the pattern actually recurs. That evidence is what makes the authored skill specific instead of generic, which turns out to be the whole game.对于每个候选项，代理会捕获证据：文件、行范围以及证明模式实际复现的提交历史。证据让编写的技能具体而非通用，这正是全部游戏的关键。
Score: rank by leverage, not enthusiasm打分：按杠杆而非热情排序
It is very easy to get excited and mine forty skills. Forty skills is noise. The loop forces discipline with a five-axis rubric.很容易兴奋地挖出四十个技能。四十个技能是噪音。循环通过五轴评分标准强制纪律。
Frequency and leverage are a pair: high frequency with low leverage is noise, low frequency with high leverage is a trap. Bespokeness is the tiebreaker. A pattern that recurs constantly but already has a maintained community skill is a REUSE, not a BUILD. Stability matters because a skill that churns out of date in six weeks is worse than no skill. And verifiability is the gate on everything: if an agent cannot check whether it followed the skill, the skill can never get better.频率和杠杆是一对：高频低杠杆是噪音，低频高杠杆是陷阱。定制程度是平局决胜点。一个持续出现但已有维护社区技能的模式是 REUSE，而不是 BUILD。稳定性很重要，因为六周后就过时的技能比没有技能更糟。可验证性是所有的闸门：如果代理无法检查自己是否遵循了技能，技能永远无法改进。
The scores do not just rank the backlog. Their shape drives the next decision, which is the one that matters most.分数不仅仅是对待办事项的排序。它们的形状驱动下一步决策，而这一步最为关键。
Dedupe: reuse before you build去重：先复用再构建
This is the heart of skill mining, and the part that separates it from “the agent wrote me a pile of markdown.”这是技能挖掘的核心，也是它与“代理给我写了一堆 markdown”区别所在。
For every candidate that survives scoring, the agent checks the existing ecosystem before authoring anything. It does that with a skill built exactly for the job: find-skills. Point it at a candidate and it searches your installed skills, runs npx skills find <query>, and checks the skills.sh leaderboard for a maintained skill that already covers the need. The cheapest skill in the world is the one somebody else already maintains. There are battle-tested community skills for React, Next.js, testing, security review, ClickHouse, and dozens more, with hundreds of thousands of installs and active maintainers. Re-implementing those in your repo is not a flex. It is a liability you now own.对于每个通过评分的候选项，代理在编写任何东西之前会检查现有生态系统。它使用专门为此构建的技能：find‑skills。把它指向候选项，它会搜索已安装的技能，运行 `npx skills find <query>`，并检查 skills.sh 排行榜中是否已有维护的技能覆盖该需求。世界上最便宜的技能就是已经有人维护的。社区已经有经过实战检验的 React、Next.js、测试、安全审查、ClickHouse 等上百个技能，拥有数十万次安装和活跃维护者。把这些重新实现到你的仓库并不是炫技，而是你现在承担的负债。
Most candidates resolve to REUSE: a maintained public skill already covers this, install it and move on. A few are close but need a thin overlay. That is EXTEND. BUILD is the exception that has to earn its place: genuinely bespoke, high-leverage, nothing in the ecosystem that covers it. REJECT is not failure; it is the loop doing its job correctly. A good mining run might surface thirty candidates and build six. The other twenty-four are not failures. They are you not re-inventing things that do not need re-inventing.大多数候选项会归为 REUSE：已有维护的公共技能已经覆盖，直接安装即可。少数接近但需要薄层覆盖的属于 EXTEND。BUILD 是例外，需要凭自身价值赢得位置：真正定制的、高杠杆的、生态系统中没有覆盖的。REJECT 不是失败，而是循环正确执行的表现。一次好的挖掘可能会出现三十个候选项并构建六个。其余二十四个并非失败，而是你没有重新发明不需要重新发明的东西。
The failure mode nobody talks about没人谈论的失败模式
The moment skills become easy to create, you get a new problem that looks a lot like the old utils.js problem, or the company wiki nobody trusts.当技能变得容易创建时，你会遇到一个类似旧 utils.js 问题或公司维基没人信任的新问题。
Skill sprawl. Dozens of overlapping, half-maintained skills piling up faster than anyone can curate them. And its close cousin, skill redundancy: three different write-good-React skills, each slightly different, none authoritative, all drifting apart over time. Sprawl and redundancy do not just waste effort. They actively degrade your agents. When five skills could match a task, the agent loads the wrong one, or loads two that contradict each other, and the quality you were trying to add turns into noise.技能蔓延。成百上千的重叠、半维护的技能堆积得比任何人都快。以及它的近亲——技能冗余：三个写得稍有不同的 write‑good‑React 技能，没有权威，随着时间漂移。蔓延和冗余不仅浪费精力，还会主动削弱你的代理。当五个技能都能匹配同一任务时，代理可能加载错误的，或加载两个相互矛盾的，原本想提升的质量反而变成噪音。
A bloated skill library is worse than a small one. Same way a 4,000-line utils file is worse than a tight standard library.臃肿的技能库比小巧的更糟。就像 4000 行的 utils 文件比紧凑的标准库更糟一样。
find-skills is the guardrail against both. By forcing a does-this-already-exist check before anything gets authored, it makes reuse the default and authoring the exception. Every candidate it can route to an existing skill is one fewer thing you maintain, one fewer near-duplicate for an agent to trip over, one fewer source of drift. A skill you did not write (because a maintained one already existed) is the highest-leverage outcome of the entire process. If you want the full quality toolkit once skills are in place (audit, lint, token budgeting, security scanning) that is a separate post.find‑skills 是防止两者的护栏。通过在任何东西被编写前强制进行“是否已存在”检查，它让复用成为默认，编写成为例外。每个它能路由到已有技能的候选项，都意味着你少维护一件事，少一个代理可能绊倒的近似重复，少一个漂移来源。你没有编写的技能（因为已有维护的存在）是整个过程最高杠杆的结果。如果你想在技能就位后获得完整的质量工具箱（审计、lint、令牌预算、安全扫描），那是另一个帖子的话题。
Author: write skills that are specific, or not at all作者：只写具体的技能，或者根本不写
For the candidates you do build, the loop writes a SKILL.md with a few non-negotiable properties.对于你实际构建的候选项，循环会写一个 SKILL.md，里面包含几条不可协商的属性。
A trigger-rich description: this single field is how the skill gets discovered, and it has to contain the phrases a person would actually say. You write it last, once you know exactly what the skill does. One job per skill: if describing it needs the word “and,” split it. Real commands and real paths: “write good tests” is not a skill; “run pnpm test:int; integration tests live in tests/integration and need .env.test with port 5441" is a skill. The specificity is the value. And a verification step: if an agent cannot tell whether it followed the skill, the skill can never improve.富含触发词的描述：这是技能被发现的唯一字段，必须包含人们真实会说的短语。你在完全了解技能功能后最后写它。每个技能只做一件事：如果描述需要使用“和”，就拆分。真实的命令和真实的路径：“write good tests” 不是技能；“run pnpm test:int; integration tests live in tests/integration and need .env.test with port 5441” 才是。具体性就是价值。还有验证步骤：如果代理无法判断自己是否遵循了技能，技能永远无法改进。
Compose: mine the agents, not just the skills组合：挖掘代理，而不仅仅是技能
Skills are capabilities. Agents are the roles that wield them.技能是能力。代理是使用这些能力的角色。
A generic code reviewer agent is weak. It reviews like a smart stranger. A reviewer agent that loads your repo’s convention skill and your repo’s security skill reviews like a senior engineer who has been on the team for years. It is carrying the same institutional knowledge they are. Same for an implementer that loads your architecture skill, a fixer that loads your debugging playbooks, a migrator that loads your deploy recipes.一个通用的代码审阅代理很弱。它像一个聪明的陌生人一样审阅。加载了你仓库的约定技能和安全技能的审阅代理，则像一个在团队工作多年的资深工程师。实现者加载你的架构技能，修复者加载你的调试手册，迁移者加载你的部署配方，效果相同。
A typical mined roster is an implementer, a fixer, a reviewer, and a migrator. It is the same separation of roles that makes multi-model agent teams work. Each one a thin definition that names the specific skills it loads and the procedure it follows. The skills are the shared knowledge base; the agents are the specialists who have studied it.典型的挖掘名单包括实现者、修复者、审阅者和迁移者。这正是多模型代理团队能够协同工作的角色分离。每个角色都有一个薄定义，列出它加载的具体技能以及遵循的流程。技能是共享的知识库，代理是已经学习过这些知识的专才。
The loop then writes a team manifest: who hands off to whom, and in what order. Implementer ships a diff to Reviewer; Reviewer routes findings to Fixer; Fixer’s patch goes back to Reviewer; anything touching schema or deploy branches to the migrator. That manifest is what makes “drive improvements as a team” a runnable workflow instead of an aspiration.循环随后会写一个团队清单：谁把工作交给谁、顺序如何。实现者把 diff 交给审阅者；审阅者把发现交给修复者；修复者的补丁再回审阅者；任何涉及 schema 或部署分支的工作交给迁移者。该清单让“作为团队推动改进”从愿景变为可运行的工作流。
Verify: prove it, and hide nothing验证：证明它，并且不隐藏任何东西
A mined skill is a hypothesis until it is tested. A fresh-context agent gets only the authored skill and has to complete a real recent task with it. The verdict is SHIP, FIX, or REJECT, recorded with concrete evidence. A skill is verified only once a cold agent used it and it actually worked. Then lint the artifacts: valid frontmatter, unique names, descriptions that contain real trigger phrases.挖掘出的技能在被测试之前都是假设。一个全新上下文的代理只获得该技能并必须用它完成一次真实的近期任务。结果是 SHIP、FIX 或 REJECT，并附带具体证据。只有当一个冷代理使用该技能并且真的成功时，技能才算验证通过。随后对产物进行 lint：有效的 frontmatter、唯一的名称、包含真实触发短语的描述。
Then the loop writes SKILLS_MINED.md: every candidate considered, its scores, its decision, and why. Nothing is dropped silently. A rejected candidate with a clear reason is a real output. It stops the next person, or the next mining run, from re-mining the same dead end. A deferred list captures the mid-scoring candidates worth a second look next pass, so the practice compounds instead of restarting from zero.随后循环会写 SKILLS_MINED.md：每个被考虑的候选项、它的分数、决定以及原因。没有任何内容会被悄悄丢弃。带有明确理由的被拒候选是实际输出。它阻止下一个人或下次挖掘再次走进同一死胡同。一个延期列表捕获了在中期评分中值得二次审视的候选，以便下次运行时继续深化，而不是从零开始。
Built-in skepticism: the two gates内置的怀疑论：两个闸门
Running this on my own repos taught me the most important lesson the hard way: the loop is biased toward building things. Left alone, the agent talks itself into bespoke skills it thinks are clever, inflates its own leverage scores, and writes skills that read perfectly to the agent that wrote them and uselessly to everyone else. An author always fills its own gaps from memory. A cold reader cannot.在我的仓库上运行它让我以最痛苦的方式学到最重要的教训：循环倾向于构建东西。若不加干预，代理会说服自己去构建它认为聪明的定制技能，抬高自己的杠杆分数，并写出对自己完美、对他人毫无用处的技能。作者总是凭记忆填补自己的空白。冷读者做不到。
The fix is to put an adversary in the loop. An independent reviewer, fresh context, prompted to refute rather than to check.解决办法是把对手放进循环。一个独立的审阅者，拥有新上下文，被提示去反驳而不是检查。
Gate A challenges the decision. Before any candidate gets built, a skeptic re-scores it with the burden of proof reversed. Default verdict is reuse or reject; it has to be talked into a build. It attacks the recurrence evidence and the bespokeness claim. This is what keeps the loop honest about reuse. It is where most of the accuracy comes from.闸门 A 对决定提出挑战。在任何候选被构建之前，怀疑者会以逆向举证的方式重新打分。默认判决是复用或拒绝，必须说服它去构建。它会攻击复现证据和定制性声明。这是保持循环对复用诚实的关键，也是大部分准确性的来源。
Gate B red-teams the artifact. After a skill is written, a fresh agent gets only that file. Not the survey, not the reasoning that produced it. Has to complete a real task with it. A skill that says “handle money correctly” with no commands, no invariants, no specific paths is not a skill. The agent guesses. The guess is wrong. You do not find out until a float slips into a charge.闸门 B 对产物进行红队测试。技能写好后，一个全新代理只得到该文件——没有调研、没有产生它的推理。它必须用它完成一次真实任务。一个只说“正确处理金钱”却没有命令、没有不变量、没有具体路径的技能根本不是技能。代理只能猜测，猜错了。你直到一个浮点数滑入收费时才发现问题。
The non-negotiable property is independence. A skill grading its own homework rubber-stamps every time. The reviewer has to be a separate pass with no stake in the answer, told its job is to break things, not to bless them. That single discipline is the difference between a pile of plausible markdown and a portfolio you can trust.不可协商的属性是独立性。让技能给自己的作业打分等同于每次都盖章。审阅者必须是没有利益关联的独立通道，被告知工作是找破绽而不是祝福。这一单一纪律是把一堆看似合理的 markdown 变成可信组合的分水岭。
Three things check into the repo三件事会进入仓库
Run this on a real repo and three things check into the project. A handful of sharp, repo-specific skills your agents load automatically when the work matches. A small team of agent definitions that compose those skills into roles. And a report that documents what exists, what you reused, and what you chose not to build: institutional memory about your institutional memory.在真实仓库上运行，它会向项目中加入三件事：一组锋利、针对该仓库的技能，代理在工作匹配时自动加载；一小组代理定义，将这些技能组合成角色；以及一份报告，记录了已有的、复用的以及未构建的内容：关于你机构记忆的机构记忆。
The compounding effect is the real prize. Every skill is something your agents no longer re-derive. Every agent is a specialist you can summon. And because the skills are versioned files in the repo, they improve through normal pull requests. Someone hits a sharp edge, files a fix, and now every agent and every teammate inherits the lesson. The codebase starts teaching itself how to build itself.累积效应才是最终奖赏。每个技能都是你的代理不再重新推导的东西。每个代理都是你可以召唤的专才。因为技能是仓库中的版本化文件，它们可以通过普通的 Pull Request 改进。有人发现了尖锐的边缘，提交修复，现在每个代理和每个团队成员都继承了这次教训。代码库开始教会自己如何构建自己。
The same loop runs an organization’s AI portfolio同一循环可以运行在组织的 AI 组合上
Skill mining is the individual loop: one developer or team, one repo, run on demand. But look at the shape of it. Detect recurring know-how. Match it against what already exists. Find the gaps. Build only what is missing. Measure how much of the important work is now covered.技能挖掘是个人循环：一个开发者或团队，一个仓库，按需运行。但看看它的形态。检测重复的经验。与已有的匹配。找出空白。只构建缺失的。衡量重要工作现在被覆盖的程度。
That is not just a repo workflow. That is a governance loop. And the moment you have more than a handful of people using AI across an organization, the absence of that loop starts costing real money.这不仅是仓库工作流。这是治理循环。当组织中有超过少数人使用 AI 时，缺失的循环会导致真实的金钱损失。
Most enterprises rolling out AI cannot answer the questions that actually matter. What work are people trying to do with AI? Which of those patterns recur often enough to be worth standardizing? Which approved skills are being adopted and which are quietly ignored? Where are people reinventing the same capability, ad hoc, across teams that never compare notes?大多数企业在推广 AI 时无法回答真正重要的问题。人们想用 AI 做什么工作？哪些模式足够频繁值得标准化？哪些已批准的技能被采用，哪些被悄悄忽视？人们在哪些团队中以临时方式重复发明相同能力，却从未对齐？
I have watched teams spend weeks building a custom SQL generation skill, with three other teams in the same org having already built functionally identical skills and quietly abandoned them six months earlier. Nobody compared notes. Nobody knew.我看到团队花了数周时间构建自定义的 SQL 生成技能，而同一组织的另外三个团队早在六个月前就已经构建了功能相同的技能并悄然放弃。没有人对齐，没有人知道。
When nobody can answer those questions, three things happen at once. People do not adopt agents, because there is no trustworthy approved capability for the work they actually do. The org pays for the same capability to be re-invented badly, dozens of times. Finance sees a token bill climbing with no way to tie it to value, so the instinct becomes throttle the spend rather than curate the portfolio. Which kills adoption from the other direction.当没人能回答这些问题时，三件事会同时发生。人们不采用代理，因为没有可信的、已批准的能力匹配他们的实际工作。组织为同一能力的糟糕重复付费，次数多达数十次。财务看到令牌账单不断攀升，却找不到价值对应，于是本能是限制支出而不是梳理组合，这进一步抑制了采纳。
Cost dashboards describe the symptoms. They tell you that you spent a lot of tokens. They do not give you the operating loop to turn scattered AI usage into an intentional portfolio of capabilities. That loop is exactly skill mining, run continuously over an organization’s AI traffic instead of over a single repo.成本仪表板描述了症状：它们告诉你花了很多令牌，却不给出将分散的 AI 使用转化为有意的能力组合的运营循环。这个循环正是技能挖掘，只是持续运行在整个组织的 AI 流量上，而不是单一仓库。
The metric that makes it legible is the org-scale version of the SKILLS_MINED.md report: portfolio coverage, the percentage of your top recurring work patterns backed by an approved, trusted capability. That single number reframes the whole conversation. When it goes up, people actually adopt agents because the work they do has a capability built for it. When it goes down, you know exactly where the gap is and what to build next.让它可读的指标是组织层面的 SKILLS_MINED.md 报告：组合覆盖率，即你最常出现的工作模式中有多少比例得到已批准、可信的能力支持。这个单一数字重新定义了整个对话。当它上升时，人们会真正采用代理，因为他们的工作已有对应能力。当它下降时，你准确知道缺口在哪里以及下一步该构建什么。
The enterprise-scale version of this is what I am building toward next. Skill mining gives an individual team that loop on a repository; the same loop run across an organization is how enterprise AI stops being a cost center and becomes an operating model. One is the dig site; the other is running the whole mineral economy.企业级的实现正是我接下来要构建的。技能挖掘为单个团队提供了仓库循环；同一循环跨组织运行时，企业 AI 就不再是成本中心，而是运营模型。一个是挖掘现场，另一个是运行整个矿业经济。
The skill is open source under MIT and installs cross-harness. Two steps:该技能在 MIT 许可证下开源，可跨 harness 安装。两步走：
# Install the skill into your harness
npx skills add voodootikigod/skill-mining
# Then in your harness of choice, in the project you want to mine
> mine this repo for skillsIt will survey the codebase, score what it finds, tell you what to reuse versus build, write the skills and agents it recommends, and hand you a report of everything it considered. Read the report critically. The rejected and deferred candidates are often as informative as the built ones. Commit the skills you keep, and watch the next task go faster.它会调研代码库，给出评分，告诉你复用还是构建，写出推荐的技能和代理，并交付一份完整的报告。批判性阅读报告。被拒和被延期的候选往往和已构建的同样有价值。提交你保留的技能，观察下一个任务的加速。
Trust the reuse bias. Let find-skills win the argument. The instinct to build everything bespoke is the thing to fight; it is how you end up with skill sprawl. Re-mine after big changes: a major refactor or a new subsystem lays down a fresh seam of conventions, and capturing them while they are hot is the whole point. Treat skills like code: review them, version them, fix them in PRs. A skill that drifts out of date is worse than no skill at all.相信复用偏好。让 find‑skills 赢得争论。对抗一切定制化的冲动——那是导致技能蔓延的根源。大改动后重新挖掘：一次重大重构或新子系统会留下新一批约定，趁热捕获正是目的。把技能当作代码来对待：审阅、版本化、在 PR 中修复。一个过时的技能比没有技能更糟。
The knowledge of how your team builds is already in your codebase. It is just locked in a form only your most senior people can read fluently. Skill mining is how you get it out, and how you make sure the next change, by a human or an agent, starts two years ahead instead of from scratch.你的团队如何构建的知识已经在代码库里。它只是被锁在只有最高级成员才能流畅阅读的形式中。技能挖掘就是把它取出来，并确保下一个改动——无论是人还是代理——都能提前两年而不是从零开始。
The skill-mining skill is MIT-licensed and available via npx skills add voodootikigod/skill-mining. The Agent Skills Specification lives at agentskills.io. The enterprise-scale version of this loop is a story for soon.技能挖掘技能采用 MIT 许可证，可通过 `npx skills add voodootikigod/skill-mining` 获得。Agent Skills Specification 位于 agentskills.io。企业级循环的实现正在酝酿中。
