Prompt marketplaces distributed text. Skills marketplaces distribute operating behavior.
Sources: agent-dx-cli-scale in jpoehnelt/skills, You Need to Rewrite Your CLI for AI Agents
Author: James Phoenix | Date: March 2026
The Marketplace Pattern Is Back, but the Unit Changed
In early 2023, prompt marketplaces appeared everywhere. The pitch was simple. Someone writes a useful text artifact, someone else copies it, and the buyer gets a temporary productivity boost. That model fit the tools of the time because the prompt was the main portable unit of value.
The important shift is that a skill is not just text for a model to read. It is a packaged operating surface with routing metadata, a narrow scope, and a place in an agent runtime. The user does not merely copy a clever paragraph. They install a capability that the agent can discover later and load only when relevant.
agent-dx-cli-scale Is a Good Example of the New Unit
The agent-dx-cli-scale skill from jpoehnelt/skills is a clean example because it is narrow, operational, and clearly installable.
npx skills add https://github.com/jpoehnelt/skills --skill agent-dx-cli-scale
What gets installed is not a vague idea like “be more agent friendly.” It is a rubric that an agent can apply to any CLI. The skill packages a seven-axis scoring framework:
- machine-readable output
- raw payload input
- schema introspection
- context window discipline
- input hardening
- safety rails
- agent knowledge packaging
As a skill, it becomes a reusable evaluator that can be pulled into a session at the moment a user asks, “How agent-ready is this CLI?” The agent does not need to rediscover Justin Poehnelt’s framework or reconstruct the scoring criteria from memory. The install step converts the framework into a runtime asset.
Why Skills Are Better Marketplace Objects Than Prompts
Prompt marketplaces suffered from a structural problem. A prompt is detached from execution context. The buyer gets a blob of text, but still needs to answer:
- When should this be used?
- When should it not be used?
- What tools is it supposed to call?
- What output shape is expected?
- How does it evolve as the tool or workflow changes?
A good skill answers those questions directly.
That is why runtime skills matter. They sit closer to execution. They include a description that supports routing, a body that encodes procedure, and often constraints that stop the agent from making the same predictable mistakes.
This makes the marketplace object more durable. A prompt ages like a screenshot. A skill ages like code. It can be versioned, updated, diffed, and reinstalled. That means the marketplace is not just curating clever language. It is distributing small pieces of operational infrastructure.
Progressive Disclosure Is Why This Distribution Model Works
The reason skills marketplaces are viable is the same reason agent systems need progressive disclosure. Agents cannot afford to load every possible workflow into base context. They need a lightweight discovery layer up front and full instructions only on demand.
A skills marketplace gives you exactly that architecture:
- the listing page shows what exists
- the skill metadata tells the agent what the skill is for
- the installed file provides the full operating detail when triggered
That is a much cleaner retrieval story than prompt marketplaces ever had. A prompt marketplace asked the human to search manually, choose manually, copy manually, and decide manually when to paste the text. A skills marketplace can hand the agent a directory of capabilities, each with short descriptions, while keeping the heavy instructions dormant until needed.
agent-dx-cli-scale shows this clearly. At browsing time, the marketplace entry says: this skill evaluates CLIs for agent-first design. At install time, the environment gains a reusable evaluator. At runtime, the agent pulls in the scoring details only when the task is about CLI assessment. That is a clean context budget story from discovery to execution.
The Real Economic Change Is Capability Composability
Prompt marketplaces mostly sold one-off cleverness. Skills marketplaces can sell or share composable capability.
That opens a different ecosystem dynamic:
- a tool vendor can ship the canonical workflow for its own product
- an expert can publish a narrow diagnostic rubric like
agent-dx-cli-scale - a team can maintain private skills for internal systems
- users can assemble a stack of specialized capabilities instead of one giant instruction file
The interesting question is no longer “who wrote the smartest prompt?” It is “what small capability should exist as an installable module?”
Many valuable skills will be tiny. A permission-debugging skill. A schema-migration review skill. A postmortem synthesis skill. A “score my CLI” skill. These are not glamorous products, but they compress repeated coordination work into reusable execution surfaces.
What Separates a Real Skill Marketplace from Prompt Slop
The failure mode is obvious. People will wrap thin advice in frontmatter and call it a skill. That will recreate the worst part of prompt marketplaces under a new label.
A real marketplace needs stronger quality signals. The good ones will likely converge on a few criteria:
- a strong description that supports routing
- a narrow, testable use case
- install instructions that actually work
- versioned source in a public repo
- evidence that the skill tracks a real tool or workflow
- guardrails, invariants, or output contracts that reduce agent drift
Standards help here. The agent-dx-cli-scale listing already points toward OpenClaw-style conventions. That matters because the more portable the skill format becomes, the less each marketplace needs to act like a walled garden. The best outcome is not one dominant store. It is a shared packaging model that lets many directories, repos, and CLIs distribute the same capability units.
The Bigger Shift
The core insight is that skills are not documentation and not quite software. They live in between. They are executable knowledge packages.
That middle layer is what prompt marketplaces were missing. Prompts were too loose to be dependable and too detached from runtime to compound cleanly. Skills sit closer to the point of use. They are small enough to distribute like content, but structured enough to behave like infrastructure.
Once that becomes normal, the competitive surface for agent tooling changes too. The best ecosystems will not just expose tools. They will accumulate the best installable workflows around those tools. Discovery, packaging, and routing become part of product quality.
That is the real continuity with the prompt marketplaces of 2023. The desire is the same. People want portable leverage. The difference is that skills are a better container for it.
Related
- Runtime Skills Turn Documentation Into Capability – Why skills outperform static notes at the point of use
- Ship the Prompt – CLIs that distribute their own operational knowledge
- Rewrite Your CLI for AI Agents – The design principles that underpin
agent-dx-cli-scale - Index-First Context Priming Protects Agent Attention – Why discovery plus on-demand loading beats loading everything up front
