Skip to content

talocode/skilllane

BranchesTags

Repository files navigation

SkillLane

Skills are infrastructure for agents.

Open-source skill runtime and registry for AI agents — create, validate, install, run, and share reusable agent skills.

npm PyPI License: MIT

Why SkillLane

Every AI agent today writes the same debugging prompts, code reviews, and content generation from scratch. Skills solve this — reusable, validated, portable bundles of agent behavior.

SkillLane is the runtime that makes skills first-class infrastructure:

  • Create skills from templates or scratch
  • Validate skills with a 100-point scoring system (secrets detection, schema checks, content quality)
  • Install from local paths, git repos, or built-in skills
  • Run skills to generate structured prompts for any agent target
  • Share via a local registry (remote marketplace coming soon)

How it works

┌─────────────────────────────────────────────────────────┐
│                     SkillLane                           │
│                                                         │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐           │
│  │ Creator  │──▶│Validator │──▶│ Installer│           │
│  │ (scaffold)│  │ (100pts) │   │ (copy +  │           │
│  └──────────┘   └──────────┘   │ registry)│           │
│                                 └────┬─────┘           │
│                                      │                  │
│                                      ▼                  │
│                          ┌───────────────────┐          │
│                          │  Local Registry   │          │
│                          │  ~/.skilllane/    │          │
│                          │  registry.json    │          │
│                          └────────┬──────────┘          │
│                                   │                     │
│                    ┌──────────────┼──────────────┐      │
│                    ▼              ▼              ▼      │
│              ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│              │  Runner  │  │API Server│  │MCP Server│  │
│              │ (prompts)│  │ (:3080)  │  │(stdio)   │  │
│              └──────────┘  └──────────┘  └──────────┘  │
│                    │              │              │       │
│                    ▼              ▼              ▼       │
│              ┌──────────────────────────────────────┐   │
│              │     Agent Targets                    │   │
│              │  codex │ opencode │ codra │ tera     │   │
│              └──────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────┘

Install

npm

npm install -g @talocode/skilllane

pip

pip install talocode-skilllane

From source

git clone https://github.com/talocode/skilllane.git
cd skilllane
npm install
npm run build
npm link

Requirements: Node.js >= 18.0.0

Quickstart

# Initialize SkillLane storage
skilllane init

# Install a built-in skill
skilllane install --builtin systematic-debugging

# Run it
skilllane run systematic-debugging --task "Debug a TypeError in UserProfile"

# See all installed skills
skilllane list

# Create your own skill
skilllane create my-skill --title "My Skill" --category engineering

# Validate it
skilllane validate ./my-skill

# Check system health
skilllane doctor

Skill Format

Every skill is a directory containing these files:

File Required Description
metadata.json Yes Name, version, tags, category, targets
SKILL.md Yes Role, instructions, constraints, workflow
tools.json Yes Tool definitions the skill needs
examples.md Yes Example inputs/outputs for reference
eval.md Yes Success criteria and evaluation checks

metadata.json schema

{
  "name": "my-skill",
  "version": "0.1.0",
  "title": "My Skill",
  "description": "What this skill does",
  "author": "Your Name",
  "license": "MIT",
  "tags": ["engineering", "debugging"],
  "category": "engineering",
  "targets": ["codex", "opencode", "codra", "mcp"],
  "requiresTools": [],
  "createdAt": "2026-01-01T00:00:00.000Z",
  "updatedAt": "2026-01-01T00:00:00.000Z"
}

Built-in Skills

SkillLane ships with 8 skills ready to install:

Skill Category Description
systematic-debugging engineering Structured approach to diagnosing and fixing code errors
agent-code-review engineering Code review covering correctness, security, performance, maintainability
context-engineering engineering Manage context windows, summarize, compact information efficiently
screen-aware-command engineering Create precise agent commands from rough user instructions
launch-thread-writer marketing Generate concise product launch threads in Talocode style
x-growth marketing Write X posts, replies, hooks, and launch threads that get engagement
product-launch marketing Turn shipped products into launch copy, docs, X threads, and release notes
frontend-design design Produce better UI with deliberate aesthetic, hierarchy, typography, color choices

CLI Commands

skilllane init                        # Initialize ~/.skilllane directory
skilllane create <name>               # Create a new skill from template
skilllane validate <path>             # Validate a skill folder
skilllane install <source>            # Install a skill from a path
skilllane list                        # List installed skills
skilllane search <query>              # Search installed skills
skilllane show <name>                 # Show skill details
skilllane run <name>                  # Run a skill
skilllane remove <name>               # Remove an installed skill
skilllane export <name>               # Export a skill to a tarball
skilllane serve                       # Start the HTTP API server
skilllane mcp                         # Start the MCP server
skilllane doctor                      # Check system health
skilllane demo                        # Run deterministic demo

# Registry management
skilllane registry path               # Show registry file path
skilllane registry rebuild            # Rebuild registry from installed skills
skilllane registry stats              # Show registry statistics

# Configuration
skilllane config get <key>            # Get a config value
skilllane config set <key> <value>    # Set a config value
skilllane config list                 # List all config values

Create options

skilllane create my-skill \
  --title "My Skill" \
  --description "Does something useful" \
  --category engineering \
  --tags "debugging,troubleshooting" \
  --targets "codex,opencode" \
  --template debugging \
  --out ./skills

Run options

skilllane run systematic-debugging \
  --task "Fix this TypeError" \
  --context "Cannot read property 'name' of undefined" \
  --target opencode \
  --out result.json

Install options

skilllane install --builtin systematic-debugging     # Install built-in
skilllane install ./my-skill                          # Install from path
skilllane install https://github.com/user/skill.git  # Install from git
skilllane install ./my-skill --force                  # Overwrite existing

SDK Usage

TypeScript

import { SkillLaneClient } from '@talocode/skilllane';

const client = new SkillLaneClient();

// Initialize
await client.init();

// Create a skill
await client.createSkill({
  name: 'my-skill',
  description: 'A custom skill',
  category: 'engineering',
  outDir: './skills',
});

// Validate
const result = await client.validateSkill('./my-skill');
console.log(`Score: ${result.score}/100`);

// Install
await client.installSkill('./my-skill');

// List skills
const skills = await client.listSkills({ category: 'engineering' });

// Run a skill
const run = await client.runSkill({
  skillName: 'systematic-debugging',
  task: 'Debug a runtime error',
  context: 'TypeError at line 42',
  target: 'opencode',
});

console.log(run.prompt);

Connect to remote API

const client = new SkillLaneClient({
  baseUrl: 'http://localhost:3080',
  authToken: 'your-token',
});

API Routes

Start the API server with skilllane serve.

Method Route Auth Description
GET /health No Health check
GET /v1/skilllane/health No Health check (v1)
GET /v1/skilllane/doctor No System diagnostics
POST /v1/skilllane/init Yes Initialize storage
POST /v1/skilllane/skills/create Yes Create a new skill
POST /v1/skilllane/skills/validate Yes Validate a skill
POST /v1/skilllane/skills/install Yes Install a skill
GET /v1/skilllane/skills No List installed skills
GET /v1/skilllane/skills/search No Search skills
GET /v1/skilllane/skills/:name No Get skill details
POST /v1/skilllane/skills/:name/run Yes Run a skill
POST /v1/skilllane/skills/:name/export Yes Export a skill
DELETE /v1/skilllane/skills/:name Yes Remove a skill
GET /v1/skilllane/registry No Get registry info
POST /v1/skilllane/registry/rebuild Yes Rebuild registry
GET /v1/skilllane/registry/stats No Registry statistics
POST /v1/skilllane/demo No Run demo

Example: Run a skill via API

curl -X POST http://localhost:3080/v1/skilllane/skills/systematic-debugging/run \
  -H "Content-Type: application/json" \
  -d '{"task": "Debug a TypeError", "context": "Cannot read property of undefined"}'

MCP Tools

Start the MCP server with skilllane mcp. Exposes 12 tools via the Model Context Protocol (JSON-RPC over stdio):

Tool Description
skilllane_init Initialize local storage
skilllane_create Create a new skill
skilllane_validate Validate a skill directory
skilllane_install Install a skill from a path
skilllane_list List installed skills
skilllane_search Search skills by query
skilllane_show Show skill details
skilllane_run Run a skill with a task
skilllane_remove Remove an installed skill
skilllane_doctor Run health checks
skilllane_demo Run the demo
skilllane_registry_stats Get registry statistics

MCP Configuration

{
  "mcpServers": {
    "skilllane": {
      "command": "skilllane",
      "args": ["mcp"]
    }
  }
}

Python Package

The Python package provides an HTTP client that talks to a running SkillLane API server.

pip install talocode-skilllane
from talocode_skilllane import SkillLaneClient

client = SkillLaneClient(base_url="http://localhost:3080")

# Check health
print(client.health())

# List skills
skills = client.list_skills(category="engineering")

# Run a skill
result = client.run_skill(
    name="systematic-debugging",
    task="Debug a TypeError",
    context={"error": "Cannot read property of undefined at line 42"}
)
print(result)

Python CLI

skilllane-py health
skilllane-py list --category engineering
skilllane-py search debugging
skilllane-py validate ./my-skill --strict
skilllane-py run systematic-debugging --task "Fix this bug"
skilllane-py demo

Environment variables

Variable Default Description
SKILLLANE_URL http://localhost:3080 API server URL
SKILLLANE_TOKEN (none) Auth token

Local Registry

All data lives in ~/.skilllane/:

~/.skilllane/
├── config.json          # Configuration
├── registry.json        # Installed skills index
├── skills/              # Skill directories
│   ├── systematic-debugging/
│   ├── agent-code-review/
│   └── ...
└── runs/                # Run history

Registry management

skilllane registry path     # Show path to registry.json
skilllane registry rebuild  # Rescan skills/ and rebuild registry
skilllane registry stats    # Show skill counts by category/tag

Validator

The validator scores skills on a 100-point scale:

Check Points Type
Each missing required file -15 error
metadata.json invalid JSON -15 error
Each metadata field error -10 error
Empty metadata.title -5 error
Empty metadata.description -5 error
Empty metadata.targets -5 error
Empty metadata.tags -3 warning
tools.json invalid JSON -10 error
No tools defined -3 warning
SKILL.md empty -15 error
SKILL.md too short -5 warning
examples.md empty -10 error
No example section header -5 warning
eval.md empty -10 error
No criteria section header -5 warning
File exceeds 1MB -5 warning
Secret detected in file -15 error

Score interpretation:

  • 80-100: Production-ready
  • 50-79: Usable with warnings
  • 0-49: Needs work
skilllane validate ./my-skill
skilllane validate ./my-skill --strict   # Fail on first error
skilllane validate ./my-skill --json     # JSON output

Creator

Scaffold new skills from templates:

skilllane create my-skill --template basic
skilllane create my-bug-fixer --template debugging
skilllane create my-writer --template writing
skilllane create my-launcher --template product-launch

Each template generates all 5 required files with pre-filled content matching the template's domain.

Runner

The runner takes an installed skill and generates a structured prompt for any agent target.

skilllane run systematic-debugging --task "Fix the login bug"

Output modes:

Mode Description
prompt Plain text sections with [Section] headers
markdown Markdown with ## Section headers and --- dividers
json JSON array of {section, content} objects

Target descriptions injected into prompts:

Target Description
codex OpenAI Codex CLI — terminal commands and file operations
opencode OpenCode CLI — bash tool, file tools
codra Codra — codebase context and editor features
tera Tera — code generation and inline suggestions
mcp MCP protocol — tool-based interactions
clipboard Output to clipboard
stdout Plain text response
all General-purpose instructions

Security & Privacy

  • Local-first: All data stored in ~/.skilllane/. No telemetry.
  • Secrets detection: Validator scans for AWS keys, private keys, API keys, tokens, passwords, bearer tokens.
  • Auth support: Optional Bearer token auth for API routes. Configurable via SKILLLANE_REQUIRE_AUTH and SKILLLANE_API_AUTH_TOKEN.
  • No remote calls: v0.1 does not call external services by default.

Talocode Ecosystem

SkillLane is part of the Talocode ecosystem:

  • SkillLane — Skill runtime and registry
  • OpenCode — AI coding CLI (primary target)
  • Codex — OpenAI's coding agent
  • Codra — Code intelligence platform

Demo Video

Run the built-in demo to see SkillLane in action:

skilllane demo

This validates a built-in skill, installs it, runs it with a sample TypeScript error, and saves output to demo/demo-output.json.

Roadmap

Version Milestone
v0.1 Local runtime, CLI, SDK, API, MCP, 8 built-in skills
v0.2 Remote registry, skilllane publish, skilllane update, skill versioning
v0.3 Skill dependencies, skill composition, plugin hooks
v1.0 Production-ready remote marketplace, enterprise features

See docs/ROADMAP.md for details.

Limitations

Be aware of these current limitations:

  • Local only (v0.1): No remote registry or sharing. You can't skilllane install from a central marketplace yet.
  • Prompt generation, not execution: The runner generates structured prompts — it does not execute code or call LLMs directly.
  • No skill versioning: Skills are identified by name, not version. Updating requires --force.
  • No skill dependencies: Skills cannot depend on other skills.
  • Remote marketplace planned: A hosted registry for discovering and publishing skills is planned for v0.2.

Contributing

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

MIT License — see LICENSE for details.

About

Open-source skill runtime and registry for AI agents — create, validate, install, run, and share reusable agent skills across Codex, OpenCode, Tera, Codra, MCP, and Talocode workflows.

Topics

cli sdk skills mcp opencode developer-tools codex ai-agents prompt-engineering agentic-workflows context-engineering skill-registry talocode

Resources

Readme

License

MIT license

Security policy

Security policy
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases 1

SkillLane v0.1.0 Latest
Jul 16, 2026

Packages

 
 
 

Contributors

Languages