PRPM: Distributable Intelligence for AI-Assisted Development

In one line: PRPM is a package manager for AI coding assistants—ship rules, skills, and agents that make migrations and refactors correct by default.

In Two Minutes

Codemods automate the first 60–80% of migrations. Docs explain the rest. Developers still wrestle with edge cases, conventions, and tests. PRPM closes the gap by letting maintainers publish executable knowledge:

Rules - Declarative constraints AI enforces during code generation
Skills - Step-by-step procedures for specific tasks
Agents - Multi-file orchestration with edge case detection

Developers prpm install @vendor/migration-package, their AI assistant loads it from .claude/ or .cursor/, and performs context-aware changes across the repo, flags true edge cases, and generates tests that match your conventions.

Outcome:

95% of migration work handled automatically vs 70% with scripts alone. Faster upgrades, consistent code, materially fewer support tickets.

Why now: AI can refactor entire codebases, but it lacks framework- and company-specific patterns. PRPM provides a universal format with converters for Cursor/Windsurf/Claude/Copilot, versioned distribution, and a registry for discovery and updates.

Who benefits:

Framework authors - Smoother breaking changes, faster adoption
SaaS vendors - Deprecate old APIs sooner, fewer tickets
Enterprises - Codify standards once; every team's AI follows them
OSS maintainers - Contributors generate PRs in your house style

How It Works in 60 Seconds

1. Author

Create rules, skills, and agents as Markdown files with YAML frontmatter:

$ prpm init
# Creates prpm.json + example files

---
format: cursor
subtype: rule
---

Nango TypeScript Patterns

Learn more at Nango.dev

When converting YAML integrations:

•YAML sync → TypeScript class extending NangoSync
•models array → generic type NangoSync<Model>
•frequency → @Frequency decorator

2. Publish

$ prpm publish
✓ Published @nango/yaml-to-ts-migration@1.0.0

3. Install & Apply

$ prpm install @nango/yaml-to-ts-migration-agent
✓ Installed to .cursor/rules/nango/yaml-to-ts-migration-agent

# In your AI assistant (Cursor/Claude/etc):
"Migrate all YAML integrations to TypeScript"

# AI (with package loaded):
✓ Migrated 12 integrations
✓ Generated tests
✓ Updated imports
⚠ 2 files require manual review (flagged)

Total time: 30 minutes vs 2-4 hours

The Problem: Edge Cases Stall Migrations

Traditional Approach

When frameworks ship breaking changes:

Migration script - Handles 60-80% (syntax-level transforms)
Documentation - Explains patterns and edge cases
Support channels - Field hundreds of questions
Months of lag - Adoption delayed by migration pain

Result: Slow adoption, fragmented ecosystem, support burden

Real Example: Nango's YAML → TypeScript Migration

When Nango migrated from YAML-based integrations to TypeScript, they provided:

✅ Migration script: nango migrate yaml-to-ts

Converts basic YAML structure
Handles ~70% of common cases

✅ Documentation: Migration guide with examples

API reference for new TypeScript classes
Pattern explanations

❌ Missing: Deep knowledge for AI to complete migration

Which TypeScript patterns for each YAML feature
How to handle pagination logic correctly
Webhook migration with proper typing
Test generation matching Nango conventions
Edge case detection and reporting

Gap: Developers manually convert 30% of cases by reading docs, trial-and-error on type errors, hoping they match Nango's patterns.

The PRPM Solution

Nango ships the complete suite:

Component	Purpose	Coverage
Migration Script	Syntax-level transforms	70%
Documentation	Human learning	Reference
PRPM Packages	AI-executable knowledge	+25%
Developer Review	True edge cases	5%

Migration Script

70%

Syntax-level transforms

Documentation

Reference

Human learning

PRPM Packages

+25%

AI-executable knowledge

Developer Review

True edge cases

Total: 95% automated vs 70% with scripts alone

Package Types: Rules, Skills, Agents

Rules

Declarative constraints enforced during code generation

Example: Nango TypeScript Integration Rules

→Sync configs extend NangoSync<ModelType>
→Action configs extend NangoAction<InputType, OutputType>
→Use @Frequency decorator for sync schedules
→Class names: PascalCase (e.g., SalesforceContacts)
→File names: kebab-case (e.g., salesforce-contacts.integration.ts)

When AI generates code, it automatically applies these patterns.

Skills

Step-by-step procedures for specific tasks

Example: Migrate YAML Sync Configuration

Read the YAML sync configuration
Extract: name, frequency, models, endpoints
Create TypeScript class extending NangoSync<ModelType>
Add @Frequency decorator
Preserve pagination logic
Add error handling
Generate tests

AI invokes skills for specific migration tasks.

Agents

Multi-step orchestration with reporting

Example: Nango YAML to TypeScript Migration Agent

I am a specialized agent for migrating Nango YAML integrations to TypeScript.

My Process:

Discovery - Scan codebase for YAML integration files
Analysis - Parse each YAML, identify patterns and complexity
Generation - Create TypeScript equivalents using rules and skills
Integration - Update imports, dependencies, references
Testing - Generate test files based on YAML patterns
Reporting - Summary with edge cases flagged for review

AI runs agents for end-to-end migrations.

The Complete Stack

Every technical company should ship:

Component	Format	For	Coverage
Documentation	Website, markdown	Humans	Concept learning
Migration Scripts	CLI, codemods	Automation	60-80% mechanical
PRPM Packages	Rules, skills, agents	AI	+20-40% contextual

This is the new standard.

Documentation teaches, scripts automate, PRPM packages guide AI to handle nuanced work.

Why Now

The AI coding assistant is the new compiler.

Just like every language needed:

Documentation (how to write code)
Compiler/interpreter (how to run code)
Package manager (how to share code)

Every AI coding platform needs:

Documentation (what to build)
Migration scripts (basic automation)
PRPM packages (how to build it correctly)

2020: "AI will help with autocomplete"
2023: "AI can write full functions"
2024: "AI can refactor entire codebases"
2025: "AI needs distributed knowledge to do it RIGHT"
      ↑
    PRPM fills this gap

We're building the missing piece.

Get Started

For Framework/Library Authors

$ prpm init
# Create migration rules, skills, and agents
$ prpm publish @yourframework/v2-migration

For Enterprises

$ prpm init --private
# Create internal rules and skills
$ prpm publish @company/coding-standards --registry=company.prpm.dev

For Developers

$ prpm install @react/hooks-migration
$ prpm install @stripe/api-v4-migration
# Let AI use these packages to write better code

Ready to build the future?

Get Started View on GitHub

This is the future of software development: Intelligence as code, distributed through packages, applied by AI.