When an AI rewrites its own how-to notes, why do vague, wordy advice turn into concrete step-by-step instructions?

This explores why, when an AI system rewrites its own library of agent skills (reusable how-to documents), the entries drift from broad, wordy descriptions toward concrete execution logic. No note in the corpus answers the "why" head-on. Several point at the same mechanism, though: the rewriting is judged by whether the agent's actions improve, and only concrete procedure changes actions.

The direct observation comes from SkillOS. A trainable curator, kept separate from a frozen executor, learns to move a skill repository away from "generic verbose additions" and toward actionable execution logic and cross-task meta-strategies (Can a separate trained curator improve skill libraries better than frozen agents?). The curator is rewarded on how the executor performs, not on how good a description reads. SkillOpt applies the same pressure more bluntly. It treats the skill document like model weights and accepts an edit only if it improves held-out performance (Can skill documents be optimized like neural network weights?). Text that doesn't change what the agent does gets filtered out.

Execution-oriented content survives because of what skills actually do. An analysis of 8,135 trials found that skills mostly work as procedural anchors, which stabilize the agent's actions. That accounted for 65.7% of skill cases, against 4.5% for injecting missing knowledge (Do skills teach procedures or inject missing facts?). A generic description tells a capable model nothing it didn't already know, while a concrete procedure gives it something to follow. The same note also explains why the meta-strategies show up. Skills fail when they're invoked out of context or followed too rigidly, so mature skills need guidance on when to apply them as well as how. An adjacent result points the same way. Models tuned on deliberately wrong or empty instructions performed about as well as those trained on correct ones, because what transfers is the shape of the output, not the semantic gloss (Does instruction tuning teach task understanding or output format?). Descriptive prose carries less usable signal than it appears to.

The same pull toward specifics appears in related work. Agent Workflow Memory extracts routines at sub-task level and strips out example-specific values. The gains grow as the gap between training and test tasks widens, so procedure at the right granularity is what transfers (Can agents learn reusable sub-task routines from past experience?). The generic end is the default resting place when nothing pushes back. When reward variance is low, policies collapse into input-agnostic templates (Why do language models collapse into generic templates?). Generic skill text looks like the same kind of collapse, and execution-level detail is what a real performance signal pulls out of it.

Two notes complicate the picture. Code2Skill skips the evolution entirely by lifting skills from source code, so they start out executable and carry their evidence with them (Can source code replace experience as skill raw material?). And evolving a good harness is a measurable skill in its own right. Models struggle to keep useful intermediate updates, and results shift sharply with the executor, so downstream scores alone can't tell you whether an evolved skill is good (Can language models build and maintain their own agent harnesses?). SkillOS is the counterweight here: its trained curator generalizes across executor backbones, which suggests the drift toward execution logic isn't tied to one model.