When Work Becomes Programmable

How employees and organizations can start programming their own intelligence - through Agent Skills

We talk about AI agents getting smarter, and how with increasingly more context and memory (see the Enterprise Graph) they can start becoming useful in work for real. Last week (hot off the press!) Anthropic released Agent Skills functionality which promises to bake in the ‘how to’ knowledge that makes work...work. This week we dive in what it is, and what implications it can have in the mid and long term. It’s going to be slightly technical in some parts - so feel free to skip those, but my goal is focus on how this could change work design and in the future, also learning & development.

Let’s dive in! 🐬

---

From Assistants to Skilled Collaborators

One of the biggest shortcomings of AI Agents at the moment, is that even though they can reason, summarize, even code — they are still like a bright interns without process memory. Ask to reconcile accounts, prepare an ESG report, or validate an invoice, and they’ll improvise every time. Anthropic’s new Agent Skills framework promises to give them exactly that — modular micro-expertise that can be shared, reused, and improved.

If it works, this is an important step - because in the context of work, a Skill is a digital representation of procedural knowledge — a reusable module that captures how work is done so AI agents (and eventually humans) can perform it reliably.

First of all, let’s understand better what they are.

🧩 Anthropic AI Agent Skills Definition

An Agent Skill is a self-contained folder of instructions, code, and resources that an AI agent can discover, load, and use autonomously to perform a specific kind of task.

Each Skill lives in its own directory, centered on a SKILL.md file that describes:

• What the skill does

• When the agent should use it

• Any supporting assets (scripts, datasets, documentation)

Agents use progressive disclosure: they first scan summaries of all available skills, then load only the relevant ones in full.
That’s how you can scale — a single general agent becomes a chameleon, swapping expertise without retraining.

Skills can be transparent (plain text) or active (invoking tools, code, or APIs).
They bring modularity to AI — like GitHub repos for intelligence.

Key properties:

• Modular: each skill focuses on one domain or capability (e.g., financial analysis, data cleaning).

• Structured: it contains a central SKILL.md file with metadata — name, description, when to use — plus optional helper files (scripts, docs, datasets).

• Dynamic: the agent doesn’t preload all skills, it decides when to invoke one through progressive disclosure.

• Composable: multiple skills can be combined to handle complex workflows.

• Transparent: skills are plain text and code, not hidden weights — they can be inspected, versioned, and governed.

What it looks like:

Skills are to agents what APIs are to apps — portable packages of capability.

What you can do with them - and why this is different

In Anthropic’s Claude Cookbooks, you already find early examples of Skills applied to real workflows:

• Finance Skills: parsing ledgers, analyzing statements, generating structured quarterly reports.

• Data Skills: cleaning messy datasets, matching columns, detecting anomalies.

• Custom Enterprise Skills: connecting to internal APIs, retrieving policy documents, enforcing compliance logic.

Each of these Skills follows a consistent pattern:

Identify → Encapsulate → Invoke → Reuse

You start by identifying a task the agent struggles with (e.g., “prepare a P&L summary from raw data”). Then you encapsulate the know-how — add instructions, reference files, maybe a small Python script. When needed, the agent invokes the skill automatically. And once it’s tested, any other agent can reuse it — instantly.

That’s the short version.
The deeper change lies in how this differs from what we’ve been doing until now.

🧠 1. From Prompt Engineering → Reusable Procedures

Until now, we’ve had to teach large models the same task every time through prompting:

“You are a financial analyst. Here’s our data. Please write a quarterly summary…”

Each session starts from scratch; the model has no memory of how you do things.
Skills break this loop. They store your best prompt, your context, and your logic in a structured way — permanently.
The next time, any agent can just load the “Quarterly Report Skill” and execute without re-explaining everything.

It’s like moving from ad-hoc conversations to standard operating procedures for AI.

🧩 2. From Fine-Tuning → Plug-and-Play Expertise

Before Skills, if you wanted an agent that “knows” your domain — legal drafting, ESG reporting, or supply-chain analysis — you had two main options:

• Fine-tune a model (costly, brittle, opaque).

• Use retrieval-augmented generation (helpful, but purely informational).

Skills introduce a third way: encode your domain logic as lightweight modules that the agent can dynamically load.
They don’t change the model weights — they extend capabilities at runtime.
That makes them composable (mix and match), inspectable (you can open the folder), and shareable (others can reuse it).

This is capability engineering instead of model training.

🧭 3. From Knowledge Bases → Executable Knowledge

Traditionally, company knowledge lives in wikis, PDFs, or intranets — searchable but static.
Agents could “read” those documents but not act on them.

A Skill turns that same content into executable knowledge:

• A policy becomes a decision rule.

• A process becomes a workflow script.

• A guide becomes an instruction set the agent can follow step by step.

It’s the difference between knowing and doing.

🔁 4. From Single-Use Prompts → Scalable Systems

In current workflows, every agent is an island.
Your marketing agent doesn’t “remember” what your finance agent learned last week.
Skills make knowledge modular and shareable across the organization.

Once one team encodes a process — say, “budget approval workflow” — it can be reused anywhere.
That means every new agent inherits a baseline of competence from day one.

Over time, you don’t just build a better agent — you build a corporate skill library, a living repository of how your organization actually works.

Why this matters - and how work can change

Although it initially may look like a developer feature, this is potentially a new operating model for organizational knowledge. We could stop “prompting” AI for every task and start building libraries of skills — living, versioned, auditable artifacts that encode how our organizations actually operate.

Every company could maintain:

• a Finance Skill Library (reporting, budgeting, forecasting)

• a Marketing Skill Library (SEO optimization, content testing, audience mapping)

• a People Ops Skill Library (recruitment, pay benchmarking, policy generation)

These become proprietary assets — the process layer that makes AI agents company-specific.

🔁 From Static Graphs → Executable Graphs

We recently framed the Enterprise Graph as the connective tissue that makes AI useful inside companies — linking data, content, and context so agents can reason with them.
But reasoning alone doesn’t change work; execution does.

With Skills, that same graph becomes actionable.
Nodes aren’t just “documents” or “employees” anymore — they can be Skills with defined behaviors. A “Finance” node might now include “Generate Quarterly Report” or “Reconcile Budget” as callable Skills. A “Recruiting” node could expose “Draft Job Description” or “Screen Candidate Profiles.”

The result is a graph of capabilities, not just knowledge.

🧩 SkillOps: Operating the Graph

As Skills proliferate across this enterprise graph, organizations will need a new operational layer — SkillOps.
Just as DevOps unified code, infrastructure, and deployment, SkillOps will unify knowledge, governance, and execution.

SkillOps is where:

• Knowledge graphs meet workflow automation,

• Governance meets continuous improvement,

• Human expertise meets AI execution.

It will involve:

• Registries: a canonical directory of all Skills and their relationships in the enterprise graph.

• Pipelines: automated testing, validation, and deployment of Skills (CI/CD for knowledge).

• Telemetry: usage analytics, version tracking, audit logs.

• Governance frameworks: who can publish, edit, or deprecate a Skill.

In mature organizations, this will become a new operational discipline — part knowledge engineering, part process automation, part AI ethics.

🧠 Humans Shift Roles — Again

When Skills become part of the Enterprise Graph, human roles could evolve along three new axes:

This reshapes how we think about “knowledge work.”
Instead of individuals executing processes, teams will design and maintain digital process assets that agents can execute reliably.

🕸️ From Knowledge Graphs to Capability Networks

Imagine your Enterprise Graph evolving into a Capability Network:

• Every department node exposes its Skills as APIs.

• Agents traverse the graph to assemble workflows dynamically.

• Data flows trigger Skills that act, not just analyze.

Example:
A marketing agent queries the enterprise graph:

“Who handles ESG reporting?”
The graph responds:
“Finance Department → ESG Disclosure Skill → ‘Generate draft sustainability report from this year’s data.’”

Within seconds, the agent composes a workflow across nodes, executes it, and routes the result to the right reviewers.
The graph has become the interface for doing, not just knowing.

⚙️ Governance Becomes Strategic

When processes live as Skills inside your Enterprise Graph, governance becomes an executive concern, not a technical one.
Questions like:

• Who maintains the compliance logic inside the “Expense Approval Skill”?

• How often do we review the assumptions embedded in the “Hiring Filter Skill”?

• Which teams’ Skills are being reused across the company — and which are not?

These become operational KPIs as real as revenue or NPS.

You can think of the modern enterprise stack evolving like this:

⚠️ The Potential Drawbacks of “Skills”

1. 🧩 Fragmentation and Version Drift

Once every team starts building their own Skill folders, you risk ending up with dozens of slightly different versions of the same process:

• “Quarterly_Report_v1”

• “Quarterly_Report_v2_internal”

• “Quarterly_Report_v2.1_France”

Without strong governance, these differences multiply, producing “Skill spaghetti.”
It’s the same problem that hit low-code tools and spreadsheets: great for agility, terrible for consistency.

Why it matters:
Agents might load outdated or conflicting instructions, leading to inconsistent outcomes and compliance issues.

2. 🔒 Security & Compliance Risks

Skills can contain executable code or API connections, meaning they’re as powerful — and as dangerous — as any software component.
A malicious or poorly reviewed skill could exfiltrate data, trigger unintended actions, or expose internal systems.

What this implies:
Companies will need:

• Security audits for Skills (code scanning, sandbox execution).

• Access controls (who can create, edit, or deploy Skills).

• Digital signatures or “Skill provenance” metadata.

In other words: “SkillOps” must include DevSecOps.

3. 🧠 Overreliance and Skill Blind Spots

As agents get more capable, humans may trust Skills too quickly.
If the Skill’s logic is flawed, biased, or outdated, the agent will still execute it confidently.

This creates a new failure mode: automated procedural error — faster and more invisible than before.
(Think of a macro that runs perfectly but applies the wrong rule.)

Mitigation:

• Mandatory review checkpoints.

• Explainability layers (“why did the agent choose this skill?”).

• Regular audits and feedback loops.

4. 🧱 Knowledge Capture vs. Knowledge Loss

Skills make it easy to codify expertise — but that also means experts may stop evolving their practice.
When “the skill works,” teams might forget to revisit assumptions or update logic.

Over time, organizations risk petrifying processes instead of improving them.
The same pattern happened with legacy ERP systems: great at enforcing rules, bad at adapting them.

Solution:
Adopt Skill lifecycle management — every skill has an owner, version history, and expiry date.

5. 🕹️ Cognitive Offloading & De-skilling

When agents handle more procedural work, humans naturally lose touch with the underlying reasoning.
If a “Recruitment Evaluation Skill” makes decisions faster than you, it’s tempting to accept its output as truth.

This leads to de-skilling — workers lose the very expertise they encoded.
Future professionals may become “Skill operators” rather than practitioners.

Organizational implication:
We’ll need to redefine training and oversight — focusing not on “how to do the task,” but “how to understand, validate, and improve the Skill that does it.”

6. 🧮 Complexity and Maintenance Overhead

While Skills reduce friction for end users, they increase complexity for system administrators:

• Dependency tracking (which Skill uses which scripts?).

• Compatibility management (after API updates).

• Monitoring (which Skills are used, by whom, with what outcomes?).

At scale, managing Skills becomes its own discipline — SkillOps — requiring dashboards, policies, and continuous integration pipelines.

7. 🧭 Ethical and Strategic Risks

When you codify a workflow into a Skill, you also codify its assumptions — and those can outlive the context that made them valid.
If a Skill encodes a biased decision rule or outdated regulation, it can silently propagate errors across the organization.

At a broader level, Skills could create vendor lock-in if ecosystems become proprietary.
If your enterprise relies on a vendor’s Skill library, your processes effectively belong to them.

8. ⚖️ Cultural and Governance Gaps

Implementing Skills isn’t just technical — it’s cultural. Most organizations aren’t likely to be ready to think of processes as code or knowledge as versioned software. Without that shift, Skills risk becoming another underused innovation, like internal wikis or RPA bots - we knew these could improve work, but never really implemented them.

Final Thoughts - and try it yourself

Skills make agents powerful — but also organizationally real.
That means they’ll need the same care we give to software, governance, and culture.
They’re not just a technical layer — they can be a new layer of institutional memory.
And like all memories, they must be curated to stay useful.

Right now, the real shift is this:

From prompt engineering to process engineering.
From AI hype to SkillOps discipline.
From knowledge to execution.

We’ve talked before about how AI adoption today is both imperative and messy — full of pilots, copilots, and uncoordinated tools.
The real challenge isn’t adding more AI, but orchestrating it: aligning people, processes, and systems around shared goals, while creating small, goal-oriented task teams that can safely experiment and bring back learnings.

Skills are now part of that orchestration fabric.
They give those teams a way to capture what works and make it reusable — turning every successful experiment into a repeatable capability.
They let organizations build a feedback loop between discovery and deployment, between human creativity and machine execution.

And yes, for many, this will feel like a second job for a while — documenting, curating, encoding.
But just like writing documentation once made software teams faster, SkillOps will make AI-enabled teams smarter.
It’s the bridge between today’s messy experimentation and tomorrow’s coherent, self-improving enterprises.

That’s the next frontier of work:
not just using AI, but teaching your organization how to learn through it.

Until next week!
Matteo

---

🧠 Optional: Try It Yourself: How to Experiment with Agent Skill

Want to see how this works in practice?
I’ve put together a super simple SkillOps Starter Kit on GitHub — a ready-to-use folder structure, sample SKILL.md, and registry template so you can start building and testing your own Agent Skills today. You don’t need enterprise infrastructure to start — just curiosity and Claude.

1️⃣ Read the examples (optional but inspiring)

If you’re curious, look at Anthropic’s Skills Cookbooks.
You’ll see how a Skill is simply a small file (SKILL.md) that tells Claude what the Skill does and when to use it — like a digital playbook.

2️⃣ Make your first Skill

Instead of “coding,” you’re just writing a short description.

1. Open any text editor (Notes, Notion, or Google Docs).

2. Paste this and edit the text in bold:

# Skill: Meeting Summarizer  
description: Summarize meeting notes into key decisions and next steps.  
usage: Use this Skill when asked to recap or summarize discussions.  
steps:  
  - Identify main topics  
  - List key decisions  
  - Write clear follow-up actions  

You’ve just created your first Skill file — no software needed.

3️⃣ Test it in Claude

Open Claude (any version works) and copy-paste your Skill text at the top of the chat.
Then say:

“You now have access to this Skill. Please use it to summarize the following notes.”

Paste a few lines of meeting notes — and watch as Claude applies the instructions automatically.
That’s what Anthropic calls progressive disclosure: Claude reads the Skill only when it’s useful.

4️⃣ Save and share

If you like the result:

• Copy that text into a folder on your computer called My Skills.

• Add the date and your name at the bottom (e.g., “v1.0 – Matteo – Oct 2025”).

• Share it with a teammate — now you both have a repeatable way to run that process.

If you’re in Notion for example, make each Skill its own page with fields like:

That’s SkillOps at a human scale — a shared library of how you work, written in plain language.