An API tells an agent what it can call, but not how your team gets a job right. Skills package that missing procedure in a folder whose details load only when needed. The format becomes practical by choosing reliable triggers, separating steps from reference material, preferring constraints to a procedural novel, and using scripts when a step should be deterministic. Cursor's worktree rewrite tests the provocative case for moving product behavior from thousands of lines of code into instructions, including the isolation failures that follow. Langfuse and Supabase make maintenance concrete: product documentation has to keep pace with the product, and an eval can be wrong even when the skill is right. Regression tests come next, followed by retrieval, ownership and versioning when one useful folder grows into shared infrastructure.
Why first: Aghammadzada explains why APIs, tools and human documentation still leave an agent without the workflow knowledge needed to use a platform well. Skills fill that gap through progressive loading. Pocock follows with the practical question: what makes one of those folders good enough for the model to find and follow?
Why here: Aghammadzada defines the gap and the progressive-loading pattern. Pocock turns that pattern into an editing checklist for triggers, structure, steering and pruning, then Nisi and Proser put the same choices into a complete build-and-test walkthrough.
Why here: Pocock supplies compact rules for a skill file. Nisi and Proser show the surrounding work: package references and scripts, share the folder across agents, and compare runs with and without it. Gomes then tests a more radical use for the format, replacing a large implemented feature with instructions.
Why here: Nisi and Proser treat skills as portable additions to an agent. Gomes moves product behavior into them, deleting thousands of lines while accepting that prompt-based isolation is weaker than code-enforced boundaries. Klingen follows with a less dramatic but more common maintenance problem: product knowledge goes stale.
Why here: Gomes shows the leverage and the new failure modes that appear when behavior moves into a skill. Klingen shows how to maintain one against a changing product: inspect traces, point to living documentation, and resist an optimizer that rewards short runs at the expense of current information. Rodrigues then tests the same approach against a product rule whose absence can expose data.
Why here: Klingen keeps changing product knowledge outside the skill and measures whether the agent fetches it. Rodrigues adds a rule that cannot be missed, then catches his own evaluator checking the wrong database metadata. Schmid follows by turning those hard-won lessons into a smaller, repeatable test discipline.
Why here: Rodrigues shows both a skill changing agent behavior and a grader misreading the result. Schmid generalizes the method into positive and negative trigger cases, isolated trials, cheap assertions and ablation tests. Miraje then asks what changes when skills become the main feature layer of a harness.
Why here: Schmid gives one skill a lifecycle through evaluation and retirement. Miraje scales that discipline to a skill-centric harness, where descriptions route tasks and a growing registry needs retrieval and governance. Touil widens the same argument from one harness to an organization with many teams and workflows.
Why last: Miraje explains why a skill-centric harness needs retrieval and governance. Touil shows what that demand becomes across many teams: a searchable catalog, dependencies, versions, access controls, evaluation, observability and named owners. The pack ends where a useful personal technique becomes shared infrastructure with a maintenance bill.