Elastic just gave us one of the clearest examples yet of what it looks like when an enterprise gets serious about packaging institutional knowledge for AI agents. Their elastic-docs-skills repository is an open source catalog of 19 Claude Code skills — slash commands purpose-built for Elastic’s documentation workflows. Each skill is a versioned, self-contained SKILL.md file with YAML frontmatter and a markdown body that acts as a system prompt. When installed, they become commands like /docs-check-style or /crosslink-validator that documentation authors invoke while working in Claude Code, Cursor, or Codex.
This isn’t a toy example. This is a production documentation team encoding their style guide, their MDX syntax conventions, their redirect handling, their changelog formatting, and their review processes into distributable agent context. That’s worth paying attention to.
What’s in the Catalog
The skills break down across four categories, and the taxonomy itself is instructive.
Authoring skills handle the creation and editing of documentation content. There are skills for tagging docs with applies-to metadata, classifying content types, generating Kibana release notes from pull requests, managing URL redirects, generating serverless changelog entries, providing syntax reference for Elastic’s custom MDX, fixing changelog formatting, improving SEO meta descriptions, updating LLM support matrices, and optimizing page opening paragraphs. Ten skills just for writing and editing.
Review skills cover validation and linting of existing content. Style checking against Elastic’s style guide using Vale, cross-document link validation, jargon flagging, frontmatter auditing, changelog review, and even a meta-skill for reviewing skill definitions themselves. Six skills that encode what a thorough documentation review looks like at Elastic.
Workflow skills automate process-level tasks — changelog management and documentation retrospectives. Project skills handle documentation for specific product areas like Kibana Lens chart pages and settings.
What stands out is the coverage. This isn’t one big “help me write docs” prompt. It’s 19 discrete, focused capabilities that each encode a specific piece of Elastic’s documentation practice. The decomposition matters. It means each skill can be versioned, tested, and maintained independently.
The Architecture That Makes It Work
The structure Elastic chose is worth studying because it solves problems that most organizations haven’t even identified yet.
Each skill is a SKILL.md file with required frontmatter: name (kebab-case), version (SemVer), and description. Optional fields include allowed-tools (constraining what the skill can access), context fork (for read-only skills that run in isolated subagents), and sources (upstream URLs for freshness checking). The markdown body is the system prompt — role statement, input definition, step-by-step process, rules and constraints, output format.
They’ve built quality infrastructure around this. A CI workflow validates SKILL.md frontmatter on every PR. A freshness checker compares skills against their upstream source URLs to detect drift. Most skills include eval test cases — structured input/output pairs with grading expectations — and PRs that modify skills automatically run eval tests via agentic workflows. There’s even a /create-skill meta-skill that walks contributors through creating new skills interactively.
This is documentation-as-code applied to agent context. Version it. Test it. Review it. Deploy it. The same discipline organizations apply to their application code is being applied to the knowledge that shapes how agents work with their content.
Three Distribution Paths
Elastic supports three ways to install these skills, and the variety tells you something about where the ecosystem is heading.
The Claude Code plugin system lets you add skills through \/plugin marketplace add and \/plugin install. The npx skills CLI — npx skills@latest add elastic/elastic-docs-skills -g — works across Claude Code, Cursor, and Codex. And there’s an interactive TUI installer via a curl one-liner for the folks who prefer that workflow.
The multi-agent compatibility is the key detail. Elastic isn’t building for one tool. They’re publishing skills that work across whatever AI coding agent their team happens to be using. The skill is the unit of distribution, not the agent.
What Makes This Different
I’ve been tracking how organizations publish agent context for a while now, and Elastic’s approach is notable for several reasons.
First, they’re treating skills as first-class software artifacts. SemVer versioning, CI validation, eval testing, automated freshness checks — this isn’t someone dumping a prompt into a repo. This is a maintained catalog with production-grade infrastructure.
Second, the catalog model is right. They deploy a browsable catalog site via GitHub Pages. Users can install all skills or cherry-pick individual ones. That’s the composability that enterprise adoption requires. Not every documentation contributor needs the Kibana release notes skill, but everyone needs the style checker.
Third, the eval-driven development pattern is something more organizations need to adopt. If you’re going to version and distribute agent skills, you need a way to know whether they still work after changes. Elastic’s eval framework gives them regression testing for prompt engineering. That’s a maturity marker.
Fourth, they have an MCP server at elastic.co/docs/_mcp/ that exposes tools like search_docs, get_document_by_url, and find_docs_inconsistencies. Skills can leverage this server, which means the skills aren’t just static context — they can interact with Elastic’s documentation infrastructure in real time. That’s the kind of integration that turns skills from prompt templates into actual capabilities.
The Pattern for Everyone Else
Here’s what I think matters most about Elastic’s approach. Every organization has institutional knowledge that currently lives in wikis, style guides, runbooks, and the heads of senior team members. That knowledge shapes how work gets done correctly — whether it’s writing documentation, reviewing code, deploying services, or handling incidents.
Elastic took their documentation knowledge and made it distributable. They didn’t build a custom AI tool. They didn’t fine-tune a model. They packaged their expertise into versioned skill files that any compatible agent can consume. The documentation style guide isn’t something you have to read and internalize anymore. It’s something your agent knows because the skill was installed.
That’s the pattern. Take the knowledge that makes your teams effective. Decompose it into discrete, focused skills. Version them. Test them. Distribute them through the same infrastructure you use for code. Let your agents carry the institutional knowledge so your people can focus on the work that actually requires human judgment.
What This Means for Naftiko
Elastic’s doc skills catalog validates the direction we’ve been heading with the Naftiko capability specification. Our approach to making API integrations discoverable, testable, and consumable by agents is the same philosophy Elastic applied to their documentation workflows. The difference is scope — we’re focused on the API integration layer while Elastic focused on documentation practice — but the pattern is identical. Package expertise as versioned, testable, distributable artifacts that agents consume. The organizations that figure this out first are the ones whose agents will actually be useful.
Where Naftiko Lives
- Naftiko Framework — Apache 2.0 framework for spec-driven integration, with HTTP source adapters, MCP/Agent Skill/REST exposure types, and output reshaping via JSONPath.
- Naftiko Fleet Community Edition — the free edition of Naftiko, including the framework, the VS Code extension, and the Backstage templates.
- Naftiko Capabilities Schema — the JSON Schema and Spectral rules that define what a valid Naftiko capability looks like. Same versioned-spec pattern Elastic applied to SKILL.md, applied to capability YAML.
