Complete Guide to AI IDE Prompt Formats: Schemas, Specifications, and Conversions

1. Cursor

File Location: .cursor/rules (multiple files)

Format: MDC (Markdown Components) with YAML frontmatter

JSON Schema: cursor.schema.json

Deep Dive: Cursor Rules: A Technical Deep Dive

Frontmatter Requirements

Required:

• description (string) - Human-readable description used by AI for intelligent rule selection

Optional:

• globs (array of strings) - File patterns for "Apply to Specific Files" mode
• alwaysApply (boolean) - true = "Always Apply", false = intelligent/file-specific

Key Features

• Four Rule Types: Always Apply, Apply Intelligently, Apply to Specific Files, Apply Manually (@-mentioned)
• MDC Format: Cursor uses Markdown Components, an extension of standard markdown
• Smart Glob Patterns: Target specific file types or directories with precision

Example

---
description: React component development standards
globs:
  - "src/**/*.tsx"
  - "src/**/*.jsx"
alwaysApply: false
---

# React Component Standards

Use functional components with hooks. Keep components under 200 lines.

## State Management

We use Zustand for global state:
- Create stores in `src/stores/`
- Use selectors to prevent re-renders

2. Claude Code

File Locations:

• Agents: .claude/agents/*.md
• Skills: .claude/skills/*.md
• Slash Commands: .claude/commands/*.md
• Hooks: .claude/hooks/* (executable files)

Format: Markdown with YAML frontmatter (except hooks, which are executable scripts)

JSON Schemas:

• claude-agent.schema.json
• claude-skill.schema.json
• claude-slash-command.schema.json
• claude-hook.schema.json

Deep Dive: Claude Desktop & Claude Code: A Technical Deep Dive

Frontmatter Requirements (Agents & Skills)

Required:

• name (string) - Lowercase identifier with hyphens, max 64 chars for skills
• description (string) - Brief overview, max 1024 chars for skills

Optional:

• allowed-tools (string) - Comma-separated list (e.g., "Read, Write, Bash")
• model (string) - "sonnet" | "opus" | "haiku" | "inherit"

Key Features

• Tool Restrictions: Control which Claude Code tools (Read, Write, Bash, WebSearch, etc.) each agent/skill can use
• Model Selection: Choose specific Claude model per agent/skill
• Executable Hooks: Event-driven automations that run actual code (bash, TypeScript, Python, binaries)
• Emoji Icons: H1 headings can include emojis in markdown content (not frontmatter)

Example (Agent)

---
name: code-reviewer
description: Reviews code for best practices and potential issues
allowed-tools: Read, Grep, Bash
model: sonnet
---

# 🔍 Code Reviewer

You are an expert code reviewer with deep knowledge of software engineering principles.

## Instructions

- Check for code smells and anti-patterns
- Verify test coverage for new code
- Flag security vulnerabilities

3. Continue

File Location: .continue/rules/*.md

Format: Markdown with YAML frontmatter (or pure YAML files)

JSON Schema: continue.schema.json

Deep Dive: Continue Dev Prompts: A Technical Deep Dive

Frontmatter Requirements

Required:

• name (string) - Display name/title for the rule

Optional:

• description (string) - When the rule should be used
• globs (string or array) - File patterns like "**/*.tsx"
• regex (string or array) - Content matching patterns
• alwaysApply (boolean) - Complex tri-state logic for inclusion behavior

Key Features

• Regex Matching: Match rules based on file content patterns, not just filenames
• Tri-State alwaysApply: true = always, false = globs or AI, undefined = no globs or globs match
• Template Variables: Support for dynamic content in slash commands

Example

---
name: React Component Standards
globs: ["**/*.tsx", "**/*.jsx"]
regex: "^import React"
alwaysApply: false
---

# React Component Standards

Use functional components with hooks. Avoid class components.

## Testing

Every component needs a corresponding test file in `__tests__/`.

4. Windsurf

File Location: .windsurf/rules (single file)

Format: Plain markdown (NO frontmatter allowed)

Character Limit: 12,000 characters (hard limit)

JSON Schema: windsurf.schema.json

Deep Dive: Windsurf Rules: A Technical Deep Dive

Format Requirements

• No frontmatter: Any YAML frontmatter will be treated as content
• Plain markdown only: Standard markdown syntax, no extensions
• Single file: All rules and context in one document
• 12k hard limit: Content beyond 12,000 characters is truncated

Key Features

• Radical Simplicity: No metadata, no configuration, just write markdown
• Zero Parsing Overhead: No frontmatter parsing means instant loading
• Constraint-Driven Design: 12k limit forces concise, focused rules

Example

# React Development Guidelines

## Component Structure

- Use functional components with hooks
- Keep components under 200 lines
- Extract logic into custom hooks

## State Management

We use Zustand for global state:
- Create stores in `src/stores/`
- Use selectors to prevent re-renders
- Keep store slices focused and small

5. GitHub Copilot

File Locations:

• Repository-wide: .github/copilot-instructions.md
• Path-specific: .github/instructions/*.instructions.md

Format: Markdown with optional YAML frontmatter (path-specific files only)

JSON Schema: copilot.schema.json

Deep Dive: GitHub Copilot Instructions: A Deep Dive

Frontmatter Requirements (Path-Specific Only)

All fields optional:

• applyTo (string or array) - Glob patterns; can be comma-separated string like "**/*.ts,**/*.tsx"
• excludeAgent (string) - "code-review" | "coding-agent" to restrict which agent uses the instructions

Key Features

• Two-Tier System: Repository-wide baseline + path-specific overrides
• Comma-Separated Patterns: Unique syntax allowing applyTo: "**/*.ts,**/*.tsx" as single string
• Agent Exclusion: Control whether rules apply to code review vs coding agent
• No Frontmatter for Repo-Wide: Main instructions file is plain markdown

Example (Path-Specific)

---
applyTo: "app/models/**/*.rb"
excludeAgent: code-review
---

# Model Guidelines

Use ActiveRecord validations. Keep models focused and avoid business logic.

## Naming Conventions

- Use singular names for models
- Prefix join tables with both model names

6. Kiro Steering

File Location: .kiro/steering/*.md

Format: Markdown with optional YAML frontmatter

JSON Schema: kiro-steering.schema.json

Deep Dive: Kiro Steering Files: A Technical Deep Dive

Frontmatter Requirements

All fields optional (defaults to "always" if no frontmatter):

• inclusion (string) - "always" (default) | "fileMatch" | "manual"
• fileMatchPattern (string) - REQUIRED if inclusion: fileMatch
• domain (string) - Topic categorization (e.g., "testing", "api", "security")
• foundationalType (string) - "product" | "tech" | "structure" for special files

Key Features

• Inclusion Modes: Three strategies for when rules apply (always, file-based, manual)
• Domain Organization: Categorize rules by topic for better context management
• Foundational Files: Special files (product.md, tech.md, structure.md) for core project context
• Defaults to Always: No frontmatter means rule is always included

Example (fileMatch Mode)

---
inclusion: fileMatch
fileMatchPattern: "components/**/*.tsx"
domain: frontend
---

# React Component Guidelines

Use functional components with hooks. Avoid class components.

## Performance

- Use React.memo() for expensive renders
- Implement proper dependency arrays in hooks

7. Kiro Hooks

File Location: .kiro/hooks/*.json

Format: JSON configuration (not markdown)

JSON Schema: kiro-hooks.schema.json

JSON Structure

Required:

• name (string) - Human-readable name for the hook
• description (string) - What the hook does
• version (string) - Hook version (typically "1")
• when (object) - Trigger conditions:
  • type: "fileCreated" | "fileModified" | "fileDeleted"
  • patterns: Array of glob patterns
• then (object) - Action to take:
  • type: "askAgent" | "runCommand"
  • prompt: For askAgent actions
  • command: For runCommand actions

Key Features

• Event-Driven Automation: Trigger actions when files are created, modified, or deleted
• AI-Powered Actions: Ask agent to perform tasks automatically
• Pattern Matching: Use glob patterns to target specific files
• JSON Format: Unlike other Kiro files, hooks are pure JSON configuration

Example

{
  "name": "Image Asset Indexer",
  "description": "Automatically adds new image files to index.ts",
  "version": "1",
  "when": {
    "type": "fileCreated",
    "patterns": [
      "client/src/assets/*.png",
      "client/src/assets/*.jpg"
    ]
  },
  "then": {
    "type": "askAgent",
    "prompt": "Update client/src/assets/index.ts to include the new image file"
  }
}

8. agents.md

File Location: agents.md (project root or subdirectories)

Format: Plain markdown (NO frontmatter allowed)

JSON Schema: agents-md.schema.json

Deep Dive: agents.md: A Deep Dive into OpenAI's Open Standard

Format Requirements

• No frontmatter: Any YAML frontmatter is invalid
• Plain markdown only: Standard markdown syntax, no extensions or special features
• No special syntax: Just write documentation
• Free-form content: No required structure or sections

Key Features

• OpenAI Standard: Tool-agnostic format supported by multiple AI coding assistants
• Maximum Simplicity: The simplest possible format—just markdown
• Auto-Description: PRPM extracts description from first paragraph automatically
• No Configuration: Zero metadata, zero setup, zero learning curve

Example

# TaskMaster Development Guide

Task management app for remote teams with real-time collaboration.

## Project Overview

Built with React 18, TypeScript, Node.js, and PostgreSQL.

## Architecture

### Frontend

- React 18 + TypeScript
- Vite for build tooling
- Zustand for state management

### Backend

- Node.js + Express
- PostgreSQL with Prisma ORM
- Redis for session storage

## Coding Conventions

- Use TypeScript strict mode
- Functional components with hooks
- Test coverage required for new features

How It Works

1. Canonical Format: Packages are stored in PRPM's canonical format (see canonical.schema.json), which preserves core instructional content and common metadata. Format-specific features (like tools, regex patterns, or path-specific rules) may be lost during conversion.
2. Schema-Driven Validation: Each format's schema defines required fields, optional fields, field types, and constraints (like max character limits).
3. Best-Effort Conversion: PRPM maps canonical format to target format using schema definitions, preserving as much information as possible while flagging lossy conversions with quality scores and warnings.
4. Format-Specific Rules: Converters handle special cases like Copilot's comma-separated patterns, Windsurf's 12k character limit, and format-specific features that don't translate across formats.

Example: Installing a Cursor Rule in Claude Code

# Install a Cursor rule package
prpm install @nextjs/app-router --format claude-skill

# PRPM automatically:
# 1. Validates the package against cursor.schema.json
# 2. Converts to canonical format
# 3. Validates against canonical.schema.json
# 4. Converts to claude-skill format using claude-skill.schema.json
# 5. Writes to .claude/skills/app-router.md

Validating Prompts with JSON Schemas

You can validate your own prompts against PRPM's schemas using any JSON Schema validator. This catches errors early and ensures compatibility with PRPM's conversion system.

Using AJV (JavaScript)

import Ajv from 'ajv'
import cursorSchema from 'https://raw.githubusercontent.com/pr-pm/prpm/main/packages/converters/schemas/cursor.schema.json'

const ajv = new Ajv()
const validate = ajv.compile(cursorSchema)

const myRule = {
  frontmatter: {
    description: "React component standards",
    globs: ["src/**/*.tsx"]
  },
  content: "# React Standards\n\nUse functional components."
}

if (validate(myRule)) {
  console.log("Valid Cursor rule!")
} else {
  console.error("Validation errors:", validate.errors)
}

Using jsonschema (Python)

import json
import requests
from jsonschema import validate, ValidationError

# Fetch schema
schema_url = "https://raw.githubusercontent.com/pr-pm/prpm/main/packages/converters/schemas/cursor.schema.json"
schema = requests.get(schema_url).json()

# Your rule
my_rule = {
    "frontmatter": {
        "description": "React component standards",
        "globs": ["src/**/*.tsx"]
    },
    "content": "# React Standards\n\nUse functional components."
}

try:
    validate(instance=my_rule, schema=schema)
    print("Valid Cursor rule!")
except ValidationError as e:
    print(f"Validation error: {e.message}")