cli-building — Claude Code skill: what it does, how to install
cli-building guides AI agents to build command-line tools using async-first patterns, modular command composition, and terminal formatting with NO_COLOR support.
MIT 201 installs ★ 22 updated 2026-03-21
npx skills add siviter-xyz/dot-agent --skill cli-building -a claude-codeWhat cli-building does
This skill guides coding agents through building terminal tools with non-blocking I/O and composable architecture. All file, network, and process operations run through async/await structures, while complex execution branches rely on the strategy pattern instead of monolithic handler functions.
Framework guidance points to specific modern tools. For TypeScript or JavaScript projects, it prioritizes @bloomberg/stricli for its type inference and zero-dependency footprint, noting oclif for plugin-heavy setups. Python implementations focus on cyclopts or typer.
Terminal formatting follows strict constraints. The skill bans emojis unless explicitly requested, standardizing status indicators on unicode glyphs like ✓ and ✗ while requiring strict adherence to the NO_COLOR environment variable.
What it helps with
- structure a modular CLI application using stricli or cyclopts
- implement non-blocking async handlers for file and network operations
- format terminal output with unicode symbols while respecting NO_COLOR
- set up predictable command exit codes and async error handling
Example prompts for the agent
- Create a new TypeScript CLI for data processing using @bloomberg/stricli
- Build an async Python command-line utility with cyclopts
- Add status indicators and color handling that respects the NO_COLOR flag
How to install cli-building
1Skills CLI (Vercel)
npx skills add siviter-xyz/dot-agent --skill cli-building -a claude-code2Manually: put the files in place
~/.claude/skills/cli-building/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/cli-building/
1Skills CLI (Vercel)
npx skills add siviter-xyz/dot-agent --skill cli-building -a codex2Manually: put the files in place
.agents/skills/cli-building/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add siviter-xyz/dot-agent --skill cli-building -a cursor2Manually: put the files in place
.cursor/skills/cli-building/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install siviter-xyz/dot-agent skills/cli-building2Manually: put the files in place
.github/skills/cli-building/SKILL.md1Skills CLI (Vercel)
npx skills add siviter-xyz/dot-agent --skill cli-building -a gemini-cli2Platform CLI
gemini skills install https://github.com/siviter-xyz/dot-agent --path skills/cli-buildingManually: put the files in place
.devin/skills/cli-building/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add siviter-xyz/dot-agent --skill cli-building -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about cli-building
How to install cli-building in Claude Code?
Run npx skills add siviter-xyz/dot-agent --skill cli-building -a claude-code. Alternatively, copy the skill definition file directly into ~/.claude/skills/cli-building/SKILL.md.
What frameworks does this skill recommend?
For TypeScript, it highlights @bloomberg/stricli as the primary choice alongside oclif. For Python, it recommends cyclopts and typer.
Why does the skill ban terminal emojis?
Emojis are excluded to keep output clean and predictable across environments. The skill standardizes on unicode indicators like checkmarks and arrows instead.
Source text
SKILL.md · MIT
---
name: cli-building
description: Build command-line interfaces with async-first design, composable commands, and proper output formatting. Use when creating CLI tools, commands, or interactive terminal applications.
---
# CLI Building
Guidelines for building command-line interfaces with modern patterns and best practices.
## When to Use
- Creating new CLI tools or commands
- Building interactive terminal applications
- Adding commands to existing projects
- Implementing command-line interfaces
- Working with CLI frameworks
## Core Principles
- **Async-first**: All I/O operations should be async/await, avoid blocking operations
- **Composable commands**: Commands should be modular and reusable, use command composition
- **Strategy pattern**: Use strategy pattern for branching workflows or task-based commands
- **Output formatting**: Proper formatting with unicode symbols and color support
## Framework Selection
### TypeScript/JavaScript
**stricli** (`@bloomberg/stricli`, recommended for modern async-first CLIs):
- Built for async/await from ground up
- Type-safe command definitions with full type inference
- Lazy loading for startup performance
- Zero dependencies
**oclif** (alternative):
- Mature framework with extensive features
- Plugin system
- Good for complex CLIs
### Python
**cyclopts** (recommended for async-first):
- Modern async-first CLI framework
- Type-safe with excellent async support
- Clean API design
**typer** (when fully async support available):
- Based on Python type hints
- Clean and intuitive
- Good for simple to medium complexity CLIs
## Command Architecture
### Composable Commands
Design commands as reusable modules:
- Shared command utilities
- Command middleware
- Reusable command modules
- Command composition patterns
### Strategy Pattern
Use strategy pattern for:
- Workflow branching
- Task-based commands
- Dynamic command routing
- Conditional command execution
## Output Formatting
- **No emojis**: Do not use emojis unless explicitly directed
- **Unicode symbols**: Use unicode symbols (✓, ✗, →, ⚠) for status indicators
- **Color support**: Use color libraries, never hardcoded ANSI codes
- **NO_COLOR**: Always respect `NO_COLOR` environment variable
- **Formatting**: Use formatting for better readability (bold, dim, etc.)
## Async Patterns
### Async-First Design
All I/O should be async:
- File operations: use async file APIs
- Network requests: use async HTTP clients
- Process execution: use async process APIs
- Database operations: use async database clients
### Error Handling
Handle async errors properly:
- Use try/catch with await
- Handle promise rejections
- Provide clear error messages
- Exit with appropriate codes
## Command Structure
### Basic Command
```typescript
// stricli example
import { createCli } from '@bloomberg/stricli';
async function myCommand() {
// Async implementation
}
const cli = createCli({
name: 'my-cli',
commands: {
'my-command': myCommand
}
});
cli.run();
```
```python
# cyclopts example
from cyclopts import App
app = App()
@app.default
async def my_command():
# Async implementation
pass
if __name__ == '__main__':
app()
```
## Best Practices
1. **Async by default**: All operations should be async
2. **Composable design**: Build reusable command modules
3. **Strategy pattern**: Use for workflow branching
4. **Proper formatting**: Unicode symbols and color with NO_COLOR support
5. **Error handling**: Clear error messages and exit codes
6. **Type safety**: Use TypeScript types or Python type hints
7. **Testing**: Test commands in isolation
## References
For detailed guidance, see:
- `references/async-patterns.md` - Async/await best practices
- `references/composable-commands.md` - Command composition patterns
- `references/strategy-pattern.md` - Strategy pattern for workflows
- `references/output-formatting.md` - Output formatting guidelines
- `references/frameworks.md` - Framework comparisons and selection
© siviter-xyz · MIT · siviter-xyz/dot-agent