Skills Replace Prompts as the Unit of Reuse

The transition from prompt engineering to agentic engineering is shifting the fundamental unit of value in AI development. For years, organizations hoarded prompt libraries, treating them as proprietary intellectual property. These collections of text snippets were intended to steer language models into performing complex tasks. But prompt libraries never compounded. They were brittle, tightly coupled to specific model versions, and largely unversionable as robust software assets. A prompt is not a capability; it is an incantation.

The new unit of reuse is the agent skill. A skill is a portable, natural-language artifact that packages procedures, domain heuristics, tool policies, output constraints, and failure modes. It acts as the external state for a frozen agent, allowing the agent to adapt and improve without requiring weight updates. This shift fundamentally changes what an engineering organization should be accumulating.

Key takeaways

• Prompt libraries act as brittle incantations that fail to compound across model generations.
• Agent skills serve as portable, optimizable procedures that act as the external state for a frozen agent.
• A text-space optimizer can treat a skill document like a model parameter, proposing bounded edits that are validated against a held-out set.
• Optimized skill artifacts transfer successfully across model scales and execution harnesses, preserving value indefinitely.

The Illusion of the Prompt Library

When you build with prompts, you operate in a zero-sum environment. A prompt that works perfectly on one model version will frequently break when the underlying weights update. The industry spent years cataloging these text snippets, yet because a prompt lacks a structured interface for feedback and iteration, it cannot self-correct. When an edge case fails, a developer must manually intervene, tweaking the phrasing and hoping the change does not regress performance on other tasks.

This fragility stems from the fact that a prompt is inherently stateless and unprincipled. It does not separate the “what” from the “how.” In contrast, when you build with skills, you are creating a durable, versioned asset. A skill document formalizes the procedure. It isolates the domain heuristics and tool policies into a dedicated artifact that an agent can invoke. Because the skill is an explicit artifact rather than a hidden string in a codebase, it can be systematically measured, tested, and optimized.

Treating Text as a Trainable Parameter

As researchers demonstrate, agent skills can be treated as optimizable artifacts rather than static text files. In their work on SkillOpt, researchers introduced a text-space optimizer for agent skills that applies deep-learning principles, like learning rates, validation gates, and momentum, directly to the text documents that guide agents.

This means a skill can self-evolve. Instead of a developer manually tweaking a prompt when an edge case fails, a separate optimizer model analyzes execution trajectories. The target model first runs a rollout batch using the current skill. The optimizer then separates failures from successes and partitions each group into reflection minibatches. This exposes reusable procedural errors, such as an agent consistently searching the wrong source or failing to verify a tool result. The optimizer proposes bounded add, delete, or replace edits to the skill document.

Crucially, it only accepts those edits if they strictly improve performance on a held-out validation set. The deep-learning analogy here is operational, not decorative. The textual learning rate acts as an edit budget that controls how drastically the skill changes in one iteration, preventing catastrophic forgetting of previously learned heuristics. The held-out gate ensures the skill does not overfit to a single trajectory. The skill becomes a living document that gets sharper with every execution, exactly how traditional software optimization works.

The paper’s own checkpoints show this directly: across three benchmarks, the held-out test score climbs as the skill is optimized, not just the training-split score.

Exhibit 1. SkillOpt performance across optimization epochs on three benchmarks: training-rollout, held-out validation-selection, and unseen-test scores all rise as the skill is refined. Source: Yifan Yang, Ziyang Gong, Weiquan Huang, et al. “SkillOpt: Executive Strategy for Self-Evolving Agent Skills.” arXiv:2605.23904v1, 2026, p. 12.

Portability and the New SDLC

This changes the software development life cycle for AI products. In a spec-driven development environment, the capability constraint is no longer the model, but the specification of the procedure. By formalizing these procedures into skills, organizations can decouple the execution engine from the domain knowledge.

If skills are portable, they can be transferred across model scales, execution harnesses, and nearby domains without further optimization. The research evaluated this across six benchmarks, covering QA, spreadsheets, documents, math, and embodied decision making, and seven target models. On GPT-5.5, the text-space optimizer lifted the average no-skill accuracy by +23.5 points in direct chat, by +24.8 inside the Codex agentic loop, and by +19.1 inside Claude Code. The skills optimized in one environment retained their value when moved between radically different execution environments without retraining.

This is a massive leverage point for organizations transitioning to agentic engineering. You aren’t just writing instructions; you are training a procedural asset that retains value regardless of which underlying foundation model you deploy.

What You Should Be Accumulating

If you are an engineering leader, your mandate must shift from curating prompts to curating skills. You should be accumulating versioned, tested, and optimized skill artifacts. These artifacts represent the captured domain knowledge of your organization, formalized into a state that an agent can execute and a system can iteratively improve.

The organizations that win the next decade of software won’t have the best prompts, nor will they necessarily have the most advanced proprietary models. They will have the most refined, compounding libraries of agent skills. The competitive moat lies in the procedures your agents have mastered, not the incantations used to summon them. As part of the broader transition to organizing intelligence to scale, skills are the bedrock asset that makes autonomous agents reliable in production.

References

• Yifan Yang, Ziyang Gong, Weiquan Huang, Qihao Yang, Ziwei Zhou, Zisu Huang, Yan Li, Xuemei Gao, Qi Dai, Bei Liu, Kai Qiu, Yuqing Yang, Dongdong Chen, Xue Yang, and Chong Luo. “SkillOpt: Executive Strategy for Self-Evolving Agent Skills.” arXiv:2605.23904v1, May 2026.
• Tanvi Singhal, Gabriela Hernandez Larios, Debanshu Dus, Lavi Nigam, and Smitha Kolan. “Agent Skills.” May 2026.