In the realm of developer tools, every Command Line Interface (CLI) typically adheres to the same pattern: parse flags, execute logic, and print output. For instance, git commit -m "fix bug" has no inherent knowledge of whether your repository uses conventional commits. Similarly, npm audit cannot discern which specific vulnerabilities affect the code you’ve actually modified. The fundamental limitation is clear: the CLI doesn't understand your project's context; developers are required to carry all that information.
"Skills" revolutionize this paradigm. A skill is a single Markdown file designed to teach an AI agent how to perform a task within the context of your specific project. Unlike traditional tools, it requires no binaries, no build steps, and no runtime dependencies—just adaptable instructions that respond to the specific findings within your project.
Skills are not intended to replace CLIs; rather, they orchestrate them. I've developed numerous skills that invoke tools like Git, GitHub CLI (gh), npm, and custom scripts, subsequently reasoning about their outputs. This orchestration layer empowers AI agents with capabilities that no single CLI can achieve independently.
What is a Skill?
A skill is defined within a SKILL.md file, beginning with YAML frontmatter:
---
name: commit
description: ">
Create git commits following repository style.
Use when user asks to "commit changes", "/commit".
Don't use for pushing code or creating PRs.
---
The description field serves as the entire API for the skill. An AI agent reads this description to determine when to activate the skill. The "Use when" directives define the triggers, while "Don't use when" prevents erroneous activations. This forms the foundational contract between the skill and the agent.
The body of the Markdown file contains the specific instructions for the agent to follow. These instructions are not general knowledge the agent already possesses, but rather your project's particular conventions, common pitfalls, and preferred tools.
A crucial feature is the ! prefix, which automatically executes shell commands. This allows for critical context to be pre-loaded before the main instructions are processed by the agent.
Skills adhere to an open standard, ensuring compatibility across various AI tools like Claude Code and Cursor. This design eliminates the need for binary distribution; simply copying the Markdown file makes the skill operational.
Five Things CLIs Can't Do (Based on the provided content, two are highlighted)
1. Adapt to Your Project's Conventions
My commit skill, for example, pre-loads essential context the moment it's activated:
## Pre-loaded context
- Status: !`git status`
- Diff: !`git diff HEAD`
- Log: !`git log --oneline -10`
## Message Style
Match repo's existing commit patterns from log.
By the time the skill begins its operations, it has already gathered information about your recent commit history, the contents of your staging area, and your current code diff. It then processes the Git log to identify whether your project employs Conventional Commits, Semantic Commits, or a custom style, and subsequently adapts its commit message generation to match that established pattern.
To achieve this level of adaptability, a traditional CLI would typically require a complex configuration file, a parser, and a classifier. In stark contrast, a skill achieves this simply through intelligent reading and reasoning.
2. Orchestrate Multiple Tools and Correlate Results
My coverage skill goes beyond merely running tests; it intelligently correlates test coverage data with your actual code changes:
- Execute
git diff -U0 --no-colorto identify lines that have been changed. - Run the test suite to generate a coverage report.
- Parse the
lcov.infofile, extracting coverage data, e.g.:SF:src/utils/helper.tsDA:10,1# line 10, coveredDA:11,0# line 11, NOT covered
- Match the identified changed lines against the parsed coverage data.
- Report exclusively those lines that you have actually changed and that remain uncovered.