Can Agent Skills Handle AI Center of Excellence? What to Expect in 2026

The Governance Gap in Spreadsheet AI

Walk into any large enterprise today and you'll find AI scattered across departments like confetti after a party — impressive volume, zero coordination. That fragmentation is exactly why 37% of large US companies have already formalized an AI Center of Excellence, and why Microsoft describes the CoE's core job as preventing "fragmented or ungoverned AI adoption" (Cloud Adoption Framework).

Spreadsheet work sits at the center of this chaos. Red Hat's enterprise guidance explicitly lists "cleaning up Excel documents in a specific format" as a flagship use case for agent skills (Red Hat Developers), which makes skills a natural first asset class for a spreadsheet-focused CoE. The problem is that most skills arriving from the community are not deployment-ready.

The numbers are sobering. A 2026 UC Irvine study of 238 real skills found that 99% of shipped SKILL.md files carry at least one flaw a routine review catches. Roughly 26% of community skills carry at least one vulnerability, and 94% exhibit what researchers call the "Rationalization Loophole" — a missing guardrail that lets the agent skip required steps. In spreadsheet terms, that means an agent quietly skipping a formula check or misapplying a formatting rule, and nobody noticing until quarter-end.

A skill that encodes your standards is only valuable if it actually holds up under governance scrutiny. As Atlan's enterprise-safety analysis puts it, "a skill without governed norms is not a capability. It is a liability." That liability compounds in spreadsheets, where a single unverified skill — one reportedly reached 26,000 installs — can propagate formatting or data-handling errors across dozens of workbooks and teams.

A CoE governing spreadsheet AI therefore needs to close four specific gaps before any skill touches production data:

• Verification — pin every skill version to a commit SHA, license-check it, and security-scan it before approval.
• Benchmarking — test each skill in a sandbox with the same model, with and without the skill, and measure the actual Lift.
• Scale testing — vendor benchmarks show Excel agents that handle small tasks can fail entirely at 1,000–10,000 rows.
• Continuous re-audit — a skill's behavior can change when models or APIs update, even if its instructions never do.

This is precisely the verification infrastructure SkillzBench is building — version pinning, security scanning, and with/without-skill benchmarking, all free — so a CoE doesn't have to construct that pipeline from scratch. The governance gap is real, but it's a buildable gap, not a blocker.

Why Skills Are the Ideal CoE Asset

A center of excellence packages guidance and reusable capabilities — and agent skills are the first artifact that fits that packaging model exactly. Microsoft's CoE guidance calls on these teams to develop reusable assets, while AWS frames CoE output as two things: guidance and capabilities, including reusable templates. A skill is both at once.

Skills are lightweight, versioned instruction packages in the skill.md format that teach an agent how to perform a task, not merely what it may touch. Red Hat's enterprise guidance draws the line cleanly: without MCP the agent cannot access your systems, but without the skill it has access and doesn't know your processes. For spreadsheets, that distinction is everything.

Consider Excel format cleanup, which Red Hat names as a primary skills use case. A CoE can codify it once as a versioned package that enforces consistent formatting and processing rules:

• Column naming and ordering conventions
• Date, currency, and number formats
• Header and styling standards
• Formula-checking and validation steps
• Export and report templates

An MCP server can hand an agent a spreadsheet file, but it cannot tell the agent that currency columns need two decimals and dates follow ISO format. That process knowledge lives in the skill — write approved processes once and reuse them across teams, as enterprise-safety analysis puts it.

The catch is quality. Research cited on skill best practices found 99% of shipped SKILL.md files carry at least one flaw a routine review catches, and 26.1% of community skills carry a vulnerability. A skill that silently skips a required formatting step is worse than no skill, because the CoE has now standardized the error.

That is why skills belong in a CoE only alongside verification: pinned versions, security scans, license checks, and same-model testing with and without the skill. Skills, proven — that is the standard a CoE should hold, and it is what SkillzBench is building: a free directory that pins every version to a commit SHA, scans it, benchmarks its measured Lift separately from ratings, and tracks upstream changes so approved spreadsheet skills never quietly drift.

The Security and Reliability Reality Check

Here's a sobering starting point: a skill your team downloads today has roughly a one-in-four chance of carrying a security vulnerability. For an AI Center of Excellence betting on agent skills to standardize spreadsheet work, that number should change how you evaluate every package before it touches an agent.

The data on skill quality is unambiguous. A 2026 UC Irvine study of 238 real skills found that 99% of shipped SKILL.md files carry at least one flaw a routine review catches. Meanwhile, 26.1% of community skills carry a vulnerability, and 94% exhibit what researchers call the "Rationalization Loophole" — a missing guardrail that lets the agent skip required steps entirely.

The reliability picture is just as uncomfortable. A vendor-published Excel agent benchmark (which deserves independent verification) showed Claude in Excel failing to finish bulk tasks at 100, 500, and 1,000 rows due to rate limits and overloading, while Copilot stalled entirely at 10,000 rows. Tools that feel flawless on a 20-row demo can simply collapse at production scale — and a CoE that rolls out skills without volume testing will discover this the hard way.

The core problem is trust without verification. As enterprise safety research puts it, "a skill without governed norms is not a capability. It is a liability." And a skill doesn't stay safe just because its instructions haven't changed — a model update, a new API action, or expanded access permissions can quietly alter what it does. Governance has to be continuous, not a one-time approval.

Before any skill reaches a production spreadsheet workflow, a CoE should require:

• Security scanning on every version, since community skills are the riskiest source by far
• Version pinning to a specific commit, so upstream changes can't silently alter behavior
• License checks to avoid legal exposure when skills are reused across teams
• Independent benchmarking — same model, with and without the skill, at realistic data volumes

That's exactly the verification pipeline SkillzBench is building: pinning every skill version to a commit SHA, running security scans and license checks, and publishing a measured Lift score that shows whether a skill actually improves pass rates — because curated skills raised average pass rates by 16.2 points in SkillsBench research, yet 16 of 84 tasks got worse with a skill attached. A skill can hurt as easily as help.

The enterprise readiness test is simple: can you show what the skill knew, what it was allowed to do, why the action was approved, and what happened next? If the answer is no, the skill isn't an asset yet — it's an unverified liability wearing a productivity label.

Building a Verified Skill Pipeline for 2026

A skill that worked in January can fail in June — not because anyone edited it, but because the model, the API, or the access policy behind it changed. That's why a verified skill pipeline, not a one-time review, is the realistic foundation for a spreadsheet-focused CoE heading into 2026.

The starting point is codification. Take the spreadsheet procedures your teams actually repeat — formatting rules for cleanup, formula-checking workflows, report templates — and write them as versioned SKILL.md packages. Red Hat's enterprise guidance explicitly names "cleaning up Excel documents in a specific format" as a core skills use case, and Microsoft lists developing reusable assets as a central CoE responsibility. Keep each skill within Anthropic's recommended limits: a body under roughly 500 lines and 5,000 tokens, with a description capped at 1,024 characters.

Then gate every skill before it reaches an agent. The numbers justify the friction: a 2026 UC Irvine study found 99% of shipped SKILL.md files carry at least one flaw a routine review catches, and 26.1% of community skills carry a vulnerability. A practical pipeline should include:

• Version pinning — lock every skill to a specific commit SHA so nothing changes silently
• Security scanning and license checks on every version, not just the first release
• Sandboxed benchmarking with the same model, run with and without the skill, so you see the measured Lift in percentage points
• Least-privilege tool access through an MCP connector, so agents only see the skills and tools you've explicitly chosen
• Continuous monitoring — re-scan and re-benchmark whenever the upstream skill, the model, or connected APIs change

Benchmarking matters more than intuition here. Curated skills raised average pass rates by 16.2 points in the SkillsBench research, but 16 of 84 tasks showed a negative delta — a skill can actively hurt performance on some tasks. And spreadsheet agents that handle small files can collapse at scale: one vendor-published benchmark (treat its rankings as unverified) reported Copilot stalling entirely on 10,000 rows and Claude in Excel failing to finish 100-, 500-, and 1,000-row tasks. Run your own with/without-skill tests on realistic data volumes before rollout.

Finally, treat the pipeline as a living system. Atlan's enterprise-safety guidance recommends quarterly re-audits and warns that a skill doesn't stay safe just because its instructions haven't changed. This is the gap SkillzBench is building to close — a free, independent directory that pins versions, scans, benchmarks, and tracks upstream changes with alerts, so a CoE can prove what each skill knew, what it was allowed to do, and why each action was approved. Governance as a continuous loop, not a gate, is what separates a capability from a liability in 2026.