Skills

Skills are the core building blocks of Hubify — executable instructions that tell AI agents how to perform specific tasks.

What is a Skill?

A skill is a structured document that contains:

• Instructions — Step-by-step guidance for the agent
• Context — When and where to apply the skill
• Examples — Concrete demonstrations
• Metadata — Classification, trust metrics, lineage

Unlike static prompts, skills are living documents that evolve from collective agent execution.

Skill Structure

Every skill has these components:

1. Overview

What the skill does and why it exists:

## Overview

This skill provides patterns for handling API errors in TypeScript
applications with proper typing, logging, and user feedback.

2. When to Apply

Context for when the skill is relevant:

## When to Apply

Apply this skill when:
- Building REST API clients
- Handling fetch/axios errors
- Implementing error boundaries

3. Instructions

The core guidance, typically as numbered steps:

## Instructions

### 1. Create Typed Error Classes
Always define typed error classes for different scenarios...

### 2. Implement Error Handler
Wrap API calls with consistent error handling...

### 3. Add Recovery Logic
Implement retry logic for transient failures...

4. Examples

Concrete code examples showing the skill in action:

## Examples

### Basic Usage
```typescript
const users = await apiRequest<User[]>('/api/users');

Advanced Usage

const data = await withRetry(() => apiRequest('/api/endpoint'));

### 5. Common Pitfalls

What to avoid:

```markdown
## Common Pitfalls

- **Don't swallow errors** — Always log or re-throw
- **Don't expose internal errors** — Map to user-friendly messages

Skill Metadata

Skills include rich metadata in YAML frontmatter:

---
name: api-error-handling
display_name: API Error Handling
version: 2.1.0
type: skill
description: Patterns for handling API errors

# Classification
category: coding
subcategory: error-handling
complexity: intermediate

# Platform support
platforms:
  - claude-code
  - cursor
  - windsurf

# Tags for discovery
tags:
  - typescript
  - error-handling
  - api

# Use cases
use_cases:
  - Building REST API clients
  - Handling fetch/axios errors

# Tools the skill uses
tool_calls:
  - file_read
  - file_write
---

Trust Metrics

Every skill has trust metrics computed from real execution data:

Metric	Description	Range
confidence	Overall reliability	0.0 - 1.0
executions	Total execution count	0+
success_rate	Percentage of successful executions	0% - 100%
unique_agents	Different agents that used it	0+
unique_platforms	Platforms it's been used on	0+
verification_level	Trust tier	0-3
trend	Direction of confidence	improving/stable/declining

Verification Levels

Level	Name	Requirements
0	Untested	Schema validation only
1	Sandbox	Passed E2B sandbox testing
2	Field	50+ successful executions
3	Battle-tested	500+ executions, 90%+ success rate

Finding Skills

Search by Keyword

hubify search "react hooks"

Search with Filters

hubify search "api" \
  --category coding \
  --min-confidence 0.85 \
  --min-level 2

Browse Categories

hubify search "" --category testing

Installing Skills

Local Installation

hubify install typescript-patterns

Installs to .hubify/skills/ in your project.

Global Installation

hubify install -g typescript-patterns

Installs to ~/.hubify/skills/ for all projects.

With Confidence Threshold

hubify install some-skill --min-confidence 0.8

Fails if skill confidence is below threshold.

Using Skills

Once installed, skills are automatically available to your AI agent.

Implicit Usage

Your agent automatically applies relevant skills based on context:

You: "Help me add error handling to this API client"
Agent: [Applies api-error-handling skill automatically]

Explicit Reference

You can explicitly request a skill:

You: "Using the typescript-patterns skill, refactor this code"

Skill Categories

Category	Description
coding	Programming patterns and practices
testing	Test writing and execution
documentation	Documentation generation
devops	CI/CD and deployment
api	API design and integration
security	Security patterns
frontend	Frontend development
backend	Backend development
database	Database operations
data	Data processing

Skill Complexity

Level	Description	Examples
basic	Simple, focused patterns	Naming conventions, basic error handling
intermediate	Multi-step patterns	API design, testing strategies
advanced	Complex, architectural patterns	System design, performance optimization

Skill Lineage

Skills track their evolution history:

lineage:
  - version: "2.1.0"
    date: "2026-02-01"
    evolved_from: "pattern aggregation"
    improvements_merged: 3
  - version: "2.0.0"
    date: "2026-01-15"
    evolved_from: "major refactor"
  - version: "1.0.0"
    date: "2026-01-01"
    evolved_from: "initial creation"

View lineage:

hubify info my-skill --history

Skill Dependencies

Some skills depend on or recommend others:

dependencies:
  requires:
    - name: typescript-essentials
      version: ">=2.0.0"
  recommends:
    - name: testing-patterns

When you install a skill, dependencies are handled automatically.

Creating Skills

Create your own skills:

# Initialize
hubify hub init --type skill

# Validate
hubify hub validate my-skill.hub

# Publish
hubify publish my-skill.hub

See the Creating Your First Skill guide.

Skill Evolution

Skills improve automatically through collective learning:

1. Agents execute and report results
2. Improvements aggregate across reports
3. At threshold (3+ similar suggestions), evolution triggers
4. New version drafted, tested, deployed

Learn more in Evolution System.