CLI Commands

SkillKit provides 50+ commands organized into functional categories. Built on Clipanion v4 with interactive prompts via @clack/prompts.

Global Options

Option	Short	Purpose
`--help`	`-h`	Display command help
`--version`	`-v`	Show version info
`--quiet`	`-q`	Minimal output, no logo

Install Command

Install skills from GitHub, GitLab, Bitbucket, or local paths.

skillkit install <source> [options]

Source Formats

Format	Example
GitHub	`owner/repo` or full URL
GitLab	`gitlab:owner/repo`
Bitbucket	`bitbucket:owner/repo`
Local Path	`./path` or `~/path`

Install Options

Option	Short	Type	Purpose
`--skills`	`-s`	string	Comma-separated skill names
`--all`	`-a`	boolean	Install all discovered skills
`--yes`	`-y`	boolean	Skip confirmation prompts
`--global`	`-g`	boolean	Install to global directory
`--force`	`-f`	boolean	Overwrite existing skills
`--provider`	`-p`	string	Force provider: GitHub, GitLab, Bitbucket
`--list`	`-l`	boolean	List available skills without installing
`--agent`	—	array	Target specific agents (repeatable)

Examples

# Interactive installation
skillkit install anthropics/skills

# CI/CD installation (no prompts)
skillkit install anthropics/skills --skills=pdf,xlsx --agent claude --yes

# List available skills
skillkit install anthropics/skills --list

# Force overwrite
skillkit install anthropics/skills --skills=pdf --force

# Install for multiple agents
skillkit install anthropics/skills --agent claude --agent cursor

Remove Command

skillkit remove <skill-names> [options]

Option	Short	Purpose
`--agent`	—	Target specific agents (default: all)
`--yes`	—	Skip confirmation
`--keep-metadata`	—	Remove skill but preserve metadata
`--source`	`-s`	Remove all skills installed from a specific source
`--all`	`-a`	Remove all installed skills
`--force`	`-f`	Skip confirmation prompt

Bulk Removal

skillkit remove --source iii-hq/iii
skillkit remove --all
skillkit remove --all --force

When using --source, SkillKit matches against the source field in each skill's metadata and removes every skill that was installed from that repository. When using --all, every discovered skill across all agent directories is removed. Both flags update AGENTS.md automatically if managed sections are present.

Update Command

skillkit update [skill-names] [options]

Option	Short	Purpose
`--dry-run`	—	Check for updates without installing
`--yes`	—	Skip confirmation prompts
`--agent`	—	Update in specific agents only
`--force`	`-f`	Force update, bypass checksum and GitHub API checks

The update command uses a two-stage change detection pipeline:

GitHub API check -- For remote sources, SkillKit queries the GitHub API to compare the repository's pushed_at timestamp against the installed metadata. If the repository has not been pushed since the last install or update, the skill is skipped without cloning.
Checksum comparison -- After cloning, a checksum of the source SKILL.md is compared against the stored checksum. If the content is identical, the update is skipped.

Use --force to bypass both checks and always overwrite the installed skill.

Enable/Disable Commands

skillkit enable <skill-names> [options]
skillkit disable <skill-names> [options]

Disabled skills are ignored by the sync command. No file changes occur.

Check Command

skillkit check [skill-names] [options]

Checks installed skills for available updates, quality scores, and GitHub activity.

Option	Short	Purpose
`--verbose`	`-v`	Show detailed output including stars and push dates
`--quiet`	`-q`	Minimal output

For remote GitHub sources, the check command queries the GitHub API to compare each repository's pushed_at timestamp against the installed date. Each skill displays its quality score badge (A-F). In verbose mode, the output also includes the repository's star count and how recently it was pushed.

skillkit check
skillkit check pdf xlsx --verbose

List Command

skillkit list [options]

Lists installed skills with quality grades.

Sync Command

skillkit sync [options]

Synchronizes enabled skills to agent configuration files.

skillkit recommend [options]

AI-powered recommendations based on project analysis.

Option	Purpose
`--search`	Task-based search
`--category`	Filter by category
`--min-score`	Quality threshold

Generate Command

AI-powered skill generation with multi-source context and agent optimization.

skillkit generate [options]

Generate Options

Option	Type	Purpose
`--provider`	string	LLM provider: anthropic, openai, google, ollama, openrouter
`--model`	string	Specific model (e.g., gpt-4o, gemini-2.0-flash)
`--compose`	string	Natural language search to find skills to compose
`--agents`	array	Target agents for optimization
`--no-memory`	boolean	Skip memory context
`--context-sources`	string	Comma-separated: docs,codebase,skills,memory

Context Sources

The wizard gathers context from 4 sources:

Source	Description
Documentation	Library docs via Context7 MCP
Codebase	Local project patterns and conventions
Skills	15,000+ marketplace skills for composition
Memory	Your corrections and learned patterns

Examples

# Interactive wizard (recommended)
skillkit generate

# Use specific provider
skillkit generate --provider openai --model gpt-4o

# Compose from existing skills
skillkit generate --compose "testing patterns for react"

# Generate for specific agents
skillkit generate --agents claude-code,cursor

# Skip memory personalization
skillkit generate --no-memory

Trust Score

Generated skills receive a trust score (0-10):

Grade	Score	Meaning
Trusted	8-10	High clarity, well-bounded
Review	5-7	May need refinement
Caution	0-4	Requires careful review

Agent Compatibility

The wizard shows compatibility scores for each target agent based on:

Context length limits
MCP/tool support
Format requirements

Marketplace Command

skillkit marketplace [options]
skillkit marketplace search <query>

Browse 15,000+ indexed skills from the aggregated catalog.

Option	Purpose
`--tags`	Filter by tags
`--refresh`	Force refresh index

Manifest Commands

Team collaboration via Git-committable .skills file.

skillkit manifest init          # Create .skills file
skillkit manifest add <source>  # Add skill source
skillkit manifest install       # Install from manifest

Manifest File Format

# GitHub skills
anthropics/skills
vercel-labs/agent-skills

# Local skills
./local-skills

# Specific versions
owner/repo@v1.2.3

Memory Commands

skillkit memory status          # View memory status
skillkit memory search <query>  # Search learnings
skillkit memory compress        # Compress observations to learnings
skillkit memory export <name>   # Export learnings as skill
skillkit memory sync-claude     # Update CLAUDE.md with learnings
skillkit memory index           # View memory index (Layer 1)
skillkit memory --global        # Use global memory

Option	Purpose
`--global`	Use global memory instead of project
`--limit`	Limit number of results
`--tags`	Filter by tags

Translation Commands

skillkit translate <skill> --to <agent>
skillkit translate --all --to <agent>
skillkit translate <skill> --to <agent> --dry-run

Agent Commands

skillkit agent list                              # List agents
skillkit agent show <name>                       # Show details
skillkit agent create <name>                     # Create agent
skillkit agent translate --source ./path --to cursor
skillkit agent translate --source ./path --to cursor --recursive
skillkit agent sync                              # Sync to target
skillkit agent validate                          # Validate definitions

Context Commands

skillkit context init    # Initialize project context
skillkit context sync    # Sync context to agents

Test Command

skillkit test [path]           # Run skill tests
skillkit test --tags unit      # Filter by tags
skillkit test --json           # JSON output for CI

Workflow Commands

skillkit workflow list         # List workflows
skillkit workflow run <name>   # Execute workflow
skillkit workflow create <name> # Create workflow

CI/CD Commands

skillkit cicd github-action    # Generate GitHub Actions
skillkit cicd gitlab-ci        # Generate GitLab CI
skillkit cicd pre-commit       # Generate pre-commit hooks

Serve Command

Start the SkillKit REST API server for runtime skill discovery.

skillkit serve [options]

Option	Short	Default	Description
`--port`	`-p`	`3737`	Port to listen on
`--host`	`-H`	`0.0.0.0`	Host to bind to
`--cors`	—	`*`	CORS allowed origin
`--cache-ttl`	—	`86400000`	Cache TTL in milliseconds

Examples

# Start with defaults
skillkit serve

# Custom port and host
skillkit serve --port 8080 --host localhost

# Restricted CORS
skillkit serve --cors "http://localhost:3000"

# Short cache TTL (1 hour)
skillkit serve --cache-ttl 3600000

Endpoints

Method	Path	Description
GET	`/search?q=...`	Search skills
POST	`/search`	Search with filters
GET	`/skills/:owner/:repo/:id`	Get specific skill
GET	`/trending?limit=20`	Trending skills
GET	`/categories`	Skill categories
GET	`/health`	Server health
GET	`/cache/stats`	Cache statistics

Issue Planner

Generate structured plans from GitHub Issues. Requires the gh CLI.

skillkit issue plan "#42"                        # Plan from current repo
skillkit issue plan rohitg00/skillkit#42          # Cross-repo
skillkit issue plan "#42" --agent cursor          # Target specific agent
skillkit issue plan "#42" --no-tests              # Skip test steps
skillkit issue plan "#42" --json                  # JSON output
skillkit issue plan "#42" --tech-stack react,ts   # Override tech stack

Issue Plan Options

Option	Short	Default	Purpose
`--agent`	`-a`	`claude-code`	Target agent
`--output`	`-o`	`.skillkit/plans/issue-<n>.md`	Output file path
`--no-tests`	—	`false`	Skip test steps
`--json`	—	`false`	Output as JSON
`--tech-stack`	—	—	Comma-separated tech stack

Issue List

skillkit issue list                               # List open issues
skillkit issue list --repo owner/repo             # Specific repo
skillkit issue list --label bug                   # Filter by label
skillkit issue list --limit 20                    # More results
skillkit issue list --json                        # JSON output

The planner extracts task lists (checkboxes) from the issue body, infers file mentions from backtick-quoted paths, and maps labels to tags (e.g., bug → fix, enhancement → feature). Generated plans work with skillkit plan validate and skillkit plan execute.

Session Intelligence

Track skill executions, generate handoff documents, and analyze skill impact.

Timeline

View a unified chronological event stream of all session activity.

skillkit timeline                          # Last 50 events
skillkit timeline --type git_commit        # Filter by event type
skillkit timeline --skill code-simplifier  # Filter by skill
skillkit timeline --since 2026-02-10       # Date filter
skillkit timeline --limit 20 --json        # JSON output

Option	Short	Purpose
`--type`	`-t`	Filter: skill_start, skill_complete, task_progress, git_commit, observation, decision, snapshot
`--skill`	`-s`	Filter events by skill name
`--since`	—	Show events since date (YYYY-MM-DD)
`--limit`	`-l`	Max events (default: 50)
`--json`	`-j`	JSON output

Session Handoff

Generate a structured context document for agent switching.

skillkit session handoff                    # Print markdown to stdout
skillkit session handoff --to cursor        # Target agent recommendations
skillkit session handoff --out handoff.md   # Save to file
skillkit session handoff --json             # JSON output

Option	Short	Purpose
`--to`	—	Target agent for recommendations
`--out`	`-o`	Save to file path
`--json`	`-j`	JSON output

Lineage

Show which skills produced which code changes with aggregate impact stats.

skillkit lineage                           # Full overview
skillkit lineage --skill code-simplifier   # Single skill
skillkit lineage --file src/index.ts       # Single file
skillkit lineage --since 2026-02-01 --json # Date filter + JSON

Option	Short	Purpose
`--skill`	`-s`	Filter by skill name
`--file`	`-f`	Filter by file path
`--since`	—	Show lineage since date
`--limit`	`-l`	Max entries
`--json`	`-j`	JSON output

Utility Commands

skillkit init                  # Initialize project
skillkit create <name>         # Create new skill
skillkit validate [path]       # Validate skill format
skillkit read <skills>         # Read skill content
skillkit settings --set key=value  # Configure settings

Publishing Commands

skillkit publish [path]        # Generate well-known hosting structure
skillkit publish --output dir  # Output to specific directory
skillkit publish --dry-run     # Preview without writing
skillkit publish submit        # Submit to SkillKit marketplace

publish submit

Submits a skill to the SkillKit marketplace by creating a GitHub issue on rohitg00/skillkit via the gh CLI. No browser is needed.

Before submitting, the command displays:

Quality score and grade (A-F) from the skill evaluator
GitHub star count and last push date from the GitHub API
Any quality warnings (up to 3)

If gh is not installed or not authenticated, the command prints a manual submission URL as a fallback.

Tap Command

Manage custom skill sources (taps). Taps are user-level source repositories stored in ~/.skillkit/taps.json. They let you add private or third-party skill repositories that are not part of the official marketplace.

tap add

Add a custom skill source.

skillkit tap add owner/repo
skillkit tap add owner/repo --name "My Skills"

tap remove

Remove a custom skill source.

skillkit tap remove owner/repo

tap list

List all custom skill sources.

skillkit tap list

Once a tap is added, skills from that source appear in skillkit marketplace search results and can be installed with the standard skillkit install owner/repo workflow.

Security Scanning

skillkit scan <path>                       # Scan skill for vulnerabilities
skillkit scan <path> --format json         # Output as JSON
skillkit scan <path> --format table        # Tabular output
skillkit scan <path> --format sarif        # SARIF for GitHub Code Scanning
skillkit scan <path> --fail-on high        # Exit 1 if HIGH+ findings
skillkit scan <path> --skip-rules UC001    # Skip specific rules

Threat Categories:

Category	Description
Prompt Injection	Override/bypass agent instructions
Command Injection	eval(), exec(), shell commands
Data Exfiltration	Webhook URLs, env var reads, credential access
Tool Abuse	Tool shadowing, autonomy escalation
Hardcoded Secrets	API keys, tokens, private keys
Unicode Steganography	Zero-width chars, bidi overrides

Install Integration:

Skills are automatically scanned during skillkit install. Use --no-scan to skip, or --force to install despite findings.

Output Formats:

summary (default) - colored terminal output
json - machine-readable JSON
table - tabular format
sarif - SARIF v2.1 for GitHub Code Scanning / IDE integration

Interactive TUI

skillkit ui    # Launch terminal UI
skillkit       # Same as above

Navigation Keys:

Key	Action
`h`	Home
`b`	Browse
`m`	Marketplace
`r`	Recommend
`t`	Translate
`c`	Context
`i`	Installed
`s`	Sync
`/`	Help
`q`	Quit

Exit Codes

Code	Meaning
0	Success
1	General error
2	Invalid arguments
3	Configuration issue
4	Network problem
5	Filesystem error

Quality Grades

Skills receive automatic quality scores mapped to grades:

Grade	Score Range
A	90-100
B	80-89
C	70-79
D	60-69
F	Below 60

Skills with score below 60 trigger warning displays before installation.

CLI Commands

On this page