JSON Schemas for Every AI Prompt Format

1. Format Conversion Requires Precision

PRPM converts prompts between 15+ formats. To do that reliably, we need to know exactly what each format expects. Schemas let us:

• Validate input: Catch malformed prompts before conversion
• Validate output: Ensure conversions produce valid files
• Handle subtypes: Claude agents vs skills vs slash commands have different requirements
• Preserve metadata: Know which fields are format-specific vs universal

Every converter in @pr-pm/converters uses these schemas for validation.

2. Publishing Needs Validation

When you run prpm publish, the CLI validates your package against the schema for your declared format and subtype. This catches errors before they reach the registry:

$ prpm publish

❌ Validation failed:
  - Missing required field: description
  - /frontmatter/model: must be one of [sonnet, opus, haiku, inherit]
  - /frontmatter/allowed-tools: pattern mismatch

Fix these errors and try again.

Clear error messages tell you exactly what's wrong and where.

3. Documentation Is a First-Class Output

Schemas aren't just for validation—they're living documentation. Each schema includes:

• $comment with link to official docs
• description fields explaining each property
• examples showing real-world usage
• Pattern explanations for complex fields

The schemas in packages/converters/schemas/ serve as the canonical reference for format specifications.

IDE Autocomplete and IntelliSense

VS Code (and most modern editors) support YAML Language Server, which uses JSON schemas to provide autocomplete, validation, and hover documentation.

Add this to your workspace .vscode/settings.json:

{
  "yaml.schemas": {
    "https://registry.prpm.dev/api/v1/schemas/cursor.json": ".cursor/rules/*.md",
    "https://registry.prpm.dev/api/v1/schemas/claude/agent.json": ".claude/agents/*.md",
    "https://registry.prpm.dev/api/v1/schemas/claude/skill.json": ".claude/skills/*.md",
    "https://registry.prpm.dev/api/v1/schemas/continue.json": ".continue/rules/*.md"
  }
}

Now when you edit Cursor rules or Claude agents, you get:

• Field suggestions as you type frontmatter
• Inline documentation for each field
• Red squiggles for invalid values
• Enum suggestions (e.g., Claude model choices)

CI/CD Validation

Add schema validation to your GitHub Actions workflow to catch invalid prompts before they reach production:

name: Validate Prompts

on: [push, pull_request]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '20'

      - name: Install PRPM
        run: npm install -g prpm

      - name: Validate all packages
        run: |
          for dir in packages/*/; do
            cd "$dir"
            prpm validate
            cd ../..
          done

The prpm validate command checks your prpm.json manifest and all referenced files against their schemas.

Building Tools on PRPM

If you're building tooling around AI prompts—linters, editors, quality analyzers—schemas give you a programmatic way to validate prompt files:

import { validateMarkdown } from '@pr-pm/converters';

// Validate a Cursor rule file
const cursorRule = readFileSync('.cursor/rules/react.md', 'utf-8');
const result = validateMarkdown('cursor', cursorRule, 'rule');

if (!result.valid) {
  console.error('Validation errors:', result.errors);
  result.errors.forEach(err => {
    console.error(`  - ${err.message}`);
  });
  process.exit(1);
}

// Validate a Claude agent with subtype-specific schema
const claudeAgent = readFileSync('.claude/agents/code-reviewer.md', 'utf-8');
const result2 = validateMarkdown('claude', claudeAgent, 'agent');

if (result2.warnings.length > 0) {
  console.warn('Warnings:', result2.warnings);
}

The validation API returns structured errors with paths and messages, making it easy to surface issues to users.

Format Conversion with the CLI

The PRPM CLI includes a convert command that leverages these schemas to safely convert between formats:

# Convert a Cursor rule to Claude skill format
$ prpm convert .cursor/rules/react.md --to claude --subtype skill

✅ Validated input (cursor:rule)
✅ Converted to claude:skill
✅ Validated output
📄 Wrote: .claude/skills/react.md

# Convert entire directories
$ prpm convert .cursor/rules/ --to continue --output .continue/rules/

Converting 12 files...
✅ 12/12 files converted successfully
⚠️  2 warnings (optional fields missing)
❌ 0 errors

The CLI validates both input and output using the appropriate schemas, catching errors before they reach your filesystem.

Programmatic Conversion with Validation

For building tools, use the conversion API which includes built-in schema validation:

import { convertToFormat, validateFormat } from '@pr-pm/converters';

// Convert Cursor rule to Claude skill
const cursorRule = readFileSync('.cursor/rules/refactoring.md', 'utf-8');

// Validate input
const inputValid = validateMarkdown('cursor', cursorRule, 'rule');
if (!inputValid.valid) {
  throw new Error('Invalid Cursor rule');
}

// Convert
const claudeSkill = convertToFormat(cursorRule, 'cursor', 'claude', 'skill');

// Validate output
const outputValid = validateMarkdown('claude', claudeSkill, 'skill');
if (!outputValid.valid) {
  console.error('Conversion produced invalid Claude skill');
  console.error('This is a converter bug, please report it');
}

Write Once, Publish Everywhere

For package publishers, schemas enable a powerful workflow: write your prompt in one format, then publish to all 15+ formats with confidence.

# Write once in your preferred format (e.g., Claude skill)
$ cat .claude/skills/typescript-best-practices.md

---
name: typescript-best-practices
description: TypeScript coding standards and best practices
---

# TypeScript Best Practices
...

# Publish to PRPM registry (canonical format)
$ prpm publish
✅ Validated against claude:skill schema
✅ Published to registry

# Generate distributions for all formats
$ prpm convert .claude/skills/typescript-best-practices.md --to cursor
$ prpm convert .claude/skills/typescript-best-practices.md --to continue
$ prpm convert .claude/skills/typescript-best-practices.md --to windsurf
$ prpm convert .claude/skills/typescript-best-practices.md --to copilot
# ... 15+ formats supported

# Each conversion is validated against target format's schema
✅ cursor:rule - validated
✅ continue:rule - validated
✅ windsurf:rule - validated
✅ copilot:repository - validated

Schemas ensure every converted output is valid for its target format. Users can install your package in any format they prefer:

# User A (Cursor user)
$ prpm install typescript-best-practices --format cursor
📥 Installed to .cursor/rules/typescript-best-practices.md

# User B (Claude user)
$ prpm install typescript-best-practices --format claude
📥 Installed to .claude/skills/typescript-best-practices.md

# User C (Continue user)
$ prpm install typescript-best-practices --format continue
📥 Installed to .continue/rules/typescript-best-practices.md

Behind the scenes, PRPM converts from the canonical format to the requested format and validates the output. Publishers maintain one source, users get their preferred format—all guaranteed valid by schemas.

1. Source Repository

Browse schemas directly in the PRPM repository:

packages/converters/schemas/
├── cursor.schema.json
├── cursor-command.schema.json
├── claude.schema.json
├── claude-agent.schema.json
├── claude-skill.schema.json
├── claude-slash-command.schema.json
├── claude-hook.schema.json
├── continue.schema.json
├── windsurf.schema.json
├── copilot.schema.json
├── kiro-steering.schema.json
├── kiro-hook.schema.json
├── kiro-agent.schema.json
├── ruler.schema.json
├── droid.schema.json
├── droid-skill.schema.json
├── droid-slash-command.schema.json
├── droid-hook.schema.json
├── opencode.schema.json
├── opencode-slash-command.schema.json
├── agents-md.schema.json
├── trae.schema.json
├── aider.schema.json
├── zencoder.schema.json
├── replit.schema.json
├── gemini.schema.json
├── gemini-md.schema.json
├── canonical.schema.json
└── format-registry.schema.json

2. Registry API

Access schemas via HTTPS for IDE integration and tooling. Browse all available schemas at the schema reference endpoint:

# Base format schemas
https://registry.prpm.dev/api/v1/schemas/{format}.json

# Subtype schemas (where applicable)
https://registry.prpm.dev/api/v1/schemas/{format}/{subtype}.json

# Format registry data (directory structures for all formats)
https://registry.prpm.dev/api/v1/schemas/format-registry

# Format registry schema (validates format-registry structure)
https://registry.prpm.dev/api/v1/schemas/format-registry.json

# Examples:
https://registry.prpm.dev/api/v1/schemas/cursor.json
https://registry.prpm.dev/api/v1/schemas/claude/agent.json
https://registry.prpm.dev/api/v1/schemas/kiro/hook.json

The format registry endpoint returns the complete directory structure configuration for all 15+ formats—where files should be installed, what patterns to scan for, and how nested packages work.

3. npm Package

Use the validation API in your JavaScript/TypeScript projects:

npm install @pr-pm/converters

import { validateMarkdown, validateFormat } from '@pr-pm/converters';

const result = validateMarkdown('cursor', content, 'rule');