Anthropic engineer Thariq has published a detailed breakdown of how the company uses “Skills” while building Claude Code. In his account, Skills are not simple prompt files or static instructions. They function as tool directories that an AI agent can discover and invoke on its own. Anthropic now runs hundreds of active Skills internally, and Thariq described them as a central part of the company’s development workflow.
Skills are more than markdown instructions
One of the article’s first points is a correction of a common assumption. Developers often treat Skills as markdown documents filled with prompting guidance, but in Claude Code they are structured as full directories. A Skill can include documentation, executable scripts, assets, test data, and configuration files that register dynamic hooks. That setup gives the agent access to action-oriented tools instead of leaving it limited to passive reading.
The distinction matters. A Skill can hold process logic, operational safeguards, and reusable context in one place. Thariq also noted that Skills can read from and write to log files or JSON, which lets the agent keep track of prior actions and maintain continuity across tasks.
Nine categories Anthropic sees most often
Thariq grouped the most common internal uses into nine categories. These include library and API references that teach the model how to use internal tools correctly, and product validation workflows that pair Claude with tools such as Playwright to run registration or checkout flows in a headless browser and verify results.
The remaining categories span much of the software lifecycle: data retrieval and analysis, team process automation, code scaffolding, code quality review, CI/CD and deployment automation, troubleshooting runbooks, and infrastructure operations. In the troubleshooting case, a Skill can accept an error message, call tools such as log queries, and return a structured report. In infrastructure work, it can help find idle resources, examine the cause of rising cloud bills, and add confirmation gates before destructive actions such as deleting a database.
Four design lessons for better Skills
Thariq highlighted four practical methods for building effective Skills. The first is to include “Gotchas,” a section that records mistakes Claude has made before. He described this as one of the highest-value parts of a Skill because it improves execution success by documenting failure patterns directly.
The second is “progressive disclosure.” Instead of placing every example and API reference in a single file, the team splits supporting material into subfolders and lets Claude load them only when needed. The third is memory: Skills can store and retrieve logs or JSON so past actions remain available. The fourth is dynamic hooks triggered on demand. Thariq gave the example of a /careful mode that activates only when production systems may be touched, allowing the system to intercept commands such as rm -rf or DROP TABLE.
He added that the team’s strongest Skills usually did not begin as large systems. Many started with only a few lines of code and a single gotcha note, then expanded over time as edge cases appeared and were folded back into the tool.