Essential Knowledge Now That Fable 5 and Sonnet 5 Are Out!
Those Who Just Say 'It Got Smarter' vs. Those Who Gain an Edge
In June 2026, Anthropic released the Claude 5 family. This includes the top-tier Claude Fable 5 (which launched June 9, faced a temporary halt due to export regulations, and returned fully on July 1) and the daily workhorse Claude Sonnet 5 (released June 30).
Social media timelines were filled with talk of 'it got smarter' and 'amazing benchmarks.' But let me ask you honestly—has your way of using Claude changed just because the model did?
If you're just typing questions into a chat box and getting answers, and the only difference is that the quality of the answer improved slightly because the model is smarter... you're missing out on something huge.
With this 5th generation, Anthropic isn't just pushing 'intelligence' as the main evolution. The highlight of Fable 5 is 'long-term autonomous work.' It’s the ability to break goals down into sub-tasks, delegate to tools or other agents, verify results, and course-correct when things go wrong—all while keeping the objective in sight. Sonnet 5 is even being called the 'most agentic Sonnet ever.'
In short: You only receive the full value of these new models when you use them as agents. Using them only for chat is like buying a sports car and only driving it in first gear.
The framework for this agent operation is the set of features built into Claude Code. In this article, I will summarize them all.
One rule for this article: I will only cover things that anyone can use immediately after installation or that anyone can introduce later. My own environment has dozens of custom skills built for specific projects, but I won't mention those personal dependencies. Everything written here can be replicated in your environment today.
Free PDF gift on how to use Claude, ChatGPT, Gemini, and AI agents
👇
https://foam-violet-8b3.notion.site/AI-PDF-393eb03cfae1801ab564c32ab4614fb9?source=copy_link
Chapter 1: Why 'Agent Functions' Are the Core of the 5th Generation
The Direction of Model Evolution Matches the Use Case
First, let's look at the map of Claude Code's agent functions. It is divided into three layers.
Layer 1: Sub-agents—The main Claude calls upon 'clones' of itself to delegate work.
Layer 2: Workflow—A system for organizing multiple clones to perform parallel research or mutual verification.
Layer 3: Skill—A system where you provide a manual, and Claude reads it to act as an expert.
These three layers existed in Claude Code before the 5th generation. What changed is that the models themselves are now being built specifically for this way of working.
Look again at the official description of Fable 5: 'breaking down sub-tasks,' 'delegating to other agents,' 'verifying results,' and 'course-correcting.' This is exactly what Layer 1 and Layer 2 are. The design philosophy of the model and the features of Claude Code are now perfectly aligned.
'Delegation' Only Works When the Delegatee is Smart
The ability to delegate to clones existed before, but honestly, there were many times where I felt uneasy about the results and ended up re-checking everything myself. It was like a manager who delegates to a subordinate but checks every single detail out of worry. This halves the value of delegation.
When the model gets smarter, this changes qualitatively. You can trust the delegated research. Ten agents running in parallel become the strength of ten people, rather than ten mediocre results. Furthermore, 'mutual verification' (where one AI's conclusion is intentionally challenged by other AIs to improve accuracy) doesn't work unless the verifiers are smart. If two unintelligent entities argue, it's just a waste of time.
The value of agent functions is determined by the multiplication of 'Intelligence of 1 unit × Number of units.' The evolution of the model has drastically pulled up one side of this equation. The other side (number of units and organization) is what you control through these features.
Chapter 2: Default Agent Functions [Available to Everyone Today]
Sub-agents—Delegating 'Research' to Clones is the Right Answer
Claude Code comes with standard clones for different purposes. As of July 2026, these are the three standard types:
general-purpose: A versatile type for complex research or multi-step tasks.
Explore: Specialized in searching code and files. Read-only, safe, and fast.
Plan: Specialized in creating implementation plans. It returns a plan of which files to touch in what order.
You just ask in Japanese, 'Research this with a sub-agent.' Often, it will judge the nature of the task and use them automatically without being told.
The best part about clones is that the massive amount of information they read through does not flood your main conversation. Have you ever experienced your conversation memory (context) getting full during long tasks? With the clone method, the research process stays with the clone, and only the 'conclusion' reaches your conversation. Plus, you can run multiple clones simultaneously to advance research in three directions at once.
New Common Sense for the 5th Gen—'Differentiating Models for Commander and Hands'
This is the most important takeaway.
In Claude Code, you can specify which model to use for each sub-agent. You can specify it at the time of calling or write it in the definition file for a custom clone. Now that the 5 family is out, this differentiation has become incredibly effective.
The recommended lineup is:
- Commander (Main Conversation) = Fable 5: The brain responsible for overall judgment, planning, and final checks.
- Hands/Feet (Parallel Sub-agents) = Sonnet 5: The practical force for research, implementation, and verification.
- Chores (Simple Tasks) = Haiku 4.5: For light work like organizing files.
Why is this so hot right now? Because Sonnet 5 delivers performance that rivals Opus 4.8 but at a lower cost. In the previous generation, the 'correct' answer was to do things carefully with one top-tier model. Now, running five Sonnet 5 units under the command of one Fable 5 is a realistic and superior choice.
Switching models is just a /model command. Just type /model claude-fable-5. If you haven't tried it, start here.
Custom Sub-agents and Plan Mode—Designing 'How to Delegate'
The mechanism to define the 'personality' of a clone is also included by default. Just place a Markdown file in the .claude/agents/ folder and write the role, like 'You are a security review expert. Check only from this perspective.' You can also specify the model in this file.
While the specific content I create is personal, the 'mechanism to create them' is distributed to everyone. Everyone has the same kitchen, even if the recipes differ. Since it's just Markdown, you can share it via Git so the whole team has the same clones.
As you delegate more, safety becomes crucial. Plan Mode allows Claude to output a plan of 'I will follow these steps' without touching a single character in your files, waiting for your approval. Background execution lets you run time-consuming processes in the back, and Scheduled execution allows for periodic operations like 'run this check every morning at 9 AM.'
Workflow—'Army Management' and Adversarial Verification
Layer 2 is Workflow. This is a system to organize multiple sub-agents with scripts to move them in a set sequence. For example:
- Run reviews simultaneously with three teams: 'Bug Team,' 'Performance Team,' and 'Security Team.'
- Have another agent challenge the findings: 'Is that really a bug? Try to argue against it.'
- Only include findings in the final report that at least two out of three verifiers agree are 'real.'
This process of intentional counter-argument (adversarial verification) drastically reduces the 'plausible but wrong' points common in AI. A conclusion agreed upon by three independent units is far more reliable than the assertion of one. It's the same logic as double-checking in human organizations.
As said in Chapter 1, this feature lives or dies by the intelligence of the verifier. Now that the opposing side is Sonnet 5 class, we are at the dawn of practical use.
Chapter 3: Skill—Models Change, Skills Remain as Assets
The Reality of Skills is Just a Markdown Folder
Layer 3: Skills. To reveal the secret, it's surprisingly simple—it's just a folder with a `SKILL.md` manual inside.
The manual describes what the skill does, what requests trigger it, the steps to take, and common failures/workarounds. The moment the conversation matches the criteria, Claude automatically reads it and acts as an expert. You don't even need to say 'use the skill.'
I want to emphasize this: Models will be replaced, but skills remain. A skill made for the 4th generation works in the 5th. In fact, because the model is smarter, the execution accuracy of the same manual improves. Model evolution is a gift to everyone, but the asset of 'skills' only remains for those who build them. This is where the gap is created.
There are only two placement rules: ~/.claude/skills/ for your entire machine, or the project's .claude/skills/ for just that project. Project-side skills can be committed to Git and automatically distributed to the whole team.
skill-creator—Automating Asset Creation with the 'Skill to Make Skills'
For those who find writing manuals tedious, there is the official Anthropic skill-creator. With this, you can just say, 'Turn this series of tasks we just did into a skill,' and Claude will write the SKILL.md and place it in the correct location itself.
This starts a loop: ① Do a task with Claude → ② Have it turn the successful procedure into a skill → ③ Reproduce it with one word next time, and if it fails, 'add that lesson to the skill.' The more you use it, the smarter your specific Claude Code becomes.
The reason this loop is more valuable in the 5th generation is that the models have become better at following long manuals. Even if the manual becomes long and detailed, it's less likely to miss instructions in the middle.
Chapter 4: Official Skills & Plugins Anyone Can Install
Start with the Official '4-Piece Document Set'
Anthropic publicly releases general-purpose skills for free in their official GitHub repository (anthropics/skills). Just copy them to the locations mentioned in the previous chapter. The first ones to get are the four document-related skills:
- docx: Generate/edit Word files (supports headings, TOC, tables)
- pdf: Merge, split, fill forms, and extract text from PDFs
- pptx: Generate/edit PowerPoint slides
- xlsx: Generate/edit Excel sheets
You might wonder if an AI can really make Word files—it's absolutely at a professional level. I almost never manually create the first drafts of reports, proposal slides, or spreadsheets anymore. For developers, skill-creator and mcp-builder (for DIY MCP servers) are great, and for writers, humanizer types that detect AI writing quirks and fix them are very effective.
Plugins—Packs of Skills, Agents, and Connection Settings
Plugins are the advanced version of installing skills one by one. They package skills + custom agents + external connection settings + commands into one package, installed via the /plugin command from a marketplace.
Business packs for marketing (SEO audits, competitor analysis), legal (contract review), research (academic paper search), and development (various SDK support) are available. One note: many of these business plugins require separate account authentication for the corresponding external service. If it doesn't work after installing, that's usually why.
Chapter 5: MCP—The 'Common Outlet' for External Services
Autonomous Work Requires Tools
MCP (Model Context Protocol) is an open standard released by Anthropic in November 2024. Simply put, it's a 'common outlet to connect AI with external services.' If a service provides an MCP server, Claude Code can connect with a single command: claude mcp add <name> <connection>. For services requiring authentication, you just go through the usual OAuth in your browser once.
Major supported services include Figma, Canva, Notion, Google Drive, Slack, Gmail, Discord, Google Calendar, Ahrefs, HubSpot, ElevenLabs, and more. All are things anyone can connect to if they have an account.
In the context of the 5th generation, the value of MCP has clearly risen. Fable 5's selling point of long-term autonomous work is essentially the ability to 'keep running toward a goal while switching tools.' Picking up discussions on Slack, checking specs in Notion, fixing code, and reporting results via Gmail—the more tools (MCP) are connected, the further this 'running distance' extends. The vast 1M token context exists for these long tasks spanning multiple services.
But 'Don't Over-install' Still Applies
When you connect an MCP server, the tool list and manuals for that service are loaded into Claude's memory. Connecting too many crowds the conversation capacity. Even if the context has expanded to 1M, cluttering the mind with irrelevant tool definitions is a loss. Even if your desk gets wider, if you line up tools you don't use, your work efficiency drops.
The tip for operation remains simple: 'Keep only what you use daily, and only enable others when needed.' Another tip is handling authentication. Committing API keys directly to Git is a classic mistake. Get into the habit of putting keys in environment variables. This is a legacy from those who came before you.
Chapter 6: What Order Should I Introduce These In?
5th Gen Implementation Route: 'Step 0 + 4 Steps'
Step 0: Switch to 5th Gen Models (Right now, 1 min)
Use the /model command to set the main to Fable 5 (or Sonnet 5). Everything in this article depends on the intelligence of the model, so make the foundation the latest first.
Step 1: Use Default Sub-agents (Today)
Don't install anything; just add a word to your usual requests. 'Research this in parallel with sub-agents' or 'Just make a plan first.' Get the feel for delegating to clones here.
Step 2: Install Official Document Skills + skill-creator (This week)
If you create documents, this alone will pay for the effort.
Step 3: Turn One Routine Task into a Skill (This month)
Pick one task you do every week and say, 'Turn this procedure into a skill.' The moment that first one works, your mindset will shift from 'using AI' to 'growing your own AI.'
Step 4: Connect 2-3 Daily Services via MCP (When needed)
Only connect things you use every day. Slack and Notion are enough to start.
Common Failure Patterns
The most common is starting from Step 4. It's flashy, so I understand the feeling, but if you connect 10 MCPs without being able to use the foundational features, you'll just be left with the impression of a 'heavy tool where I don't know what it can do' and quit. Please follow the order: Foundation (Standard Features) → Form (Skills) → Connection (MCP).
Another is trying to make a skill perfect from the start. A skill is just Markdown, so you can fix it anytime. Start with a 60% version and add to it every time it fails. This way of 'growing' it results in a stronger tool.
Summary: Model Evolution is Automatic. The Gap in Utilization is Not.
Compressing the main points into three lines:
- The core of Claude 5th Gen (Fable 5 / Sonnet 5) is 'long-term autonomous work.' Unless you use it as an agent, you miss out on the evolution.
- The framework is built into Claude Code: Sub-agents, Workflow, Skills, and MCP. Differentiating Fable 5 as Commander and Sonnet 5 as Hands is the new common sense.
- Official skills and plugins are free for everyone. Models change, but the asset of skills remains only for those who build them.
Model updates are distributed equally to everyone without effort. But whether you use that new brain as a single chat partner or as the commander of an army depends on your design. Start with Step 0, switching with /model. And try adding 'Research this with a sub-agent' to your next request.
