Essay
The two halves of the engine: how a skill is authored, step by step, and how the raw library is configured to a function’s deployed tools and real process via its fit-points.
9 June 2026 · 7 min read · Binu Chacko
Situation
Skill catalogs grow weekly; anyone can publish one.
Complication
Raw skills are generic — value only appears when one is fitted to your stack and measured, and nobody shows that step.
The question
“What turns a catalog entry into a result?”
The answer
The fit discipline: baseline the number, adapt the skill at named fit-points, measure after — the case studies are this loop, worked.
The library holds 1,000+ skills — but a raw skill is not the deliverable. It is raw material: a generic procedure that, dropped into a function unchanged, can perform worse than the team’s own code. Value appears only when one or two skills are fitted to a function’s real tools and process and the change is measured. This piece explains both halves: how a skill is built, and how it is configured to your function.
A skill is a single Markdown file (SKILL.md) — not an essay, but an executable procedure an analyst or an AI agent loads and runs. It states when to use it, what it needs, the workflow to follow, how to verify the result, and the framework controls it satisfies. Structured units of senior expertise — how to triage a class of alert, enrich an indicator, extract evidence, draft an incident report to a senior standard — that a junior analyst or an agent can execute repeatably.
Name the trigger
The ## When to Use section and the descriptionfield, written as “when would someone ask for this?” If the trigger is vague, the skill never fires — this is the most-edited line.
State prerequisites
## Prerequisites — the access, data and tooling the procedure assumes are already in place.
Write the workflow
## Workflow (or ## Instructions) — the senior-standard steps, specific enough that the output is consistent across operators.
Add verification
## Verification — how to confirm the output is correct. This is the line between a draft and a deliverable, and it is required for skills the practice authors itself.
Map it to the frameworks
Frontmatter refs — aicm_domain, aicm_controls, aismm_category, nist_ai_rmf, mitre_attack / atlas. This is what lets a skill satisfy a named control objective — and therefore move a grade.
Declare the fit-point interface
fit_points[] — the named places the generic core must be adapted to a client, each with an id, label, kind, a required flag and a generic default. This is the skill’s configuration surface — the contract that makes “fit, don’t replace” mechanical rather than aspirational.
Validate before publishing
validate-skill.py checks frontmatter, the body section order and the fit-points schema. Only skills that pass are published and counted.
The deliverable is the fit, never the raw skill.
On the StoryBond case, the off-the-shelf jailbreak-detection skill — used unfitted — scored 0–2 of 15, worse than the app’s own shipped guard (8/15). Fitting its own guard to the seven named attack classes took it to 15/15. Same raw material; the configuration is what moved the number. That is why counts and coverage are never the headline — a thousand unfitted skills are inventory, not capability.
Every fit-point carries a kind. Configuring a skill to a function means binding each one to that function’s reality — the tools it has deployed and the process it actually follows:
Fitting a monitoring skill to a Splunk-based security operations center (SOC) means supplying its fit-points: the Splunk deployment type (environment), the security index names (environment), Common Information Model (CIM) data-model availability (data-source) and the threat-intel lookup tables (data-source). The same skill fitted to a different SOC — different products, different indices, different process — is a different configuration. The template never ships as-is.
Diagnose
Baseline the function with the AI Consensus Assessments Initiative Questionnaire (AI-CAIQ) attestation and place it on the AI Security Maturity Model (AISMM) Initial→Efficient scale — an evidence-backed starting position, not a self-reported score.
Prescribe
Select one or two skills with the highest effort-to-impact ratio — never by coverage, never the whole catalogue.
Fit
Bind the fit-points to the function’s deployed tools and real process. The deliverable is this configuration.
Measure
Run the workflow skills-off versus skills-on on the function’s own data, and record a task-level before/after.
Mature
Use the measured gain to move the function up its grade, then repeat the loop on the next gap. Capability you keep — not a dependency you rent.
Until that before/after is run on your own data, the numbers are modeled, not measured. The worked Security Operations figure (per-incident 26–65 min → 13–28 min) is a modeled projection from the methodology, not a measured client engagement.
See the loop deployed end-to-end to a function in Engage, and the configuration run on a real app — one guard, one before-and-after — in the StoryBond case study.
← Newer essay
What Claude Mythos Means for Your Security Program
Older essay →
The AICM Coverage Assessment
Subscribe for the next essay.