在 Anthropic 内部构建并规模化部署数百个技能的过程中，我们学到的心得。
- 分类Claude Code
- 产品Claude Code
- 日期2026 年 6 月 3 日
- 阅读时间5分钟
- https://claude.com/blog/lessons-from-building-claude-code-how-we-use-skills
技能已成为 Claude Code 中使用最广泛的扩展点之一。它们灵活、易于创建，也易于分发。
但这种灵活性也让人难以判断什么做法最有效。哪些类型的技能值得制作？如何构建一个技能？什么时候该与他人分享？
在 Anthropic 内部，我们广泛使用 Claude Code 的技能，目前有数百个技能处于活跃使用状态。以下是我们关于如何利用技能加速开发所总结的经验教训。
什么是技能？
技能是包含指令、脚本和资源的文件夹，智能体可以发现并使用它们，从而更准确、更高效地完成任务。这篇博文假设读者已熟悉技能的基础知识；如果你是新手，请从 Skilljar 上的《智能体技能入门》课程开始学习。
我们常听到一个关于技能的误解，认为它们“只是 Markdown 文件”。实际上，它们是文件夹，可以包含脚本、资源、数据等，智能体可以发现、探索并操作这些内容。
在 Claude Code 中，技能还拥有多种配置选项，包括注册动态钩子。
我们发现，Claude Code 中一些最有效的技能，正是充分利用了这些配置选项和文件夹结构。
技能的类型
在整理了 Anthropic 内部所有技能后，我们注意到它们可以归为九大类别。最优秀的技能恰好属于其中一类；而那些试图包罗万象的技能则会横跨多个类别，反而让智能体感到困惑。这并非一份定论清单，但它是一个有用的框架，可以帮助你发现自身技能库中的缺口。
1. 库与 API 参考
这些技能用于说明如何正确使用某个库、CLI 或 SDK。它们既可以针对内部库，也可以针对 Claude Code 有时难以处理的常见库。这些技能通常包含一个参考代码片段文件夹，以及一份 Claude 在编写脚本时应避免的注意事项清单。
示例如下：
- billing-lib —— 你的内部计费库：边界情况、易踩坑点等。
- internal-platform-cli —— 你的内部 CLI 封装器的每个子命令，并附有使用场景示例。
- sandbox-proxy —— 配置你所在组织的出口网关用于开发工作：哪些主机可达、如何调试“连接被拒绝”错误、如何添加白名单条目。
2. 产品验证
这些技能用于描述如何测试或验证你的代码是否正常工作。它们通常与 playwright、tmux 或其他外部工具搭配使用，用于验证。
验证技能在内部对 Claude 的输出质量产生了最可衡量的影响。让一名工程师花一周时间专门打磨你的验证技能，可能是值得的。
可以考虑采用诸如让 Claude 录制其输出视频以便你精确查看它测试了什么，或者在每一步对状态强制执行程序化断言等技术。这些通常通过在技能中包含各种脚本来实现。
示例如下：
- signup-flow-driver —— 在无头浏览器中运行注册 → 邮箱验证 → 新手引导流程，并在每一步设置用于断言状态的钩子。
- checkout-verifier —— 使用 Stripe 测试卡驱动结账界面，验证发票最终是否处于正确状态。
- tmux-cli-driver —— 用于交互式 CLI 测试，当你要验证的对象需要 TTY 时使用。
3. 数据获取与分析
这些技能用于连接你的数据和监控栈。这些技能可能包含用于凭据获取数据的库、特定的仪表盘 ID 等，以及关于常见工作流程或数据获取方式的说明。
示例如下：
- funnel-query —— “我需要关联哪些事件才能看到注册 → 激活 → 付费的漏斗”，以及包含规范 user_id 的实际表。
- cohort-compare —— 比较两个用户群的留存率或转化率，标记具有统计显著性的差异，并提供指向分群定义的链接。
- grafana — 数据源 UID、集群名称、问题 → 仪表盘查找表
- datadog — 字段参考（@request_id 与 trace_id）、服务列表、指标前缀约定
4. 业务流程与团队自动化
这些技能可将重复性工作流自动化，整合为一条指令。这类技能通常指令本身较为简单，但可能对其他技能或 MCP 有更复杂的依赖关系。对于此类技能，将先前结果保存在日志文件中，有助于模型保持一致性，并能对工作流的过往执行情况进行复盘。
示例包括：
- standup-post — 汇总你的工单追踪系统、GitHub 活动以及过往 Slack 消息 → 生成格式化的站会报告，仅包含增量更新
- create-<ticket-system>-ticket — 强制执行模式（有效的枚举值、必填字段），并包含创建后的工作流（@提醒审核人、在 Slack 中发送链接）
- weekly-recap — 已合并的 PR + 已关闭的工单 + 部署记录 → 生成格式化的周报
5. 代码脚手架与模板
这些技能用于为代码库中的特定功能生成框架样板代码。你可以将这些技能与可组合的脚本结合使用。当你的脚手架需求包含纯代码无法完全覆盖的自然语言要求时，这些技能尤其有用。
示例包括：
- new-<framework>-workflow — 根据你的注解，搭建新的服务/工作流/处理器脚手架
- new-migration — 你的迁移文件模板，附带常见陷阱提示
- create-app — 创建新的内部应用，并预先配置好你的认证、日志记录和部署配置
6. 代码质量与审查
这些技能用于在你的组织内强制执行代码质量，并协助审查代码。其中可以包含确定性脚本或工具，以实现最大程度的稳健性。你可能希望将这些技能作为钩子的一部分，或在 GitHub Action 中自动运行。
- adversarial-review — 生成一个具备全新视角的子智能体进行评审，实施修复，并迭代直至发现的问题降级为细枝末节
- code-style — 强制执行代码风格，特别是 Claude 默认处理不佳的风格
- testing-practices — 关于如何编写测试以及测试内容的指令
7. CI/CD 与部署
这些技能用于帮助你获取、推送和部署代码库中的代码。这些技能可能会引用其他技能来收集数据。
示例包括：
- babysit-pr — 监控一个 PR → 重试不稳定的 CI → 解决合并冲突 → 启用自动合并
- deploy-<service> — 构建 → 冒烟测试 → 逐步流量放量并对比错误率 → 出现性能回退时自动回滚
- cherry-pick-prod — 隔离工作树 → 拣选提交 → 解决冲突 → 生成带模板的 PR
8. 运行手册
这些技能能够接收一个症状（例如 Slack 讨论串、告警或错误特征），进行多工具排查，并生成一份结构化的报告。
示例如下：
- <service>-debugging — 将症状映射到工具和查询模式，适用于你的最高流量服务
- oncall-runner — 获取告警 → 检查常见疑点 → 格式化一份调查结果
- log-correlator — 给定一个请求 ID，从所有可能处理过该请求的系统中拉取匹配的日志
9. 基础设施运维
这些技能用于执行日常维护和运维流程，其中一些涉及破坏性操作，需要借助护栏机制来保障安全。它们能帮助工程师在关键运维中遵循最佳实践。
示例如下：
- <resource>-orphans — 发现孤立的 Pod/卷 → 发布到 Slack → 静默期 → 用户确认 → 级联清理
- dependency-management — 你所在组织的依赖审批流程
- cost-investigation — “为什么我们的存储/出站流量费用飙升”，并附带具体的存储桶和查询模式
制作技能的小贴士
一旦你决定了要制作什么技能，该如何编写呢？以下是 Claude Code 团队在制作技能方面的一些最佳实践、技巧和窍门。
不要陈述显而易见的内容
Claude 已经知道如何编码，并且能够读取你的代码库。一个只是复述 Claude 默认行为的技能，只会增加上下文，而不会增加价值。如果你要发布一个以知识为主的技能，请专注于那些能让 Claude 跳出常规思维的信息。
前端设计技能就是一个很好的例子；它由 Anthropic 的一位工程师通过与客户反复迭代，以改进 Claude 的设计品味而构建，避免了像 Inter 字体和紫色渐变这类经典模式。
建立一个“易错点”部分
任何技能中信号最强的部分就是“易错点”章节。这些章节应基于 Claude 在使用你的技能时遇到的常见失败点来构建。理想情况下，你会随着时间的推移更新你的技能，以捕捉这些易错点。
例如：
“订阅表是仅追加的。你需要的行是版本号最高的那一行，而不是最近创建时间的那一行。” “这个字段在 API 网关中叫 @request_id，在计费服务中叫 trace_id。它们是同一个值。” “即便 Stripe webhook 实际上并未处理，Staging 环境也会返回 200。请检查 payment_events 以获取真实状态。”
善用文件系统与渐进式信息呈现
正如我们之前所说，一个技能是一个文件夹，而不仅仅是一个 Markdown 文件。你应该将整个文件系统视为一种上下文工程和渐进式信息呈现的形式。告诉 Claude 你的技能中包含哪些文件，它会在适当的时候读取它们。
渐进式信息呈现最简单的形式是，指向其他 Markdown 文件供 Claude 使用。例如，你可以将详细的函数签名和使用示例拆分到 references/api.md 中。
另一个例子：如果你的最终输出是一个 Markdown 文件，你可以在 assets/ 中包含一个模板文件，供 Claude 复制和使用。
你可以拥有参考资料、脚本、示例等文件夹，这些都能帮助 Claude 更有效地工作。
避免过度引导 Claude
Claude 通常会尽量遵循你的指令，并且由于技能的可复用性很强，你需要注意不要在指令中过于具体。给予 Claude 所需的信息，但也要让它有根据实际情况灵活调整的空间。
例如：
思考一下设置过程
某些技能可能需要根据用户的上下文进行设置。例如，如果你正在制作一个将你的站会信息发布到 Slack 的技能，你可能希望 Claude 询问要发布到哪个 Slack 频道。
实现这一点的好模式是，将设置信息存储在技能目录下的 `config.json` 文件中，就像上面的例子那样。如果配置未设置，智能体可以随后向用户询问信息。
如果你希望智能体呈现结构化的多项选择题，可以指示 Claude 使用 AskUserQuestion 工具。
为模型编写描述，而非为人类编写
当 Claude Code 启动一个会话时，它会构建一份包含所有可用技能及其描述的列表。Claude 扫描这份列表，以决定“是否有技能可以处理这个请求？”这意味着描述字段不是摘要，而是关于何时触发该技能的说明。
帮助 Claude 记忆
某些技能可以通过在自身内部存储数据来包含一种记忆形式。你可以将数据存储在简单的仅追加文本日志文件或 JSON 文件中，也可以存储在像 SQLite 数据库这样复杂的数据结构中。
例如，一个 standup-post 技能可能会维护一个 `standups.log` 文件，记录它写过的每一篇帖子。这意味着下次你运行它时，Claude 会读取自己的历史记录，并能判断出自昨天以来发生了什么变化。
你可以使用环境变量 `${CLAUDE_PLUGIN_DATA}` 来获取一个稳定的目录，用于存储数据。更多关于在技能中持久化数据的内容，请参见：https://code.claude.com/docs/en/plugins-reference#persistent-data-directory。
存储脚本并生成代码
你可以赋予 Claude 的最强大工具之一就是代码。为 Claude 提供脚本和库，可以让 Claude 将它的推理步骤用于组合，决定下一步做什么，而不是重新构建样板代码。
例如，在你的数据科学技能中，你可能有一个函数库，用于从事件源获取数据。为了让 Claude 进行复杂分析，你可以给它提供一组像这样的辅助函数：
随后，Claude 可以即时生成脚本，将这些功能组合起来，对诸如“周二发生了什么？”之类的提示词进行更高级的分析。
使用按需钩子
技能可以包含仅在技能被调用时才激活的钩子，且这些钩子仅在该会话期间有效。当你希望某些钩子不必始终运行，但偶尔又极其有用时，可以使用此功能。
例如：
- /careful — 通过 Bash 上的 PreToolUse 匹配器，阻止 `rm -rf`、`DROP TABLE`、force-push、`kubectl delete` 等操作。你只会在确认操作生产环境时才需要它——如果始终开启，会让人抓狂。
- /freeze — 阻止任何不在指定目录内的编辑/写入操作。在调试时非常有用："我想添加日志，但总是无意中'修复'了不相关的代码。"
分发技能
技能的最大优势之一，就是你可以与团队其他成员共享它们。
与他人共享技能有两种方式：
- 将你的技能检入到仓库中（放在 `./.claude/skills` 下）
- 制作一个插件，并建立一个 Claude Code 插件市场，让用户可以上传和安装插件（更多信息请阅读此处的文档）
对于在相对较少的仓库上协作的小团队来说，将技能检入仓库效果不错。但每个检入的技能都会给模型的上下文增加一点负担。随着规模扩大，一个内部插件市场可以让你分发技能，让团队自行决定安装哪些，同时还能包含一个设置流程。
管理技能市场
如何决定哪些技能可以进入市场？人们如何提交它们？
在 Anthropic，我们没有集中决策的团队；相反，我们尝试有机地发现最有用的技能。如果有人拥有希望他人尝试的技能，他们可以将其上传到 GitHub 中的一个沙箱文件夹，并在 Slack 或其他论坛中引导大家前往查看。
一旦某个技能获得了关注（由技能所有者自行判断），他们就可以提交一个 PR，将其移入市场。
组合技能
你可能希望拥有相互依赖的技能。例如，你可能有一个文件上传技能用于上传文件，以及一个 CSV 生成技能用于生成 CSV 并上传它。这种依赖管理目前尚未原生内置于市场或技能中，但你可以直接通过名称引用其他技能，如果它们已安装，模型就会调用它们。
衡量技能
为了了解技能的表现，我们使用一个 PreToolUse 钩子，它允许我们在公司内部记录技能的使用情况（示例代码在此）。这意味着我们可以找出哪些技能受欢迎，或者哪些技能的使用频率低于我们的预期。
技能的最佳实践仍在不断演变。我们大多数最好的技能最初只有几行代码和一个常见陷阱，然后随着 Claude 遇到新的边缘情况，人们不断向其中添加内容，技能也因此变得更好。
理解技能的最佳方式就是开始使用、进行实验，并看看什么对你有效。
- 查看我们的技能文档
- 查找可供定制的示例技能
本文由 Thariq Shihipar 撰写，他是 Anthropic 的技术人员，从事 Claude Code 相关工作。
用 Claude 改变您组织的运作方式
What we learned building and scaling hundreds of skills internally at Anthropic.
- Category
- ProductClaude Code
- DateJune 3, 2026
- Reading time5min
- https://claude.com/blog/lessons-from-building-claude-code-how-we-use-skills
Skills have become one of the most used extension points in Claude Code. They’re flexible, easy to make, and easy to distribute.
But this flexibility also makes it hard to know what works best. What type of skills are worth making? How do you structure a skill? When do you share them with others?
We've been using skills in Claude Code extensively at Anthropic with hundreds of them in active use. These are the lessons we've learned about using skills to accelerate our development.
What are skills?
Skills are folders of instructions, scripts, and resources that agents can discover and use to do things more accurately and efficiently. This blog post assumes familiarity with skills basics; if you’re new, start with our Introduction to agent skills course on Skilljar.
A common misconception we hear about skills is that they are “just markdown files.” They’re actually folders that can include scripts, assets, data, etc. that the agent can discover, explore and manipulate.
In Claude Code, skills also have a wide variety of configuration options including registering dynamic hooks.
We’ve found that some of the most effective skills in Claude Code use these configuration options and folder structure effectively.
Types of skills
After cataloging all of our internal skills at Anthropic, we noticed they cluster into nine categories. The best skills fit cleanly into one; the ones that try to do too much straddle several and confuse the agent. This isn't a definitive list, but it is a useful framework for identifying gaps in your own skills library.
1. Library and API reference
These are skills that explain how to correctly use a library, CLI, or SDKs. They could be both for internal libraries or common libraries that Claude Code sometimes struggles to handle. These skills often included a folder of reference code snippets and a list of gotchas for Claude to avoid when writing a script.
Examples include:
billing-lib— your internal billing library: edge cases, footguns, etc.internal-platform-cli— every subcommand of your internal CLI wrapper with examples on when to use them.sandbox-proxy— configuring your org's egress gateway for dev work: which hosts are reachable, how to debug "connection refused" errors, how to add an allowlist entry.
2. Product verification
These are skills that describe how to test or verify that your code is working. They are often paired with playwright, tmux, or other external tools for verification.
Verification skills have had the most measurable impact on Claude’s output quality internally. It can be worth having an engineer spend a week just making your verification skills excellent.
Consider techniques like having Claude record a video of its output so you can see exactly what it tested, or enforcing programmatic assertions on state at each step. These are often done by including a variety of scripts in the skill.
Examples include:
signup-flow-driver— runs through signup → email verify → onboarding in a headless browser, with hooks for asserting state at each stepcheckout-verifier— drives the checkout UI with Stripe test cards, verifies the invoice actually lands in the right statetmux-cli-driver— for interactive CLI testing where the thing you're verifying needs a TTY
3. Data fetching and analysis
These are skills that connect to your data and monitoring stacks. These skills might include libraries to fetch your data with credentials, specific dashboard ids, etc., as well as instructions on common workflows or ways to get data.
Examples include:
funnel-query— "which events do I join to see signup → activation → paid" plus the table that actually has the canonical user_idcohort-compare— compare two cohorts' retention or conversion, flag statistically significant deltas, link to the segment definitionsgrafana— datasource UIDs, cluster names, problem → dashboard lookup tabledatadog— field reference (@request_id vs trace_id), service list, metric prefix conventions
4. Business process and team automation
These are skills that automate repetitive workflows into one command. These skills are usually fairly simple instructions but might have more complicated dependencies on other skills or MCPs. For these skills, saving previous results in log files can help the model stay consistent and reflect on previous executions of the workflow.
Examples include:
standup-post— aggregates your ticket tracker, GitHub activity, and prior Slack → formatted standup, delta-onlycreate-<ticket-system>-ticket— enforces schema (valid enum values, required fields) plus post-creation workflow (ping reviewer, link in Slack)weekly-recap— merged PRs + closed tickets + deploys → formatted recap post
5. Code scaffolding and templates
These are skills that generate framework boilerplates for a specific function in a codebase. You might combine these skills with scripts that can be composed. They are especially useful when your scaffolding has natural language requirements that can’t be purely covered by code.
Examples include:
new-<framework>-workflow— scaffolds a new service/workflow/handler with your annotationsnew-migration— your migration file template plus common gotchascreate-app— new internal app with your auth, logging, and deploy config pre-wired
6. Code quality and review
These are skills that enforce code quality inside of your org and help review code. These can include deterministic scripts or tools for maximum robustness. You may want to run these skills automatically as part of hooks or inside of a GitHub Action.
adversarial-review— spawns a fresh-eyes subagent to critique, implements fixes, iterates until findings degrade to nitpickscode-style— enforces code style, especially styles that Claude does not do well by default.testing-practices— instructions on how to write tests and what to test.
7. CI/CD and deployment
These are skills that help you fetch, push, and deploy code inside of your codebase. These skills may reference other skills to collect data.
Examples include:
babysit-pr— monitors a PR → retries flaky CI → resolves merge conflicts → enables auto-mergedeploy-<service>— build → smoke test → gradual traffic rollout with error-rate comparison → auto-rollback on regressioncherry-pick-prod— isolated worktree → cherry-pick → conflict resolution → PR with template
8. Runbooks
These are skills that take a symptom (such as a Slack thread, alert, or error signature), walk through a multi-tool investigation, and produce a structured report.
Examples include:
<service>-debugging— maps symptoms → tools → query patterns for your highest-traffic servicesoncall-runner— fetches the alert → checks the usual suspects → formats a findinglog-correlator— given a request ID, pulls matching logs from every system that might have touched it
9. Infrastructure operations
These are skills that perform routine maintenance and operational procedures, some of which involve destructive actions that benefit from guardrails. These make it easier for engineers to follow best practices in critical operations.
Examples include:
<resource>-orphans— finds orphaned pods/volumes → posts to Slack → soak period → user confirms → cascading cleanupdependency-management— your org's dependency approval workflowcost-investigation— "why did our storage/egress bill spike" with the specific buckets and query patterns
Tips for making skills
Once you've decided on the skill to make, how do you write it? These are some of the Claude Code team’s best practices, tips, and tricks for making skills
Don’t state the obvious
Claude already knows how to code and can read your codebase. A skill that restates what Claude would do by default adds context without adding value. If you’re publishing a skill that is primarily about knowledge, focus on information that pushes Claude out of its normal way of thinking.
The frontend design skill is a great example; it was built by an engineer at Anthropic by iterating with customers on improving Claude’s design taste, avoiding classic patterns like the Inter font and purple gradients.
Build a gotchas section
The highest-signal content in any skill is the Gotchas section. These sections should be built up from common failure points that Claude runs into when using your skill. Ideally, you will update your skill over time to capture these gotchas.
For example:
"The subscriptions table is append-only. The row you want is the one with the highest version, not the most recent created_at." "This field is called @request_id in the API gateway and trace_id in the billing service. They're the same value." "Staging returns 200 even when the Stripe webhook didn't actually process. Check payment_events for the real state."
Use the file system and progressive disclosure
Like we said earlier, a skill is a folder, not just a markdown file. You should think of the entire file system as a form of context engineering and progressive disclosure. Tell Claude what files are in your skill, and it will read them at appropriate times.
The simplest form of progressive disclosure is to point to other markdown files for Claude to use. For example, you may split detailed function signatures and usage examples into references/api.md.
Another example: if your end output is a markdown file, you might include a template file for it in assets/ to copy and use.
You can have folders of references, scripts, examples, etc., which help Claude work more effectively.
Avoid railroading Claude
Claude will generally try to stick to your instructions, and because skills are so reusable you’ll want to be careful of being too specific in your instructions. Give Claude the information it needs, but give it the flexibility to adapt to the situation.
For example:
Think through the setup
Some skills may need to be set up with context from the user. For example, if you are making a skill that posts your standup to Slack, you may want Claude to ask which Slack channel to post it in.
A good pattern to do this is to store this setup information in a config.json file in the skill directory like the above example. If the config is not set up, the agent can then ask the user for information.
If you want the agent to present structured, multiple choice questions you can instruct Claude to use the AskUserQuestion tool.
Write descriptions for the model, not for humans
When Claude Code starts a session, it builds a listing of every available skill with its description. This listing is what Claude scans to decide "is there a skill for this request?" Which means the description field is not a summary, it's a description of when to trigger this skill.
Help Claude remember
Some skills can include a form of memory by storing data within them. You could store data in anything as simple as an append only text log file or JSON files, or as complicated as a SQLite database.
For example, a standup-post skill might keep a standups.log with every post it's written, which means the next time you run it, Claude reads its own history and can tell what's changed since yesterday.
You can use the env variable ${CLAUDE_PLUGIN_DATA} to get a stable directory where you can store data, read more persisting data in skills here: https://code.claude.com/docs/en/plugins-reference#persistent-data-directory.
Store scripts and generate code
One of the most powerful tools you can give Claude is code. Giving Claude scripts and libraries lets Claude spend its turns on composition, deciding what to do next rather than reconstructing boilerplate.
For example, in your data-science skill you might have a library of functions to fetch data from your event source. In order for Claude to do complex analysis, you could give it a set of helper functions like this:
Claude can then generate scripts on the fly to compose this functionality to do more advanced analysis for prompts like “What happened on Tuesday?”
Use on-demand hooks
Skills can include hooks that are only activated when the skill is called, and that only last for the duration of the session. Use this for more opinionated hooks that you don’t want to run all the time, but are extremely useful sometimes.
For example:
/careful/freeze— blocks any Edit/Write that's not in a specific directory. Useful during debugging: "I want to add logs but I keep accidentally 'fixing' unrelated code.”
Distributing skills
One of the biggest benefits of skills is that you can share them with the rest of your team.
There are two ways you might want to share skills with others:
- check your skills into your repo (under
./.claude/skills) - make a plugin and have a Claude Code Plugin marketplace where users can upload and install plugins (read more on the documentation here)
For smaller teams working across relatively few repos, checking your skills into repos works well. But every skill that is checked in also adds a little bit to the context of the model. As you scale, an internal plugin marketplace allows you to distribute skills and let your team decide which ones to install, as well as include a setup flow.
Managing a skills marketplace
How do you decide which skills go in a marketplace? How do people submit them?
At Anthropic, we don't have a centralized team that decides; instead we try to find the most useful skills organically. If someone has a skill that they want people to try out, they can upload it to a sandbox folder in GitHub and point people to it in Slack or other forums.
Once a skill has gotten traction (which is up to the skill owner to decide), they can put in a PR to move it into the marketplace.
Composing skills
You may want to have skills that depend on each other. For example, you may have a file upload skill that uploads a file, and a CSV generation skill that makes a CSV and uploads it. This sort of dependency management is not natively built into marketplaces or skills yet, but you can just reference other skills by name, and the model will invoke them if they are installed.
Measuring skills
To understand how a skill is doing, we use a PreToolUse hook that lets us log skill usage within the company (example code here). This means we can find skills that are popular or are undertriggering compared to our expectations.
Skills best practices are still evolving. Most of our best skills began as a few lines and a single gotcha, then got better because people kept adding to them as Claude hit new edge cases.
The best way to understand skills is to get started, experiment, and see what works for you.
This article was written by Thariq Shihipar, a member of technical staff at Anthropic, working on Claude Code.