Last updated: July 9, 2026

By the end of this article, you will know how to author reusable Claude Code skills using a temporarily-available smarter model, verify they actually improve output, and deploy the same skill files unchanged across Claude Code, Codex CLI, and Gemini CLI.

Prerequisites

Image: Iwo Szapar / IWO SZAPAR

• Claude Code installed and running locally
• Familiarity with markdown files and frontmatter syntax
• Access to Claude Fable 5 (available on included plans until 12 July 2026; metered thereafter at $10 per million input tokens and $50 per million output tokens)
• Basic understanding of how agents load context files at task start

---

Imagine you are running Claude Opus 4.8 every day for coding tasks. It is capable, fast, and cost-effective. But there is a model that plans better, verifies more carefully, and catches the edge cases Opus misses. What if you could bottle some of that behaviour – not the weights, not the training data, just the written procedure – and hand it to Opus as a standing instruction? That is precisely what one developer did with Claude Code skills, and the results are worth replicating before the window closes.

1. What a Claude Code Skill Is

A Claude Code skill is a markdown file – typically named SKILL.md – stored inside a folder in your project. It carries three things: a name, a description, and plain-language instructions. When you trigger a task that matches the skill’s description, the agent loads and follows those instructions automatically. No weights, no fine-tuning, no API call required.

The format is deliberately minimal. Here is what a working skill file looks like:

---
name: plan-before-edit
description: Require a written plan before making any file edits
---

Before editing any file:
1. Write out what you intend to change and why.
2. List every file affected.
3. State the expected output.
Only begin editing after the plan is written and confirmed.

The agent reads this at task-start and holds itself to the rules you have written. Because the skill is plain text, it is readable, editable, versionable in git, and portable across model changes – the cheapest durable form of model behaviour you can produce.

If you are new to extending Claude Code beyond its defaults, 3 micro tips for working with Claude Code is a useful companion read before going further.

2. Why Let a Smarter Model Write the Skill

The best author of a skill for your daily model is a model smarter than the one you run every day. This is the core insight behind what Reddit commenters have started calling “skill distillation” – using a temporarily-smarter model to write reusable skills for the cheaper model you operate at scale.

The author of the original experiment is careful to correct a common framing error here: nothing actually distils the model. Weights, knowledge, and raw capability stay with Fable 5. What gets extracted is written procedure – how it plans, how it verifies, how it edits. You are not cloning the model; you are capturing its discipline in text.

The evidence is hard to dismiss. The author had Fable 5 author six skills targeting Opus 4.8 as the daily model, then blind-tested every output with an unaware grader. The result: 12 wins, 0 losses, and 2 ties. Three things drove that record – better planning discipline, more systematic verification, and fewer unchecked edits. A rule-of-three that maps directly to the kinds of discipline gaps a skill file is designed to close.

3. How to Author a Skill With Fable 5

Here is the recommended authoring process, drawn from the experiment and validated across all six skills.

Step 1 – Target a discipline gap, not a task.

Do not write a skill called “write tests”. Write a skill called “require-test-plan” that forces the model to state what it will test and why before it writes a single assertion. The gap is the missing planning step, not the task itself.

Step 2 – Ask Fable 5 to write the skill in its own voice, about its own behaviour.

Prompt Fable 5 like this:

You are writing a SKILL.md for yourself.
Describe exactly how you approach [discipline gap] -
the steps you take, in order, with concrete checkable rules.
Write it as standing instructions for an agent.
Include the required frontmatter: name, description.

The phrase “in its own voice, about its own behaviour” is deliberate. You want Fable 5 to externalise its internal procedure, not to summarise advice it has absorbed about the topic.

Step 3 – Add concrete, checkable rules.

Vague instructions like “be thorough” do not change behaviour. Concrete rules do. A good rule is one where you can look at the output and say definitively whether the rule was followed. “List every file you will edit before making any change” is checkable. “Think carefully before editing” is not.

Step 4 – Blind-test with and without the skill loaded.

Run the same task twice. First without the skill. Then with it loaded. Give the outputs to someone who does not know which is which and ask them to pick the better one. If the skill does not produce a measurable win, rewrite it. If it does, commit it to version control and move on to the next discipline gap.

Common mistake: Writing a skill that describes the task rather than the discipline. A skill that says “Write a unit test for every function” describes a task. A skill that says “Before writing any test, state what behaviour you are testing, what the expected output is, and what would make the test fail” describes a discipline. The second is what you want.

4. The Cross-Tool Portability Bonus

Here is where things become interesting for teams using more than one agent tool. The SKILL.md format is an open standard. The same skill files that run in Claude Code also run unchanged in Codex CLI and Gemini CLI.

A skill you author with Fable 5 today can govern Opus 4.8 in Claude Code, a GPT-5.1-based Codex workflow, and a Gemini-powered pipeline – all from a single markdown file checked into your repository. This is not a minor implementation detail. It hints at an emerging standard for agent instructions across competing tools, one that treats written procedure as a first-class artefact rather than a per-tool configuration.

For teams already exploring the wider agent tooling ecosystem, Discover Top MCP Servers at MCP Market is worth a look – MCP servers and skill files are complementary layers of agent behaviour that compose well together.

If you see a skill ignored by one tool but followed by another, it usually means the description frontmatter does not match the trigger pattern that tool expects. Check the tool’s documentation for how it matches skills to tasks – the fix is almost always a one-line edit to the description field.

5. The Window and What to Do With It

Fable 5 was redeployed on 1 July 2026 with included-plan access originally set to end on 7 July. That window was extended to 12 July. After that date, authoring with Fable 5 moves to metered pricing.

The practical implication is clear: if you have discipline gaps in your daily model’s behaviour – inconsistent planning, unchecked edits, missing verification steps – now is the time to have Fable 5 write the skills to close them. A morning’s work authoring six skills, properly blind-tested, is a library of reusable agent discipline that carries forward through every model change and every new tool you adopt.

Because a skill is just text, it travels with you. It does not expire when a model is updated, does not require a retraining run, and does not lock you to a single vendor. That combination of portability, readability, and durability makes it the most practical unit of AI coding improvement available today.

Next Steps

• Identify three discipline gaps in your current daily model – look for recurring output patterns you have to manually correct
• Author a skill for each gap using the Fable 5 prompting approach in Step 2 above
• Blind-test each skill and commit only the ones that win
• Confirm your skills load correctly in any other CLI agent tools your team uses

If you would like help auditing your current agent setup or designing a skill library for your development workflow, get in touch with the team at drs-web.co.uk/contact.

---

Frequently Asked Questions

Q: What is a Claude Code skill and how does it work?
A: A Claude Code skill is a markdown file (SKILL.md) containing a name, description, and plain-language instructions. The agent loads it automatically when a task matches the description and follows the rules – no fine-tuning or API changes required.

Q: What is “skill distillation” and does it actually distil the model?
A: Skill distillation is a term coined by Reddit commenters for using a smarter model to write reusable skills for the cheaper model you run daily. It does not distil the model – weights and capability stay with the smarter model. What you extract is written procedure: how it plans, verifies, and edits.

Q: Can I use the same SKILL.md files in Codex CLI or Gemini CLI?
A: Yes. The SKILL.md format is an open standard and the same files run unchanged in Claude Code, Codex CLI, and Gemini CLI, giving you cross-tool portability from a single version-controlled markdown file.

Q: How do I know if a skill is actually improving output?
A: Run the same task with and without the skill loaded, then have an unaware grader compare the two outputs without knowing which is which. Only commit the skill if it produces a measurable win – the blind-test method is the most reliable validation approach.

Q: How long is Fable 5 available on included plans?
A: Fable 5’s included-plan access runs until 12 July 2026. After that date it moves to metered pricing at $10 per million input tokens and $50 per million output tokens.

Source: https://www.iwoszapar.com/p/claude-code-skills-written-by-a-smarter-model