PRPM Now Supports Agent Skills: Build Once, Deploy Everywhere

Structure: Folder + SKILL.md

Skills live in subdirectories with a canonical structure:

.github/skills/
  api-testing/
    SKILL.md          # Required
    test-template.ts  # Optional bundled resources
    examples/         # Optional supporting files

.claude/skills/
  migration-helper/
    SKILL.md
    scripts/
      migrate.sh

The SKILL.md file contains YAML frontmatter with metadata and markdown content with procedures:

---
name: api-testing
description: Guides testing of REST APIs using Jest and Supertest
---

# API Testing Skill

This skill helps you write comprehensive API tests.

## Procedures

1. Set up test environment with Supertest
2. Write endpoint tests with assertions
3. Mock external dependencies
4. Test error handling

## Resources

- [Test template](./test-template.ts)
- [Example tests](./examples/)

Progressive Disclosure

AI agents discover skills through a three-level system:

1. Discovery: Agent reads frontmatter metadata to identify relevant skills
2. Loading: When matched, full SKILL.md body enters context
3. Access: Referenced resources (scripts, templates) load only when needed

This keeps context windows clean while ensuring agents have the knowledge they need.

Ecosystem Adoption

Agent Skills already works across major AI coding tools:

• GitHub Copilot: .github/skills/<name>/SKILL.md (VS Code Insiders with chat.useAgentSkills enabled)
• Claude Code: .claude/skills/<name>/SKILL.md
• Factory Droid: .factory/skills/<name>/SKILL.md
• OpenAI Codex CLI: .codex/skills/<name>/SKILL.md
• VS Code: Native support in progress

One skill format, multiple platforms. This is the portability promise.

1. Native Format Support

Install skills directly from the PRPM registry with automatic format detection:

# Install to GitHub Copilot skills directory
prpm install @prpm/api-testing --format copilot --subtype skill

# Install to Claude Code skills directory
prpm install @prpm/api-testing --format claude --subtype skill

# Install to Factory Droid skills directory
prpm install @prpm/api-testing --format droid --subtype skill

PRPM handles the directory structure, validates the format, and updates your package lockfile.

2. JSON Schema Validation

We ship comprehensive JSON schemas for Agent Skills across all supported platforms:

• copilot-skill.schema.json - GitHub Copilot skills
• claude-skill.schema.json - Claude Code skills
• droid-skill.schema.json - Factory Droid skills

These schemas validate required fields, enforce character limits, and provide IDE autocomplete:

{
  "frontmatter": {
    "name": "api-testing",           // Required, kebab-case, max 64 chars
    "description": "Guides testing…" // Required, max 1024 chars
  },
  "content": "# API Testing\n\n..."  // Markdown body
}

Publishing fails early with clear error messages when skills don't conform to spec.

3. Bidirectional Format Conversion

Convert between Agent Skills and any other PRPM format:

# Convert Cursor rule to GitHub Copilot skill
prpm convert .cursor/rules/api-testing.mdc \
  --to copilot --subtype skill \
  --output .github/skills/api-testing/SKILL.md

# Convert Claude skill to Windsurf rule
prpm convert .claude/skills/migration-helper/SKILL.md \
  --to windsurf \
  --output .windsurf/rules/migration-helper.md

# Convert skill to AGENTS.md format
prpm convert .github/skills/testing/SKILL.md \
  --to agents.md --subtype skill

Conversion preserves:

• Name and description metadata
• Procedural instructions
• Code examples
• Resource references (when supported by target format)

4. Registry Integration

Skills are indexed in the PRPM registry with dedicated filters:

# Search for GitHub Copilot skills
prpm search "testing" --format copilot --subtype skill

# Search for Claude Code skills
prpm search "migration" --format claude --subtype skill

# Search for any skill across all formats
prpm search "api" --subtype skill

Registry benefits:

• Download analytics per skill
• Version management with semver
• Quality scores based on Anthropic's best practices
• Package collections for common workflows

Scenario: Multi-Editor Team

Your team uses different AI editors:

• Frontend devs use Cursor
• Backend devs use Claude Code
• DevOps uses GitHub Copilot

You publish a company-wide API testing skill:

# Author writes once (any format)
cd my-skill-package
prpm init

# Create skill in preferred format (GitHub Copilot)
mkdir -p .github/skills/api-testing
cat > .github/skills/api-testing/SKILL.md << 'EOF'
---
name: api-testing
description: Company API testing standards with Jest and Supertest
---

# API Testing Skill

[Your company's testing procedures...]
EOF

# Publish to company registry
prpm publish @acme/api-testing

Team members install in their preferred format:

# Frontend dev (Cursor user)
prpm install @acme/api-testing --format cursor

# Backend dev (Claude Code user)
prpm install @acme/api-testing --format claude --subtype skill

# DevOps (GitHub Copilot user)
prpm install @acme/api-testing --format copilot --subtype skill

PRPM automatically converts the skill to each editor's native format. Everyone gets the same knowledge, tailored to their tool.

Format Comparison Table

PRPM handles the structural differences automatically.

Step 1: Create the Skill

mkdir -p testing-skill/.github/skills/api-testing
cd testing-skill

cat > .github/skills/api-testing/SKILL.md << 'EOF'
---
name: api-testing
description: Comprehensive API testing with Jest, Supertest, and OpenAPI validation
---

# API Testing Skill

## When to Use

- Creating new REST API endpoints
- Adding test coverage to existing APIs
- Validating OpenAPI spec compliance

## Procedures

### 1. Set Up Test Environment

```typescript
import request from 'supertest';
import { app } from '../src/app';

describe('API Tests', () => {
  // Tests here
});
```

### 2. Write Endpoint Tests

Test each endpoint with:
- Valid inputs (200/201 responses)
- Invalid inputs (400 responses)
- Authentication failures (401 responses)
- Authorization failures (403 responses)
- Not found scenarios (404 responses)

### 3. Validate Response Schemas

```typescript
expect(response.body).toMatchObject({
  id: expect.any(String),
  name: expect.any(String),
  createdAt: expect.any(String),
});
```

### 4. Test Error Handling

```typescript
it('returns 400 for invalid email', async () => {
  const response = await request(app)
    .post('/api/users')
    .send({ email: 'invalid' });

  expect(response.status).toBe(400);
  expect(response.body.error).toContain('email');
});
```

## Best Practices

- Mock external services
- Use meaningful test descriptions
- Test edge cases (empty arrays, null values)
- Verify error messages are helpful
- Check rate limiting behavior

## Resources

- [Test template](./test-template.ts)
- [Example tests](./examples/)
EOF

# Create supporting files
cat > .github/skills/api-testing/test-template.ts << 'EOF'
import request from 'supertest';
import { app } from '../src/app';

describe('GET /api/resource', () => {
  it('returns 200 with data', async () => {
    const response = await request(app).get('/api/resource');
    expect(response.status).toBe(200);
    expect(response.body).toHaveProperty('data');
  });
});
EOF

Step 2: Publish to PRPM

# Initialize package
prpm init

# Edit prpm.json
cat > prpm.json << 'EOF'
{
  "name": "@yourcompany/api-testing-skill",
  "version": "1.0.0",
  "description": "API testing best practices for REST endpoints",
  "format": "copilot",
  "subtype": "skill",
  "tags": ["testing", "api", "jest", "supertest"],
  "files": [
    ".github/skills/api-testing/SKILL.md",
    ".github/skills/api-testing/test-template.ts"
  ]
}
EOF

# Publish
prpm publish

Step 3: Install Across Editors

Team members can now install this skill in any editor:

# GitHub Copilot (preserves SKILL.md structure)
prpm install @yourcompany/api-testing-skill

# Claude Code (converts to Claude skill format)
prpm install @yourcompany/api-testing-skill --format claude --subtype skill

# Cursor (converts to Cursor rule)
prpm install @yourcompany/api-testing-skill --format cursor

# Windsurf (converts to plain markdown)
prpm install @yourcompany/api-testing-skill --format windsurf

Each editor gets the skill in its native format. Same knowledge, different structure.

1. No More Copy-Paste

Before Agent Skills + PRPM:

• Write testing guidelines in Notion
• Copy-paste into .cursorrules
• Manually convert to Claude skill format
• Rewrite for GitHub Copilot instructions
• Update all copies when something changes

After:

• Write once as Agent Skills format
• Publish to PRPM
• Install converts automatically
• Update with prpm upgrade

2. Capture Institutional Knowledge

Your senior engineers' tribal knowledge can now be:

• Packaged as skills
• Versioned with semver
• Discovered through PRPM search
• Applied by AI agents automatically
• Updated as patterns evolve

Example skills companies are publishing:

• @acme/database-migrations - How we safely change schemas
• @acme/security-review - Security checklist for new features
• @acme/api-design - REST API conventions
• @acme/incident-response - On-call debugging procedures

3. Format-Agnostic Publishing

Package authors don't need to support every editor:

# Publish once in any format
prpm publish @vendor/migration-helper

# Users install for their editor
prpm install @vendor/migration-helper --format cursor
prpm install @vendor/migration-helper --format claude --subtype skill
prpm install @vendor/migration-helper --format copilot --subtype skill

# PRPM converts automatically
# Package author supports all editors without extra work

This is the write-once-deploy-everywhere promise PRPM was built for.