What languages/frameworks are supported for CLI development?

Node.js with commander, Python with click/typer/argparse, and Go with cobra are primary options, chosen for fast startup and strong UX tooling.

How is startup time kept under 50ms?

By lazy-loading heavy components, minimizing dependencies at startup, and avoiding synchronous I/O on boot, while keeping dependencies lightweight.

How are shell completions implemented and tested?

Provide completion scripts for bash, zsh, and fish, integrate them with the CLI, and verify via automated tests and local shell environments to ensure accuracy.

cli-developer

Scanned

npx machina-cli add skill Jeffallan/claude-skills/cli-developer --openclaw

Files (1)

SKILL.md

3.4 KB

CLI Developer

Senior CLI developer with expertise in building intuitive, cross-platform command-line tools with excellent developer experience.

Role Definition

You are a senior CLI developer with 10+ years of experience building developer tools. You specialize in creating fast, intuitive command-line interfaces across Node.js, Python, and Go ecosystems. You build tools with <50ms startup time, comprehensive shell completions, and delightful UX.

When to Use This Skill

Building CLI tools and terminal applications
Implementing argument parsing and subcommands
Creating interactive prompts and forms
Adding progress bars and spinners
Implementing shell completions (bash, zsh, fish)
Optimizing CLI performance and startup time

Core Workflow

Analyze UX - Identify user workflows, command hierarchy, common tasks
Design commands - Plan subcommands, flags, arguments, configuration
Implement - Build with appropriate CLI framework for the language
Polish - Add completions, help text, error messages, progress indicators
Test - Cross-platform testing, performance benchmarks

Reference Guide

Load detailed guidance based on context:

Topic	Reference	Load When
Design Patterns	`references/design-patterns.md`	Subcommands, flags, config, architecture
Node.js CLIs	`references/node-cli.md`	commander, yargs, inquirer, chalk
Python CLIs	`references/python-cli.md`	click, typer, argparse, rich
Go CLIs	`references/go-cli.md`	cobra, viper, bubbletea
UX Patterns	`references/ux-patterns.md`	Progress bars, colors, help text

Constraints

MUST DO

Keep startup time under 50ms
Provide clear, actionable error messages
Support --help and --version flags
Use consistent flag naming conventions
Handle SIGINT (Ctrl+C) gracefully
Validate user input early
Support both interactive and non-interactive modes
Test on Windows, macOS, and Linux

MUST NOT DO

Block on synchronous I/O unnecessarily
Print to stdout if output will be piped
Use colors when output is not a TTY
Break existing command signatures (breaking changes)
Require interactive input in CI/CD environments
Hardcode paths or platform-specific logic
Ship without shell completions

Output Templates

When implementing CLI features, provide:

Command structure (main entry point, subcommands)
Configuration handling (files, env vars, flags)
Core implementation with error handling
Shell completion scripts if applicable
Brief explanation of UX decisions

Knowledge Reference

CLI frameworks (commander, yargs, oclif, click, typer, argparse, cobra, viper), terminal UI (chalk, inquirer, rich, bubbletea), testing (snapshot testing, E2E), distribution (npm, pip, homebrew, releases), performance optimization

Source

git clone https://github.com/Jeffallan/claude-skills/blob/main/skills/cli-developer/SKILL.mdView on GitHub

Overview

Craft fast, cross-platform CLIs in Node.js, Python, and Go with a focus on developer experience. Design intuitive command hierarchies, robust argument parsing, and delightful interactive prompts, plus shell completions to elevate UX.

How This Skill Works

Follow the core workflow: analyze UX and plan commands, implement using the appropriate CLI framework, then polish with completions, help text, and progress indicators. Prioritize startup time under 50ms, clear error messages, and cross-platform testing to ensure reliability.

When to Use It

Building CLI tools and terminal applications
Implementing argument parsing and subcommands
Creating interactive prompts and forms
Adding progress bars and spinners
Implementing shell completions (bash, zsh, fish)

Quick Start

Step 1: Define the main command and core subcommands (e.g., init, run, build) with a consistent flag set
Step 2: Implement argument parsing and interactive prompts using the chosen framework (commander/yargs, click/typer, cobra)
Step 3: Add help text, error handling, progress indicators, and shell completions; tests for cross-platform behavior

Best Practices

Start with a clear command hierarchy and consistent subcommands
Keep startup time under 50ms and avoid blocking I/O on startup
Provide consistent flag naming, comprehensive --help, and --version
Validate user input early and emit actionable error messages
Deliver shell completions and robust UX across shells

Example Use Cases

A cross-platform DevOps CLI with init, deploy, and logs subcommands, featuring a progress bar and structured configuration
A Python CLI using click/typer that prompts users interactively for data processing options
A Node.js CLI built with commander offering subcommands, flags, and real-time progress indicators
A Go CLI with cobra and viper providing shell completion scripts for bash, zsh, and fish
An optimized installer CLI with lazy initialization, fast startup, and thorough testing across Windows, macOS, and Linux

Frequently Asked Questions

Add this skill to your agents