{"id":6449,"date":"2026-08-06T09:00:00","date_gmt":"2026-08-06T07:00:00","guid":{"rendered":"https:\/\/storiesonboard.com\/blog\/mcp-skills-claude-codex"},"modified":"2026-08-06T09:00:00","modified_gmt":"2026-08-06T07:00:00","slug":"mcp-skills-claude-codex","status":"publish","type":"post","link":"https:\/\/storiesonboard.com\/blog\/mcp-skills-claude-codex","title":{"rendered":"MCP Skills in Claude and Codex: A Practical Comparison"},"content":{"rendered":"<p><strong>MCP skills<\/strong> are often described as if they were one feature. They are really two complementary layers. The Model Context Protocol (MCP) gives an AI agent standardized access to tools, data, and external systems. A skill gives the agent a reusable way to perform a task: the instructions, decision points, checks, and handoffs that turn access into a repeatable workflow.<\/p>\n<p>Claude and Codex support both ideas, but they package, discover, and invoke skills differently. This guide compares the two approaches using a real five-skill StoriesOnBoard workflow and a deliberately small product brief called Daily Reset.<\/p>\n<h2>MCP and agent skills solve different problems<\/h2>\n<p><a href=\"https:\/\/modelcontextprotocol.io\/docs\/getting-started\/intro\" target=\"_blank\" rel=\"noopener\">MCP is an open standard<\/a> for connecting AI applications to external systems. An MCP server can expose tools the model may call, resources the application can place in context, and reusable prompts the user can invoke. In product work, that can mean reading a story map, discovering personas and releases, creating cards, or updating acceptance criteria in the system where the team actually works.<\/p>\n<p>A skill is the operating procedure that tells the agent how to use those capabilities well. It can say: challenge vague assumptions before creating a backlog; show a plain-text preview before any write; create goals before steps and stories; continue after a partial failure; then read the board back and verify the result.<\/p>\n<table>\n<thead>\n<tr>\n<th>Layer<\/th>\n<th>Question it answers<\/th>\n<th>Typical contents<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>MCP<\/strong><\/td>\n<td>What systems can the agent access or change?<\/td>\n<td>Tools, resources, prompts, authentication, transport<\/td>\n<\/tr>\n<tr>\n<td><strong>Skill<\/strong><\/td>\n<td>How should the agent complete this job?<\/td>\n<td>Instructions, checks, templates, references, scripts, approval gates<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>This is why \u201cMCP skill\u201d is useful shorthand but an imprecise technical term. A skill can work without MCP and produce a text deliverable. An MCP connection can also work without a custom skill, leaving the model to improvise the process. The strongest setup combines the two: the skill supplies the method, while MCP supplies live context and actions.<\/p>\n<figure class=\"wp-block-image size-full\">\n  <img decoding=\"async\" src=\"https:\/\/storiesonboard.com\/blog\/wp-content\/uploads\/2026\/08\/mcp-es-agent-skill-kulonbseg.jpg\" alt=\"Diagram showing reusable agent skill instructions guiding an AI agent that reaches external systems through MCP\" title=\"Agent skill and MCP: workflow plus connectivity\"><figcaption>A skill defines the workflow; MCP connects that workflow to real tools and data.<\/figcaption><\/figure>\n<h2>How skills work in Claude<\/h2>\n<p>In Claude Code, a skill is a directory with a <code>SKILL.md<\/code> entry point and optional supporting files. Claude can load a relevant skill automatically from its description, or the user can invoke it directly with <code>\/skill-name<\/code>. According to the <a href=\"https:\/\/code.claude.com\/docs\/en\/skills\" target=\"_blank\" rel=\"noopener\">Claude Code skills documentation<\/a>, the body loads only when the skill is used, so detailed procedures do not consume the working context on every turn.<\/p>\n<p>Claude supports several skill locations:<\/p>\n<ul>\n<li><code>~\/.claude\/skills\/&lt;skill-name&gt;\/SKILL.md<\/code> for personal skills;<\/li>\n<li><code>.claude\/skills\/&lt;skill-name&gt;\/SKILL.md<\/code> for project skills;<\/li>\n<li><code>&lt;plugin&gt;\/skills\/&lt;skill-name&gt;\/SKILL.md<\/code> for distributed plugin skills;<\/li>\n<li>managed enterprise and bundled locations for centrally supplied skills.<\/li>\n<\/ul>\n<p>Claude Code also adds runtime-specific options around the open Agent Skills format. Frontmatter can control automatic invocation, pre-approve or remove tools, run a skill in a forked subagent, inject dynamic command output, or limit activation to file paths. Those features are powerful, but they are not all portable to every host. Skills uploaded to claude.ai or packaged for the Skills API must stay within the smaller standard frontmatter set documented by Anthropic.<\/p>\n<h3>How MCP appears in Claude<\/h3>\n<p>Claude Code can connect to remote HTTP or local stdio MCP servers. Connected tools become available to the model; resources can be referenced with <code>@<\/code> mentions; and MCP prompts appear as commands such as <code>\/mcp__servername__promptname<\/code>. Claude also defers large tool definitions until they are needed, reducing the context cost of connecting multiple servers. The current setup details are in Anthropic\u2019s <a href=\"https:\/\/code.claude.com\/docs\/en\/mcp\" target=\"_blank\" rel=\"noopener\">Claude Code MCP guide<\/a>.<\/p>\n<p>For the StoriesOnBoard workflow, this separation is visible in the supplied pack. The skills define the method. The <a href=\"https:\/\/storiesonboard.com\/storiesonboard-mcp-server\">StoriesOnBoard MCP server<\/a> supplies the board operations. Without the connector, the skills can still draft a discovery brief and a backlog plan, but they must not pretend that real cards were created.<\/p>\n<h2>How skills work in Codex<\/h2>\n<p>Codex uses the same core idea: a skill is a folder with a required <code>SKILL.md<\/code> plus optional <code>scripts\/<\/code>, <code>references\/<\/code>, <code>assets\/<\/code>, and agent metadata. The official <a href=\"https:\/\/learn.chatgpt.com\/docs\/build-skills\" target=\"_blank\" rel=\"noopener\">OpenAI documentation for building skills<\/a> describes progressive disclosure: Codex first sees a compact catalog of names and descriptions, then reads the full instructions only when a skill is selected.<\/p>\n<p>A Codex skill can be invoked explicitly with <code>$skill-name<\/code>, or implicitly when the task matches the skill description. Local discovery uses a different directory convention from Claude:<\/p>\n<ul>\n<li><code>.agents\/skills\/<\/code> from the current directory up to the repository root for repo-scoped workflows;<\/li>\n<li><code>$HOME\/.agents\/skills\/<\/code> for user skills;<\/li>\n<li><code>\/etc\/codex\/skills<\/code> for shared admin skills;<\/li>\n<li>system-bundled skills supplied with Codex.<\/li>\n<\/ul>\n<p>For wider distribution, Codex plugins can bundle one or more skills and optionally include MCP connections, configuration, and presentation assets. Optional <code>agents\/openai.yaml<\/code> metadata can declare an MCP dependency, control implicit invocation, and provide UI information.<\/p>\n<h3>What the Markdown brief does in Codex<\/h3>\n<p>The supplied <code>daily-reset-kickoff-brief.md<\/code> is not itself a skill. It is task context: a well-designed input that gives the active skills something concrete to reason about. Daily Reset is intentionally tiny\u2014a daily checklist that resets at midnight\u2014but it contains unresolved product decisions about personas, differentiation, editing yesterday, accounts, time zones, history, and v1 scope.<\/p>\n<p>That makes it an excellent test fixture. A weak agent will simply convert the headings into stories. A well-designed skill workflow will challenge the assumptions first, preserve open risks, build the user journey, check missing foundations, slice releases, and refine only the stories that are close to implementation.<\/p>\n<h2>The same five-skill workflow in Claude and Codex<\/h2>\n<p>The Claude pack contains five packaged <code>.skill<\/code> archives. Together they implement a handoff chain rather than one oversized prompt:<\/p>\n<ol>\n<li><strong><code>product-discovery<\/code><\/strong> acts as a skeptical product coach. It challenges vague personas, weak differentiation, untested assumptions, scope creep, and vanity metrics. Its output is a discovery brief; it does not write to the board.<\/li>\n<li><strong><code>story-map-creator<\/code><\/strong> turns the brief or PRD into goals, steps, stories, personas, and release slices. It also runs a foundations pass for necessary baseline work. It previews the full plan and waits for approval before using MCP write tools.<\/li>\n<li><strong><code>story-map-gap-finder<\/code><\/strong> reads the actual map, checks missing journey phases, personas, edge cases, error states, and structural weaknesses, then proposes additions before writing them.<\/li>\n<li><strong><code>story-map-navigator<\/code><\/strong> tracks the current phase and derives unanswered questions from the conversation. It does not write to StoriesOnBoard.<\/li>\n<li><strong><code>story-refiner<\/code><\/strong> performs just-in-time refinement for a selected release or story set, adding full narratives and testable acceptance criteria to existing cards.<\/li>\n<\/ol>\n<figure class=\"wp-block-image size-full\">\n  <img decoding=\"async\" src=\"https:\/\/storiesonboard.com\/blog\/wp-content\/uploads\/2026\/08\/storiesonboard-skill-workflow.jpg\" alt=\"Five-stage product workflow from discovery through story mapping, gap analysis, release slicing, and refinement\" title=\"Five skills from product idea to refined backlog\"><figcaption>The pack separates discovery, map creation, gap analysis, navigation, and just-in-time refinement into focused skills.<\/figcaption><\/figure>\n<p>The design has two important safety properties. First, skills that can change the board check for the connector before planning work that depends on it. Second, every write path includes an approval checkpoint. The agent drafts, presents, waits, writes, and verifies. This is the same human-in-the-loop principle that matters whenever an AI agent can change a shared system.<\/p>\n<p>The earlier article <a href=\"https:\/\/storiesonboard.com\/blog\/five-skills-one-backlog\">Five Skills, One Backlog<\/a> explains why this family was split and how the approval checkpoints evolved. The comparison here adds the portability question: what changes when the same operating method moves from Claude to Codex?<\/p>\n<h2>Moving a Claude skill pack to Codex<\/h2>\n<p>The supplied <code>.skill<\/code> files are ZIP packages containing a skill directory and its <code>SKILL.md<\/code>. Codex does not use Claude\u2019s upload package as its local install format, so the practical migration is to unpack each archive and place the resulting skill folder under <code>.agents\/skills\/<\/code>, or bundle the family as a Codex plugin.<\/p>\n<pre><code>.agents\/skills\/\n\u251c\u2500\u2500 product-discovery\/\n\u2502   \u2514\u2500\u2500 SKILL.md\n\u251c\u2500\u2500 story-map-creator\/\n\u2502   \u251c\u2500\u2500 SKILL.md\n\u2502   \u2514\u2500\u2500 references\/\n\u251c\u2500\u2500 story-map-gap-finder\/\n\u2502   \u2514\u2500\u2500 SKILL.md\n\u251c\u2500\u2500 story-map-navigator\/\n\u2502   \u2514\u2500\u2500 SKILL.md\n\u2514\u2500\u2500 story-refiner\/\n    \u2514\u2500\u2500 SKILL.md<\/code><\/pre>\n<p>Then review four portability points:<\/p>\n<ol>\n<li><strong>Invocation syntax.<\/strong> Replace Claude-facing examples such as <code>\/story-refiner<\/code> with Codex-facing <code>$story-refiner<\/code> where the user instructions mention direct invocation.<\/li>\n<li><strong>Tool dependencies.<\/strong> Make the StoriesOnBoard MCP or plugin dependency explicit. Tool names and permission behavior must match the actual Codex environment.<\/li>\n<li><strong>Claude-only frontmatter or body features.<\/strong> Dynamic context injection, forked execution, or Claude-specific permission fields need a Codex equivalent or a simpler host-neutral instruction.<\/li>\n<li><strong>Output surfaces.<\/strong> Keep the real board as the deliverable. A rendered tracker or preview can help navigation, but it should never replace the shared backlog.<\/li>\n<\/ol>\n<p>This particular pack is relatively portable because its essential behavior lives in Markdown instructions and its external actions are already isolated behind the StoriesOnBoard connector. The most important migration work is dependency declaration, invocation wording, and testing\u2014not rewriting the product method.<\/p>\n<h2>Claude vs Codex: the practical differences<\/h2>\n<table>\n<thead>\n<tr>\n<th>Area<\/th>\n<th>Claude<\/th>\n<th>Codex<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>Direct invocation<\/strong><\/td>\n<td><code>\/skill-name<\/code><\/td>\n<td><code>$skill-name<\/code> or the skills picker<\/td>\n<\/tr>\n<tr>\n<td><strong>Project location<\/strong><\/td>\n<td><code>.claude\/skills\/<\/code><\/td>\n<td><code>.agents\/skills\/<\/code><\/td>\n<\/tr>\n<tr>\n<td><strong>User location<\/strong><\/td>\n<td><code>~\/.claude\/skills\/<\/code><\/td>\n<td><code>$HOME\/.agents\/skills\/<\/code><\/td>\n<\/tr>\n<tr>\n<td><strong>Packaged distribution<\/strong><\/td>\n<td>Claude plugins and <code>.skill<\/code> uploads<\/td>\n<td>Codex plugins; local skill folders for authoring<\/td>\n<\/tr>\n<tr>\n<td><strong>Host-specific controls<\/strong><\/td>\n<td>Rich Claude Code frontmatter, dynamic injection, forked skill execution<\/td>\n<td><code>agents\/openai.yaml<\/code> UI, invocation, and MCP dependency metadata<\/td>\n<\/tr>\n<tr>\n<td><strong>MCP interaction<\/strong><\/td>\n<td>Tools, <code>@<\/code> resources, MCP prompts as slash commands<\/td>\n<td>MCP tools and resources exposed through installed plugins or configured servers<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Neither model is universally better. Claude currently offers a particularly direct path for uploading and invoking packaged skills and adds several Claude Code-specific workflow controls. Codex makes repository scope and plugin distribution explicit, which is useful when skills should travel with a codebase or be installed as a reusable bundle. The right choice depends more on where the team works, how the connector is governed, and how the workflow will be distributed than on the Markdown syntax itself.<\/p>\n<h2>Design rules for reliable MCP skills<\/h2>\n<p>Regardless of host, the same design rules make an agent workflow more dependable:<\/p>\n<ul>\n<li><strong>Give each skill one clear job.<\/strong> Focused descriptions trigger more accurately and keep the loaded context smaller.<\/li>\n<li><strong>Separate thinking from writing.<\/strong> Discovery can be conversational; board changes need explicit approval and verification.<\/li>\n<li><strong>Keep <code>SKILL.md<\/code> concise.<\/strong> Put detailed checklists, schemas, and examples in references that load only when needed.<\/li>\n<li><strong>Detect dependencies early.<\/strong> If the connector is missing, say what remains possible and never claim that external state changed.<\/li>\n<li><strong>Define exit conditions.<\/strong> \u201cBe critical\u201d without a stopping rule becomes an endless interview. \u201cBe thorough\u201d without scope becomes a token sink.<\/li>\n<li><strong>Read before updating.<\/strong> Preserve existing descriptions, annotations, and board structure instead of blindly overwriting them.<\/li>\n<li><strong>Verify the actual destination.<\/strong> A polished chat artifact is not a usable backlog. Read the shared system back after writes.<\/li>\n<\/ul>\n<h2>A practical starting point<\/h2>\n<p>Start with one repeatable workflow that already has a clear input, output, and review point. Keep the domain example small enough to understand end to end; the Daily Reset brief works because the product surface is simple while the decisions are real. Then connect only the systems the workflow genuinely needs.<\/p>\n<p>If the goal is product discovery and backlog building, the useful architecture is straightforward:<\/p>\n<pre><code>product brief\n  \u2192 focused agent skills\n  \u2192 human approval checkpoints\n  \u2192 StoriesOnBoard MCP tools\n  \u2192 verified story map and release slices<\/code><\/pre>\n<p>The skill is what makes the work repeatable. MCP is what makes the result operational. Claude and Codex use different packaging and invocation conventions, but both can support the same disciplined product workflow when those two layers are designed separately.<\/p>\n<p><strong>Want to try the operational side?<\/strong> Explore the <a href=\"https:\/\/storiesonboard.com\/storiesonboard-mcp-server\">StoriesOnBoard MCP server<\/a>, or read the plain-English guide to <a href=\"https:\/\/storiesonboard.com\/blog\/mcp-server-for-product-teams\">MCP servers for product teams<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>MCP skills combine reusable AI workflows with live tool access. See how Claude and Codex handle skills, connectors, packaging, and product backlog work.<\/p>\n","protected":false},"author":13,"featured_media":6446,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[952,7],"tags":[],"class_list":["post-6449","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-product-management","category-story-mapping","resize-featured-image"],"_links":{"self":[{"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/posts\/6449","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/users\/13"}],"replies":[{"embeddable":true,"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/comments?post=6449"}],"version-history":[{"count":0,"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/posts\/6449\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/media\/6446"}],"wp:attachment":[{"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/media?parent=6449"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/categories?post=6449"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/storiesonboard.com\/blog\/wp-json\/wp\/v2\/tags?post=6449"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}