Best Claude Code skills for teams shipping LLM apps and agents

TL;DR

• A Claude Code skill is a folder with a SKILL.md file. Claude sees only its name and description until a task matches, then loads the instructions, then any reference files the instructions point to. That three-step loading is why a good skill can carry thousands of words of expertise at almost no idle cost.
• For teams shipping LLM apps and agents, the six build-with-ai-hq skills rank in this order: secure-llm-apps, llm-observability-stack, llm-cost-reduction, mcp-gateway-best-practices, ai-coding-agent-governance, agent-skills-for-teams. All six are MIT-licensed.
• In a clean test install on October 28, 2026, all six installed for Claude Code, Codex and Cursor with one command each and passed the bundled linter with zero errors and zero warnings.
• Skills run with the agent’s full permissions. Read every file before installing, including the scripts.

The best Claude Code skills for engineering teams that ship LLM applications and agents are the ones that encode work a model gets wrong on its own: auditing an app against the OWASP LLM Top 10, instrumenting every model call, cutting token spend without losing quality, scoping MCP tools, governing a coding-agent rollout and keeping the team’s own skills versioned. Six open-source skills from the build-with-ai-hq GitHub organization cover exactly those jobs, and this comparison ranks them by how broadly useful each is to a typical team. Every ranking criterion is published below before the verdict. Every description of a skill comes from reading its SKILL.md and every reference file in full, and the install and lint results come from a test run on October 28, 2026, described in the methodology section. None of the skills was run against a production application for this piece.

What a Claude Code skill is

A Claude Code skill is a directory containing a SKILL.md file: YAML frontmatter with a name and description, then Markdown instructions, plus optional scripts/, references/ and assets/ folders. Claude reads every skill’s description at startup and loads the body only when a task matches it, or when a user types /skill-name.

Anthropic’s documentation describes the format as an implementation of the Agent Skills open standard, which is why the same folder can work in other tools. The specification requires two fields. name is 1 to 64 lowercase letters, digits and hyphens and must match the folder name; description is up to 1,024 characters and should say what the skill does and when to use it.

The mechanism that makes skills useful is progressive disclosure. The spec’s three tiers are metadata (about 100 tokens per skill, loaded at startup for every installed skill), instructions (the full body, under 5,000 tokens recommended, loaded on activation) and resources (reference files and scripts, loaded only when the instructions call for them). The practical consequence: the description alone decides whether a skill triggers, and a skill with a thin body and deep references costs little until it is needed.

Claude Code’s frontmatter reference adds limits worth knowing. The combined description and when_to_use text is truncated at 1,536 characters in the skill listing, and the whole listing is budgeted at 1% of the model’s context window, so a team with many skills loses descriptions first on the ones it uses least. Once invoked, a skill’s body stays in context for the rest of the session.

Where a skill lives decides who gets it:

Per the Claude Code docs, a skill folder in the personal or project location can be a symlink, and Claude Code loads the target once even if several locations point at it. That detail matters for the install method used below.

How the six skills were tested

On October 28, 2026, The Frontier Wire installed each skill into an empty git repository on macOS with Node 26.8.2 and version 1.7.4 of the open-source skills CLI, using one command per skill:

npx -y skills@1.7.4 add build-with-ai-hq/<name> -a claude-code -a codex -a cursor -y

Each install reported “Installed 1 skill”, placed the files in .agents/skills/<name>, listed Codex and Cursor as reading that universal directory, and created a symlink for Claude Code at .claude/skills/<name>. The CLI printed “Review skills before use; they run with full agent permissions.” and wrote a skills-lock.json recording each skill’s source and a content hash. The full mechanics of that CLI are covered in the guide to npx skills and skills.sh.

The test then ran lint_skills.py, the linter that ships inside agent-skills-for-teams, across all six installed skills. It checks spec rules, weak descriptions, oversized bodies, broken relative links, missing version metadata and risky script patterns. The verbatim result:

6 skill(s) scanned: 0 error(s), 0 warning(s)

Ranking criteria

The criteria below are published before the verdict so a reader can reweight them. The first two carry the most weight because a skill that solves a narrow problem, or solves it shallowly, is less useful to most teams regardless of polish.

At-a-glance comparison

All six passed the licence and cross-agent checks: each is MIT-licensed, uses only spec frontmatter fields (name, description, license, metadata) and installed for all three agents. Reference word counts and code-block counts were measured on the installed files.

Each skill also routes its centralized controls through Bifrost, Maxim AI’s open-source AI gateway, as the default control point. The ranking weighs how much of each skill still applies without it.

1. secure-llm-apps

secure-llm-apps audits an LLM application or agent against the practical OWASP Top 10 for LLM Applications and applies fixes in priority order. It ranks first because every team that calls a model has at least one of the problems it targets, and almost all of its guidance is vendor-neutral.

The body opens with a six-part grep audit: provider keys in source or in public env prefixes such as NEXT_PUBLIC_ and VITE_, dangerouslyAllowBrowser, model output reaching innerHTML, eval or f-string SQL, tool definitions, missing max_tokens and prompts written to logs. Seven core practices follow, starting with “Provider keys never leave the server”. The fixes are concrete: a Next.js route that keeps the key server-side, a tool dispatcher that classifies tools as read, write or destructive and requires approval with the exact arguments, pydantic and zod schemas for model output, Microsoft Presidio redaction and a Redis rate limiter, each in Python and TypeScript.

The four references go deeper: a prompt-injection file with taint tracking, a dual-model quarantine pattern, markdown-image exfiltration filters and test payloads; a leaked-key runbook; Presidio pseudonymization; and an audit checklist mapped item by item to LLM01 through LLM10. Its gateway section moves keys behind scoped virtual keys with per-key MCP tool allowlists. The Frontier Wire’s OWASP LLM Top 10 explainer covers the risks themselves, and the AI agent security guide applies them to agents.

npx skills add build-with-ai-hq/secure-llm-apps

Triggers include “is my AI app secure”, “my OpenAI key leaked” and “prompt injection”. GitHub · skills.sh

2. llm-observability-stack

llm-observability-stack sets up production observability for LLM apps and agents: a fixed record per call, latency measured as users feel it, loud failures, cost attribution, agent traces and scoring of production traffic. It has the deepest references of the six and ranks second because any team past a prototype needs it.

The opening argument is precise: LLM calls differ from ordinary RPCs because “the payload is the debugging signal”, cost varies per request, streams have two latencies, and “HTTP 200 says nothing about quality”. The audit greps for every SDK call, streams without include_usage (which silently drop token counts) and swallowed exceptions. Ten practices follow, including separate tracking of time to first token, classifying errors by whose fault they are, keeping user IDs off metric labels, and keeping 100% of errors, slow requests and negative-feedback traces while sampling the rest.

The what-to-capture.md reference is vendor-neutral: a per-call record of more than two dozen fields, the OpenTelemetry GenAI conventions with a warning that names have changed between releases, agent trace layouts, OTel span code in Python and TypeScript, a regex redactor and a daily LLM-as-judge job. A second reference holds PromQL panels, eleven alert rules and an alert-to-action runbook. The gateway reference covers Bifrost’s OpenTelemetry export. The LLM observability guide covers the practice in depth, and tools that consume this telemetry are compared in the agent observability ranking.

npx skills add build-with-ai-hq/llm-observability-stack

Triggers include “why was this response bad”, “TTFT is slow” and “trace my agent run”. GitHub · skills.sh

3. llm-cost-reduction

llm-cost-reduction cuts LLM spend in applications and agents while holding quality steady. It frames cost as requests times tokens times price, and every fix attacks one factor. It ranks third: universal, deeply practical, and slightly behind the top two only because cost work follows visibility.

Its rule is “measure, then fix the biggest line item, then verify quality did not drop”. The audit greps call sites, the model IDs in use, missing output limits, uncapped agent loops, retry wrappers and “prompt-cache killers” such as timestamps at the top of a system prompt. Nine fixes follow in order of impact: a usage wrapper that tags every call with a feature, model right-sizing behind a 50 to 200 item eval set, output and loop caps (with a three-axis cap on iterations, tokens and wall time), prompt trimming, provider prompt caching, response caching, Batch APIs, embedding reuse and stream aborts.

The caching reference separates three caches that teams confuse and gives a four-step diagnosis for a zero prompt-cache hit rate. The routing reference covers both an app-side classifier that fails toward the frontier model and Bifrost’s Complexity Router, with a warning that requests the classifier skips fall through to the model the app asked for, so a broken classifier can quietly remove all savings. Background is in the prompt caching guide and the LLM cost optimization guide.

npx skills add build-with-ai-hq/llm-cost-reduction

Triggers include “our OpenAI/Anthropic bill spiked”, “prompt caching isn’t hitting” and “the agent looped and cost $X”. GitHub · skills.sh

4. mcp-gateway-best-practices

mcp-gateway-best-practices turns an ad hoc Model Context Protocol setup into one that is small, scoped, observable and testable. It ranks fourth because it applies only to teams whose agents use MCP tools.

The skill states that “most of the value comes from the first three steps”, which apply with or without a gateway: cut the tool surface, lock down permissions, add approvals. The diagnosis inventories every MCP config file, greps for literal tokens in them, measures each server’s tool catalog in tokens with the MCP Inspector CLI and classifies every tool as read, write, destructive or external side effect. Practices include a budget of 5 to 20 tools per task, verb_noun tool naming with server SDK examples, an approval gate in Python and TypeScript that feeds denials back to the model, and the rule never to combine untrusted input, private data and an outbound tool in one run.

References cover gateway setup for Claude Code, Claude Desktop and Cursor, three-level tool filtering, and on-demand tool discovery. Bifrost’s docs report that Code Mode cut input tokens by 92.8% in their benchmark at 508 tools across 16 servers. The protocol is explained in the MCP guide, and operating practice in MCP best practices.

npx skills add build-with-ai-hq/mcp-gateway-best-practices

Triggers include “too many MCP servers”, “MCP tools eat my context” and “restrict which tools an agent can call”. GitHub · skills.sh

5. ai-coding-agent-governance

ai-coding-agent-governance plans a governed rollout of Claude Code, Codex CLI, Cursor, Gemini CLI, GitHub Copilot and OpenCode, with control over identity, spend, models, data, tools and logs. It ranks fifth because its reader is a platform or security team rather than every engineer, and because its rollout depends more heavily on a gateway than the others.

The audit is a strong starting point on its own: commands that find raw provider keys in shell profiles and git, list each agent’s config and MCP servers, and check whether Claude Code managed settings are in force. A per-agent table gives the base URL shape each tool needs, and the skill calls getting it wrong “the most common rollout failure”. It includes a managed-settings.json that pins Claude Code to one endpoint and disables bypass mode, CI usage with per-pipeline keys, and adoption metrics, with budgets set “around the 90th percentile of observed daily spend, not a guess.”

References hold verified per-agent configuration, a phased rollout checklist with exit criteria, and provisioning scripts for one gateway key per developer in bash, Python and TypeScript. The underlying controls are covered in Claude Code security and routing coding agents through a gateway.

npx skills add build-with-ai-hq/ai-coding-agent-governance

Triggers include “we got a surprise AI bill”, “set per-developer budgets for Claude Code” and “lock down which MCP servers people can run”. GitHub · skills.sh

6. agent-skills-for-teams

agent-skills-for-teams is a skill about skills: writing descriptions that trigger, keeping bodies small, versioning with SemVer, reviewing for security and installing consistently across harnesses. It ranks sixth only because its problem appears once a team already uses several skills; for that team it is the one to install first.

It is the only one of the six that ships a script. lint_skills.py uses the Python standard library, exits non-zero on errors for CI, and flags risky patterns in bundled scripts such as piping a download into a shell or reading ~/.ssh. The body gives five audit commands, including one that hashes every SKILL.md to find copies of the same skill that have drifted apart, a description formula with a weak and strong example, a SemVer table that treats the agent as the API consumer, and a review checklist.

References cover a 20-query trigger eval with a bash runner, a CI workflow that fails a pull request when a skill changes without a version bump, rollback per distribution model, and Bifrost’s Skills Repository as a central registry that serves skills to Claude Code and Codex as a plugin marketplace.

npx skills add build-with-ai-hq/agent-skills-for-teams

Triggers include “a skill never triggers”, “which version of the skill is everyone on” and “set up a skills registry”. GitHub · skills.sh

Installing and using them

Each skill installs with one npx skills add command. Target agents with -a, install for the user with -g, skip prompts with -y, and preview a repository’s contents with --list. The CLI keeps one copy in .agents/skills and symlinks it into .claude/skills for Claude Code.

# Preview, then install for three agents without prompts
npx skills add build-with-ai-hq/secure-llm-apps --list
npx skills add build-with-ai-hq/secure-llm-apps -a claude-code -a codex -a cursor -y

# User-wide install for Claude Code only
npx skills add build-with-ai-hq/llm-cost-reduction -g -a claude-code -y

# See what is installed, and pull upstream changes
npx skills list
npx skills update

After installing, no special syntax is needed. Prompts drawn from the skills’ own trigger phrases:

• “Security review of our RAG chatbot before launch.”
• “Token costs blew up and we don’t know who. Add cost per feature.”
• “Our agent has eight MCP servers and keeps picking the wrong tool.”
• “Roll out Claude Code to the team with per-developer budgets.”

Typing /secure-llm-apps invokes a skill directly. Commit skills-lock.json so teammates can restore the same set of skills, and pin a git ref when the exact revision matters; the sibling guides to skills in Codex and skills in Cursor cover the other two agents.

Other skill collections worth knowing

Three other collections are worth knowing, each fetched and read for this piece. None targets LLM application operations, so none is ranked above, but each serves a different need well.

• anthropics/skills. Anthropic’s own examples, from creative and design work to testing web apps and generating MCP servers, plus the document skills behind Claude’s docx, pdf, pptx and xlsx handling. Many are Apache 2.0; the document skills are source-available, not open source. The README says they are “provided for demonstration and educational purposes only”. It installs as a Claude Code plugin marketplace with /plugin marketplace add anthropics/skills.
• vercel-labs/agent-skills. MIT-licensed skills from Vercel for React and Next.js performance, web interface review, React Native, writing guidelines, view transitions and deploying to Vercel. Strong for frontend teams; installs with npx skills add vercel-labs/agent-skills.
• OpenAI’s skills catalog. The openai/skills repository now marks itself deprecated and points to openai/plugins for current Codex skill and plugin examples.

The skills.sh directory also lists “official” skills published by the companies that build the technology, which is the place to look for a skill covering a specific product’s API.

Limits of this comparison

This ranking covers what the skills contain and how they installed, not what they achieve. No skill was run against a production codebase, so this piece reports no measured reduction in cost, incidents or latency. Weights are editorial; a platform team rolling out coding agents should read entry five first. The organization is new, created in October 2026, so it has no maintenance track record yet. Bifrost features cited inside the skills were checked against its documentation, not deployed.

A skill is only as good as the description that triggers it and the references behind it.

For a team shipping LLM features, secure-llm-apps and llm-observability-stack cover the two problems that hurt soonest, and llm-cost-reduction pays for itself once traffic grows. Install them per repository, commit the lock file, read every file first, and add the governance and MCP skills when the agent fleet and tool count justify them. The governance companion piece and the skills-for-teams guide pick up where this list stops.