Agent Skills for Internal Operations: Turning SOPs Into Skills That Actually Trigger
An operations team spends a week converting its supplier onboarding SOP into an agent skill. The folder is tidy, the description reads well, and the pilot looks fine. Then the questions start. The assistant still forgets the rule that every new supplier needs two quotes on file. It loads the skill for a supplier question one day and ignores it the next. And after someone edits the skill to fix a bank-detail step, nobody can say which version answered last Tuesday's request.
The skill itself was written well enough. The problems come from three decisions that most agent skills guides skip: which parts of an SOP belong in a skill at all, how you know the skill fires, and who sees a new version when. This guide covers those three, using the open Agent Skills format and the documented behavior of Claude, where most teams start.
What agent skills guides already cover
The Agent Skills specification defines a folder with a SKILL.md file whose frontmatter carries a required name (up to 64 characters) and description (up to 1,024 characters), plus optional fields such as metadata. It loads in stages: about 100 tokens of name and description for every installed skill at startup, the full instructions (under 5,000 tokens recommended, and SKILL.md under 500 lines) when the skill activates, and scripts or reference files only when needed. Anthropic's engineering post explains why: the agent sees every skill's name and description first and decides from those alone.
The layer comparisons are settled as well. ConvOps separates the layers well: a skill carries knowledge, an MCP server carries access, and a workflow engine carries order and approval gates, because "a sentence in a skill cannot hold an approval." MCPOrbit draws the same line between what an agent knows and what it can do. Microsoft's Agent Framework documentation compares skills with workflows on control, checkpointing, and side effects.
For authoring, the AWS DevOps Agent guidance separates always-on instructions from on-demand skills, shows a description that failed to fire and the fix, structures procedures as decision steps, and names the failure modes that follow: conflicting skills, overlapping scope, rigid steps, and skill rot, with a last_verified comment and a quarterly review as the remedy. If you have not read those, start there. This guide picks up where they stop for a team converting business SOPs.
Sort every SOP line before you write a skill
An SOP is not one thing. A typical one mixes three kinds of content, and each belongs in a different place.
One-line house rules. "Every new supplier needs two quotes on file." "Never share bank details over chat." These are short, unconditional, and apply to many requests. They are also the content most likely to be lost inside a skill.
Keep one-line house rules out of skills, because Claude consults a skill only for tasks it cannot easily handle on its own, so a simple one-step rule may never load even when its description matches. Anthropic's own skill-creator skill says so: simple, one-step queries may not trigger a skill even if the description matches perfectly, and Claude tends to undertrigger skills in general. A rule that matters on every supplier request should sit in the always-on instruction layer your client provides (a project instruction, an organisation instruction, or an AGENTS.md style file), which is where the AWS guidance puts content that must always apply.
Multi-step judgment procedures. "How to assess a new supplier's risk tier." "How to reconcile a disputed invoice." These have several steps, branch on conditions, and need reference material such as a scoring table or a template. A skill fits this content well, because the agent only needs the procedure when the task comes up, and the staged loading keeps the reference files out of context until then.
Triggers, approvals, and system writes. "When a supplier is approved, create the vendor record in the ERP." "Payments above the threshold need finance sign-off." Each needs a fixed trigger, a durable approval record, and code that checks permissions before acting. A skill can tell the agent that an approval exists; it cannot enforce one. Put these steps in a workflow with an explicit gate, as covered in our guides on deterministic fallbacks and binding human approval to exact actions. If the skill needs a tool to reach the ERP, the access side belongs to an MCP server, and our guide on securing MCP servers covers that layer.
A worked example: supplier onboarding
Here is how one supplier onboarding SOP splits:
| SOP line | Where it goes | Why |
|---|---|---|
| Two quotes on file for every new supplier | Always-on instruction | One line, applies to every supplier request |
| Never accept bank details by chat or email reply | Always-on instruction | One line, safety rule |
| Assess risk tier from country, spend, and data access | Skill | Branching procedure with a scoring table |
| Check sanctions and company registry | Skill, with a script | Repeatable steps, reference links |
| Draft the onboarding request for the requester | Skill | Template and tone guidance |
| Finance sign-off above the spend threshold | Workflow gate | Needs a recorded approval |
| Create the vendor record in the ERP | Workflow step | System write with permission checks |
| Notify procurement when the record is live | Workflow step | Fixed trigger |
The skill that remains is smaller than the SOP. It holds the judgment, the agent loads it when a supplier assessment comes up, and the parts that must always happen are no longer depending on whether it loaded.
Write the description as trigger conditions
Once you know what goes into the skill, the description decides whether it is ever used. The Claude skill authoring best practices say the description is critical for selection because the agent may be choosing among 100 or more skills, and recommend writing it in the third person, stating both what the skill does and when to use it. The skill-creator guidance goes further and recommends making descriptions a little "pushy" to counter undertriggering.
For internal SOPs, the most useful habit is to write the description from the requests your team actually sends, not from the SOP's title. "Supplier onboarding procedure v3" tells the agent nothing. Compare:
name: supplier-risk-assessment
description: >
Assesses a new or changing supplier and assigns a risk tier using country,
annual spend, and data access. Use when someone asks to onboard, approve,
add, or review a supplier or vendor, asks what checks a supplier needs,
or shares a supplier's details for sign-off.
metadata:
owner: procurement-ops
version: "2026-10-12.1"
source_sop: "SOP-PROC-014 rev 7"
last_verified: "2026-10-12"
Pull the trigger phrases from real requests: the help desk queue, the procurement channel, or past tickets. Quote the description, or use a block scalar as above, if it contains a colon, because an unquoted colon followed by a space can break YAML parsing of the frontmatter.
Test triggering in a realistic workspace
Anthropic's guidance is to build evaluations before writing extensive documentation, starting with three scenarios, and to test with every model you plan to use. It also notes that there is no built-in way to run these evaluations, so you need the skill-creator's scripts or a harness of your own. The skill-creator's method is sound: about 20 trigger queries, roughly half that should trigger and half that are near misses that should not, each run several times.
For the supplier skill, "Can you add Acme as a supplier?" should trigger, but so should "Acme sent their details, what do we need from them?" A near miss that should not trigger might be "What's our spend with Acme this year?", which is a reporting question. Without the near misses, a description that fires on every message mentioning a supplier will look perfect.
The measuring tool can also be wrong. Check the trigger measurement before you rewrite a description, because open issues on Anthropic's own evaluation harness report 0% trigger rates, one of them for descriptions that do trigger, and trigger rate depends on the test workspace looking like a real project. Issue 556 on the anthropics/skills repository reports 0 of 3 triggers on every query across 144 queries for eight skills. Issue 1559 traces three causes in the harness: an early non-skill tool call (such as a quick directory listing) ended the run before the skill could fire, a different skill firing first ended it too, and parallel runs shared one directory, so the model saw several near-identical candidate skills. One query scored 100% run serially and 0% with four workers. The same reporter found that a rebase skill scored 0% in an empty directory and 100% in a real repository. Both issues are user reports and were still open when we checked on 2026-11-18, with a proposed fix not yet merged.
Practitioners report the same unreliability in daily use. Scott Spence found skills often did not auto-activate in Claude Code, and the first workaround, a hook that prompts activation, worked in roughly half of 20 test sessions. It is one author's report from 20 sessions, and it points the same way as the harness issues.
So treat a trigger score as a claim to check:
- Run the test in a workspace that looks like the real one: the project files, the instruction file, and the other skills your users have installed.
- Run cases one at a time before you trust a parallel run.
- Read a sample of transcripts for every 0% and every 100% result. A 0% where the agent spent its first step listing files is a harness problem, not a description problem.
- Only then rewrite the description, and keep the before and after scores with the change.
If the skill reaches internal systems, add the trigger set to your regression suite, as described in our guide to AI workflow regression testing, so a model or client update that changes triggering shows up as a failed test rather than a support ticket.
Roll out versions on purpose
On a single laptop, a skill is a folder you can edit. In an organisation, it becomes a shared asset with its own release behavior, and the defaults are worth reading before you upload anything.
The Claude Help Center article on organisation skills describes the behavior for Team and Enterprise plans. A skill an owner uploads is provisioned to all users immediately and enabled by default; users can switch it off for themselves. Enterprise plans can scope skills to groups through plugins. The default publishing policy depends on the plan: "Open" on Team plans; on Enterprise, "Open" where skill and plugin security scanning is on and "Requires review" otherwise. Under review, the reviewer approves a fixed version. Once a new version is approved, it reaches everyone automatically, and a skill shared directly with colleagues updates for them the next time they use it. The audit log captures share events but not the contents of the skill.
For internal operations, keep the reviewed skill source and its diff history in your own repository and pilot each new version with a group, because in a Claude organisation an approved new version reaches every user automatically and the audit log records share events, not skill contents. The platform will tell you that a skill was shared and when. It will not tell you what the supplier procedure said on the day a payment went out.
A rollout sequence that holds up:
- Source in a repository. The SKILL.md, scripts, and reference files live in version control, with the SOP owner as a required reviewer. The repository, not the admin console, is the record of what each version said.
- Version in metadata. Put a version string, the source SOP revision, and a
last_verifieddate in themetadatafield, as in the example above, so anyone reading the skill can match it to a commit. - Test on your own account first. The Help Center recommends this before provisioning. Run the trigger set there.
- Pilot with a group. On Enterprise, scope the new version to a pilot group through a plugin; on other plans, share it with a few colleagues before uploading it org-wide.
- Publish through review. Set the publishing policy to "Requires review" and have the reviewer compare the submitted version with the repository commit.
This mirrors what our guide on prompt versioning recommends for prompts: the text that changes agent behavior gets the same review and history as code.
Keep skills current with the SOP
The AWS guidance calls the slow decay "skill rot": the procedure changes, the skill does not, and the agent confidently follows last quarter's process. Two habits help. Tie the review to the SOP rather than the calendar, so that a change to SOP-PROC-014 opens a change to the skill in the same week. And keep facts that drift (thresholds, contacts, system names) in one reference file that the skill points to, rather than spread across the instructions. The Claude best practices make the same point from the other side: avoid time-sensitive information in the skill body.
Failure modes and tradeoffs
- Too many overlapping skills. Every installed skill adds its description to the agent's startup context, and similar descriptions compete. Keep an inventory and merge skills that answer the same requests.
- Rules buried in skills. A house rule placed inside a skill is only followed when the skill loads. Move it to the instruction layer and keep a copy in the skill only if the procedure depends on it.
- Approval described, not enforced. A skill that says "get finance sign-off" relies on the model choosing to comply. If the step matters, it needs a workflow gate.
- Trusting a single score. A trigger rate from one harness, in one workspace, on one model is a weak signal. Check transcripts and test on each model you use.
- Untracked edits. Editing a skill in the console without a matching commit breaks the link between what users saw and what you can show later.
- Untrusted skills. Anthropic recommends installing skills only from trusted sources. Treat third-party skills like third-party code: review them, pin a version, and host your own copy.
How to verify the rollout
- Every line of the source SOP is marked as instruction, skill, or workflow, with a reason.
- The description names the triggering requests in your team's own words.
- The trigger set has should-trigger and near-miss cases, and the latest scores came from a realistic workspace with transcripts sampled.
- The skill's
metadataversion matches a reviewed commit, and the SOP revision it cites is current. - The current version was piloted with a group before it reached everyone.
- Approvals and system writes named in the SOP are enforced by a workflow, not by the skill text.
Next action
Pick one SOP your team asks an assistant about every week. Mark each line as an instruction, a skill, or a workflow step, and write the skill only for the middle column. If the workflow column turns out to be longer than the skill column, the procedure needs a built workflow with approvals more than it needs a skill. Our AI audit maps that split across your procedures, and our AI workflow automation service builds the gated steps the skill should not carry.