Stop Rewriting AI Skills for Every Agent! Use n-skills Instead

Stop Rewriting AI Skills for Every Agent! Use n-skills Instead

What if I told you that every hour you spend porting a Claude Code skill to Cursor, or adapting a Codex prompt for Windsurf, is completely wasted time? Here's the brutal truth most developers haven't realized yet: the AI coding agent landscape is fragmenting faster than mobile OS wars in 2010. Claude Code wants CLAUDE.md. GitHub Copilot demands AGENTS.md. Codex expects SKILL.md. Cursor craves .cursor/rules/*.mdc. And don't get me started on Cline's .clinerules or Windsurf's "Cascade Rules."

Sound familiar? You're not alone. Thousands of developers are trapped in an endless cycle of format translation, path juggling, and "will this even work here?" debugging. Each agent ecosystem is building its own walled garden of skills, plugins, and instructions—and you're paying the price in lost productivity.

But what if there was a single marketplace that just worked everywhere? No rewrites. No compatibility nightmares. No vendor lock-in. Enter n-skills—the curated, universal plugin marketplace created by Numman Ali that's making "write once, run everywhere" a reality for AI agent skills. With native support for Claude Code, Codex, Cursor, Windsurf, Cline, OpenCode, and more, n-skills is the secret weapon top developers are already using to 10x their agent workflows.

Ready to escape format fragmentation hell? Let's dive deep.

What is n-skills?

n-skills is a curated plugin marketplace for AI agents that eliminates the compatibility chaos plaguing modern developer workflows. Created by Numman Ali and open-sourced under Apache 2.0, it serves as a universal distribution hub for skills that work across Claude Code, GitHub Copilot, OpenAI Codex, Cursor, Windsurf, Cline, Factory/Droid, OpenCode, and virtually any agent that reads the emerging AGENTS.md standard.

The project emerged from a simple but painful observation: AI coding agents are evolving at breakneck speed, but each has invented its own skill format, installation mechanism, and discovery protocol. Claude Code uses .claude/skills/ directories. Codex relies on ~/.codex/skills/. Cursor expects .cursor/rules/*.mdc files. This Tower of Babel means a skill built for one agent is useless for another—unless someone manually translates it.

n-skills solves this through three universal pillars:

• SKILL.md — The universal skill format that captures intent, context, and behavior
• AGENTS.md — The universal discovery file now adopted by 20,000+ repositories and natively supported by GitHub Copilot, Google Gemini, OpenAI Codex, Factory Droid, Cursor, and more
• openskills — The universal installer that bridges agent-specific gaps

Unlike generic plugin registries that accept anything, n-skills is deliberately curated. Numman Ali personally reviews submissions, ensuring only high-quality, genuinely useful skills make the cut. This means no abandoned wrappers, no low-effort forks, no compatibility minefields—just battle-tested tools that solve real developer problems.

The repository also features an innovative auto-sync architecture for external skills. Rather than using git submodules (which creator Numman Ali rightly calls "submodule hell"), n-skills pulls from upstream repositories via GitHub Actions, preserving attribution through .source.json files while keeping the curated collection fresh.

Key Features That Make n-skills Insane

Let's break down what makes n-skills genuinely different from any other skill distribution approach:

Universal Agent Compatibility The core superpower. n-skills doesn't favor one agent—it embraces all of them. Native plugin support for Claude Code. Direct AGENTS.md reading for GitHub Copilot and Factory/Droid. Universal installer bridging for Cursor, Windsurf, Cline, and Amp Code. When new agents emerge, the open standard foundation means they can plug in immediately.

Curated Quality Gate This isn't npm with its 2 million packages of varying quality. Every skill in n-skills is vetted for: genuine problem-solving utility, clean well-documented code, active maintenance, and real value-add over trivial wrappers. Submit via GitHub issue, get approved, then PR. The bar is intentionally high.

Dual Installation Pathways Choose your adventure. Claude Code users get native /plugin commands. Everyone else gets openskills—the universal CLI installer that works across all agents. Or mix both. The philosophy is "your choice, your workflow."

Auto-Sync External Skills External contributions stay fresh without manual intervention. A daily GitHub Actions cron job syncs upstream changes, maintaining attribution via embedded .source.json metadata. You maintain ownership in your repo; n-skills curates the collection.

Open Standards Foundation Built on agentskills.io format specification and the AGENTS.md discovery protocol—real open standards with 20,000+ repository adoptions and growing industry backing. Not a proprietary format that locks you in.

Category-Organized Discovery Skills organized into workflow, tools, development, productivity, automation, data, and documentation categories. Find what you need without drowning in miscategorized noise.

MCP Integration Ready Skills like zai-cli expose capabilities via Model Context Protocol (MCP), enabling sophisticated tool use patterns that go far beyond simple prompt templates.

Real-World Use Cases Where n-skills Dominates

1. Multi-Agent Team Orchestration

You're running Claude Code for architecture, Codex for implementation, and Cursor for code review. Without n-skills, you'd maintain three separate skill sets. With orchestration@n-skills, you define multi-agent workflows once using cc-mirror tasks and TodoWrite patterns, then deploy across your entire agent fleet. The skill handles handoffs, state persistence, and task decomposition automatically.

2. Open Source Project Maintenance at Scale

Maintaining popular open source repos is brutal: issue triage, PR review, release notes, dependency updates, contributor management. The open-source-maintainer@n-skills skill provides end-to-end GitHub repo maintenance automation. Install once, run everywhere—whether your primary agent is Claude Code in terminal or Copilot in VS Code.

3. Browser Automation with Persistent State

Testing web applications across agents? The dev-browser@n-skills skill (synced from SawyerHood) provides browser automation with persistent page state. Start a session in Claude Code, continue debugging in Cursor, hand off to Codex for fix implementation—all without losing context or rebuilding session state.

4. Multi-Modal AI Capabilities via CLI

Need vision analysis, web search, document reading, and GitHub exploration in your agent workflow? The zai-cli@n-skills skill wraps Z.AI capabilities into an MCP-accessible tool. Claude Code with Opus becomes a multi-modal powerhouse. Codex gains internet search. Cursor can read and analyze images. One skill, infinite agent upgrades.

5. Gastown: Advanced Multi-Agent Orchestration

For teams pushing the boundaries, gastown@n-skills (optimized for Claude Code + Opus) provides sophisticated multi-agent orchestration patterns. Think: autonomous coding teams with specialized roles, parallel task execution, and intelligent result aggregation. This isn't demo-tier; it's production-grade agent coordination.

Step-by-Step Installation & Setup Guide

Prerequisites

• Node.js 18+ (for openskills universal installer)
• Claude Code, Cursor, Codex, or compatible agent installed
• GitHub account (for submitting skills or contributing)

Method 1: Claude Code Native (Fastest for Claude Users)

Add the n-skills marketplace to your Claude Code installation:

# Register the marketplace in Claude Code's plugin system
/plugin marketplace add numman-ali/n-skills

Install individual skills using the @n-skills namespace:

# Install workflow orchestration capabilities
/plugin install orchestration@n-skills

# Install open source maintenance automation
/plugin install open-source-maintainer@n-skills

# Install browser automation with persistent state
/plugin install dev-browser@n-skills

# Install multi-agent orchestrator (best with Opus)
/plugin install gastown@n-skills

# Install Z.AI vision/search/reader tools via MCP
/plugin install zai-cli@n-skills

Claude Code automatically resolves, downloads, and activates these skills in your environment.

Method 2: OpenSkills Universal Installer (Works with EVERY Agent)

This is the secret weapon for cross-agent teams. Install openskills globally:

# Install the universal skills installer via npm
npm i -g openskills

Add n-skills as your marketplace and sync:

# Register n-skills marketplace in openskills
openskills install numman-ali/n-skills

# Synchronize all skills to your local agent environment
openskills sync

The sync command generates appropriate AGENTS.md entries and agent-specific configuration files. Cursor gets .cursor/rules/. Windsurf receives Cascade Rules. Cline sees .clinerules. All from one command.

New to OpenSkills? It's the universal bridge. Learn more →

Method 3: Codex Native Installation

For OpenAI Codex users, use the skill installer directly:

# Install specific skill from n-skills repository
$skill-installer https://github.com/numman-ali/n-skills/tree/main/skills/tools/zai-cli

Environment Verification

After installation, verify your setup:

# Check openskills version and configured marketplaces
openskills --version
openskills list

# For Claude Code, list active plugins
/plugin list

Skills appear in your agent's context automatically. No manual path configuration. No format translation. It just works.

REAL Code Examples from the Repository

Let's examine actual implementation patterns from n-skills, showing how universal compatibility works under the hood.

Example 1: Claude Code Marketplace Configuration

The .claude-plugin/marketplace.json file defines how Claude Code discovers and installs skills from n-skills:

{
  "name": "n-skills",
  "description": "Curated marketplace for universal AI agent skills",
  "repository": "https://github.com/numman-ali/n-skills",
  "skills": [
    {
      "id": "orchestration",
      "name": "Multi-Agent Orchestration",
      "category": "workflow",
      "entry": "skills/workflow/orchestration/skills/orchestration/SKILL.md"
    },
    {
      "id": "open-source-maintainer", 
      "name": "Open Source Maintainer",
      "category": "workflow",
      "entry": "skills/workflow/open-source-maintainer/skills/open-source-maintainer/SKILL.md"
    }
  ]
}

What's happening here? This JSON registry maps human-readable skill IDs to their SKILL.md entry points. Claude Code's plugin system parses this to provide the /plugin install command completion. The entry field uses a consistent skills/{category}/{name}/skills/{name}/SKILL.md path convention that mirrors the repository structure we'll see next. Notice how this is purely declarative—no executable code, just metadata that enables discovery.

Example 2: Repository Structure for Universal Skill Packaging

The skills/tools/zai-cli/ directory demonstrates how n-skills packages skills for multi-agent consumption:

skills/tools/zai-cli/
├── .claude-plugin/           # Claude Code-specific metadata
│   └── plugin.json           # Plugin manifest for Claude's system
├── skills/zai-cli/           # Universal skill content
│   ├── SKILL.md              # The universal format: behavior, context, examples
│   └── .source.json          # Attribution: upstream repo, author, license
└── README.md                 # Human documentation

The genius of this structure: Each skill maintains both agent-native packaging (.claude-plugin/) and universal content (skills/{name}/SKILL.md). When openskills processes this, it reads SKILL.md for the core behavior definition, then generates appropriate wrappers for target agents. The .source.json preserves provenance:

{
  "upstream": "https://github.com/numman-ali/zai-cli",
  "author": "numman-ali",
  "license": "Apache-2.0",
  "synced_at": "2025-01-15T00:00:00Z"
}

This dual-structure means Claude Code users get native performance, while everyone else gets seamless translation—without maintaining separate repositories.

Example 3: External Skill Sync Configuration

The sources.yaml file controls how upstream skills are integrated:

# External skill manifest - defines auto-sync sources
sources:
  - id: dev-browser
    category: automation
    upstream: https://github.com/SawyerHood/dev-browser
    # Sync only the skills/ directory from upstream
    source_path: skills/dev-browser
    # Target location in n-skills repo
    target_path: skills/automation/dev-browser
    # Sync schedule (daily via GitHub Actions cron)
    sync:
      frequency: daily
      preserve_attribution: true

Why this matters: This declarative approach eliminates "submodule hell." Instead of git submodules that require special handling in every tool, n-skills uses GitHub Actions to run scripts/sync-external.mjs daily. The sync engine:

1. Clones upstream repositories
2. Extracts specified source_path directories
3. Injects .source.json attribution files
4. Places content in target_path locations
5. Commits changes with upstream version references

The scripts/sync-external.mjs implementation handles edge cases: upstream restructures, deleted files, license changes, and merge conflicts. This is production-grade automation, not a naive git clone wrapper.

Example 4: GitHub Actions Auto-Sync Workflow

The .github/workflows/sync-skills.yml implements the daily synchronization:

name: Sync External Skills

on:
  schedule:
    # Run daily at 00:00 UTC
    - cron: '0 0 * * *'
  # Allow manual trigger for urgent updates
  workflow_dispatch:

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run sync engine
        run: node scripts/sync-external.mjs
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      
      - name: Update registry
        run: node scripts/update-registry.mjs
      
      - name: Commit changes
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add -A
          git diff --quiet && git diff --staged --quiet || git commit -m "chore: sync external skills [skip ci]"
          git push

Production details to notice: The workflow_dispatch enables manual triggers for security patches. The GITHUB_TOKEN provides API access for private upstreams (if configured). The idempotent commit logic (git diff --quiet) prevents empty commits. The [skip ci] in commit messages avoids infinite CI loops. This is battle-tested automation engineering.

Advanced Usage & Best Practices

Skill Composition Patterns Don't install skills in isolation. The orchestration skill is designed to coordinate others. Install orchestration + zai-cli + dev-browser to create autonomous research-to-implementation pipelines. The orchestration skill's cc-mirror task pattern handles context passing between capabilities.

Opus-Optimized Workflows The gastown skill specifically targets Claude Code with Opus. If you're using Sonnet or Haiku, expect degraded performance. Match skill complexity to model capability. For lighter models, prefer orchestration over gastown.

Custom Skill Development Follow the docs/skill-format.md specification. Key requirements: SKILL.md must include clear trigger conditions, context requirements, example interactions, and failure modes. Test across at least two agents before submitting.

AGENTS.md Discovery Optimization Place AGENTS.md in repository root for maximum compatibility. GitHub Copilot and Factory/Droid read it directly. openskills generates it automatically, but manual curation improves discovery precision.

Version Pinning for Stability For production teams, fork n-skills and disable auto-sync for critical skills. Pin to known-good versions. The upstream sync is convenient for individuals; enterprises need reproducibility.

Comparison with Alternatives

Why n-skills wins: It's the only solution combining universal coverage, quality curation, automated freshness, and genuine open standards. Agent-specific stores lock you in. Submodules multiply your maintenance surface. Manual approaches don't scale. Generic package managers lack agent-native integration.

FAQ

Q: Does n-skills work with my custom AI agent? A: If your agent reads AGENTS.md or you can install openskills, yes. The open standard foundation means new agents integrate automatically.

Q: How is this different from just using git submodules? A: Submodules require every consumer to handle recursive cloning, path resolution, and version management. n-skills' sync engine flattens this to simple files that work with every installer. As the README notes: "submodule hell is real."

Q: Can I submit my existing skill without rewriting it? A: Yes, if it follows basic SKILL.md structure. The curation review checks quality, not format purity. Minor restructuring may be requested.

Q: Is n-skills free for commercial use? A: Absolutely. Apache 2.0 licensed. Use in personal, commercial, and enterprise contexts without restriction.

Q: How quickly do external skills update? A: Daily automated sync via GitHub Actions. Critical security updates can be manually triggered via workflow_dispatch.

Q: What's the difference between n-skills and openskills? A: n-skills is the curated marketplace (the "store"). openskills is the universal installer (the "package manager"). You need both for full cross-agent functionality.

Q: Will this slow down my agent? A: No. Skills are loaded on-demand based on context triggers. The SKILL.md format is designed for efficient parsing.

Conclusion

The AI agent fragmentation problem isn't going away—it's accelerating. Every month brings new agents with new formats, new directories, new expectations. You can chase each one individually, burning hours on translation and maintenance. Or you can join the growing community of developers who've discovered n-skills as their escape hatch.

This isn't just convenience; it's strategic positioning. By building on open standards (AGENTS.md, agentskills.io, SKILL.md), n-skills insulates your skill investments from vendor churn. Skills you write today will work with agents that don't exist yet. That's genuine future-proofing.

The curation model matters too. In a world of AI-generated noise, human judgment about quality and utility becomes more valuable, not less. Numman Ali's deliberate gatekeeping means you spend time using skills, not evaluating them.

My recommendation? Install openskills today. Add n-skills. Sync once. Experience what universal agent compatibility feels like. Then contribute back—submit that skill you've been maintaining privately. The ecosystem grows stronger with every quality addition.

The future of AI agent development is interoperable, curated, and open. n-skills is already there. The only question is whether you'll join before your competitors do.

👉 Star n-skills on GitHub — and never rewrite a skill format again.

Built for developers who value simplicity. Apache 2.0 · Made by @numman-ali