Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add siviter-xyz/dot-agent --skill cli-building -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/cli-building/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cli-building/

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

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set11

The whole set →
software-engineer software-engineer — a skill that gives the agent rules for code style, documentation and workflow: no filler comments, no git commits on its own, questions when something is unclear. CX Codex +1 637installs python Gives the agent one set of Python conventions: typing, dependency injection, module and test layout. Useful when edits land in an existing codebase. CX Codex +1 353installs create-agents-md create-agents-md generates repo-committed AGENTS.md files for inline rules. Useful for keeping code style, build commands, and safety boundaries close to the code. CX Codex +1 306installs typescript typescript is a Claude Code skill that sets standards for writing and changing TypeScript. It activates for TypeScript and TypeScript React files. CX Codex +1 239installs semantic-git The semantic-git skill groups related changes into atomic commits and formats messages as Conventional Commits. Use it when an agent is preparing Git changes for commit. CX Codex +1 201installs debugging debugging is a Claude Code skill that guides root cause analysis for errors and test failures. It helps localize bugs and prepare minimal, verified fixes. CX Codex +1 151installs media-processing media-processing is a Claude Code skill for batch media workflows: resizing images, converting audio, and compressing video with FFmpeg, ImageMagick, and Python scripts. CX Codex +1 151installs psi psi structures development around planning, specifications and test-first implementation. It runs only when the user asks for it or the project’s AGENTS.md mentions it. CX Codex +1 144installs

Project sponsors

Companies that keep this analytics open