Self-Improving AI: How PRPM Teaches AI Assistants to Get Better at Their Job

Imagine an AI assistant that recognizes "I'm working on Pulumi infrastructure—let me check if there's an expert package for this" and installs it automatically. That's shipping today.

You ask your AI assistant to help with AWS infrastructure. Before it starts, it analyzes your project, searches PRPM, finds an official Pulumi package, and asks: "Should I install this to help with your task?" You approve, and it immediately applies patterns from developers who've built production Pulumi stacks.

This is the self-improving skill—PRPM's answer to AI assistants that can actively acquire expertise when they need it.

Watch It In Action

Here's what it looks like when your AI assistant recognizes it needs specialized knowledge:

Watch the full video on YouTube →

Notice what just happened: Cursor analyzed the project description, identified it was building a Hacker News app with React and TypeScript, searched the PRPM registry for relevant packages, and offered to install them. The entire flow took seconds.

The Problem: AI Assistants Don't Know What They Don't Know

Current AI coding assistants are impressive generalists. They can write React components, debug Python, and help with SQL queries. But they're also limited by their training data and base knowledge.

When you ask an AI assistant to help with a specialized task—say, setting up GitHub Actions workflows or optimizing Kubernetes manifests—it gives you generic advice based on general patterns. It doesn't know about your team's conventions, the latest best practices from the community, or the hard-won lessons from developers who've solved these exact problems.

The knowledge exists. It's scattered across GitHub repos, blog posts, and internal docs. But there's no mechanism for the AI to discover and apply it when needed.

The Solution: Self-Improvement Through Package Discovery

PRPM's self-improving skill teaches AI assistants to recognize knowledge gaps and fill them automatically. It's a meta-skill: a skill that helps the AI acquire other skills.

How It Works

The self-improving skill follows a simple workflow:

1. Project Analysis: Your AI assistant analyzes your project content and task description for domain-specific context (aws, pulumi, terraform, react, playwright, etc.)
2. Automatic Search: It searches the PRPM registry for relevant expertise packages
3. Quality Filtering: It evaluates packages based on download counts, official status, and relevance
4. User Permission: It presents the top packages and asks for your approval
5. Installation & Application: Once approved, it installs the package and immediately applies that knowledge to your task

The entire process is transparent. You see what your AI is thinking, what it found, and why it's suggesting specific packages.

The Technical Approach

The self-improving skill is implemented with intelligent triggering logic that works across AI coding assistants. Here's what makes it work:

Context Detection

The skill activates when your AI assistant detects domain-specific context in your project or request:

Confidence-Based Filtering

Not all packages are equal. The self-improving skill uses a confidence system to decide what to suggest:

Installation Command

When you approve a package, your AI assistant runs:

prpm install @prpm/pulumi-infrastructure --as cursor

The --as flag tells PRPM to install the package for your specific AI tool. This means:

• The package gets converted to your tool's format automatically
• It's installed in the right directory (e.g., ~/.cursor/rules/, ~/.claude/skills/)
• Your AI can immediately load and use the new knowledge

Use Cases: When Self-Improvement Shines

The Broader Vision: Distributable Intelligence

The self-improving skill is more than a neat feature. It's a glimpse into how software knowledge will be shared in the AI era.

From Documentation to Executable Knowledge

Traditional software distributes libraries (npm, pip) and documentation separately. There's always been a gap: how do you share patterns and domain expertise in a way that's both discoverable and executable?

PRPM fills that gap with executable knowledge packages that AI assistants can discover when needed, apply automatically, version-control, and use across different tools.

Getting Started

Installing the self-improving skill takes less than 60 seconds:

# Install PRPM CLI
npm install -g prpm

# Install the self-improving skill for Claude
prpm install @prpm/self-improving --as claude

# Or for Cursor
prpm install @prpm/self-improve-cursor --as cursor

# Or for other tools
prpm install @prpm/self-improve-windsurf --as windsurf
prpm install @prpm/self-improve-continue --as continue

Once installed, the skill activates automatically when you work on infrastructure, testing, deployment, or framework-specific tasks.

Trying It Out

Start a conversation with your AI assistant about infrastructure, testing, or framework-specific tasks. Watch it analyze your project context, search PRPM, and suggest relevant packages. The quality of assistance improves immediately.

Privacy and Control

Self-improvement happens transparently and with your control:

• Local searches: All package searches happen locally—no data sent to PRPM servers
• Explicit approval: Your AI always asks permission before installing packages
• Full transparency: You see exactly what was found and why specific packages are being suggested
• Reversible: You can uninstall packages anytime with prpm uninstall

Download tracking only happens on installation, and no personal data is collected.

What's Next

The self-improving skill is just the beginning. We're working on:

• Learning from outcomes: Track which packages were most helpful and surface them more prominently
• Contextual collections: Suggest entire collections for common scenarios ("You're building a startup MVP? Here are 15 packages that will help")
• Cross-project learning: Let AI assistants remember which packages worked well and proactively suggest them in similar contexts
• Community curation: Surface packages that developers with similar workflows found valuable

The goal is simple: AI assistants that get continuously better at their job by learning from the community.

Why This Matters

AI assistants are impressive generalists but limited specialists. The self-improving skill changes that—it lets them acquire deep, specialized knowledge on demand from real developers solving real problems.

This creates a positive feedback loop: when developers package their expertise (optimizing Kubernetes, building resilient CI/CD), every AI assistant can learn from it. Better packages lead to better AI assistance, which helps build better software, which gets packaged and shared, making AI assistants even more capable.