Claude Opus 5 and Agent Skills: What Changed

What shipped on 24 July 2026

Claude Opus 5 launched 24 July 2026, priced at $5 per million input tokens and $25 per million output tokens, unchanged from its predecessor, Opus 4.8. It's now the default model on Claude Max and the strongest model available on Claude Pro. Anthropic's stated gains are in agentic coding, computer use, long-horizon knowledge work, and maths, alongside a specific improvement in multi-agent coordination: teams of subagents running writer-verifier patterns, with few reported cases of agents overwriting each other's work.

None of that is a claim about a new SKILL.md field or a new discovery mechanism. The skill format. Covered in full in What Are Agent Skills?. Is exactly what it was before Opus 5 shipped. What changed is the model reading and executing skills, and that has real consequences for how a skill should be written, even though the file it's written in hasn't moved.

This piece covers three things: what longer autonomous runs mean for the shape of a skill's instructions, what better multi-agent coordination means for how you split work between skills and subagents, and what Claude Managed Agents loading skills straight from a GitHub repo means for how skills get deployed.

Where Opus 5 sits in the lineup

Claude Sonnet 5 remains the balanced tier and Claude Haiku 4.5 the fast, cheap tier. Nothing about which tier you're on changes whether skills work. Skill discovery and loading is a property of the agent (Claude Code, Claude Desktop, Claude Cowork, and so on), not the underlying model. What changes with a stronger model underneath is how much of a skill's instructions the agent can execute unattended before it needs a check-in, and how reliably it can coordinate with other agent instances doing related work. Both of those are worth taking seriously when you're deciding how to write the next skill you build.

Longer autonomous runs raise the ceiling on what's worth encoding

A skill that spells out a five- or six-step process is making a bet: that the agent following it will still be on-track by step six, not drifting toward its own interpretation of what "finish the task" means. That bet used to be more conservative than it needed to be, because a shorter effective attention span meant a long, unsupervised procedure was more likely to lose the thread partway through, skipping a verification step, or quietly reinterpreting an instruction two steps back.

Anthropic's stated gains in agentic coding and long-horizon knowledge work point the other way: an agent that can sustain a longer autonomous run without losing the thread makes a longer, more detailed procedural skill pay off more than it used to, not less. That's the opposite of what you might assume. You might expect a more capable model to need less hand-holding, and in a narrow sense that's true. But a skill's job was never to hand-hold a capable model through a task it could already do unaided. Its job is to encode your process (the specific order of steps, the specific checks, the specific way your team wants something done) and a model that can carry that process further without drifting from it makes writing that process down more valuable, not less.

Worked example: a skill built to run longer

project/
└── .claude/skills/
    └── release-prep/
        └── SKILL.md

---
name: release-prep
description: Use when preparing a release, compiling the changelog, running the full test suite, tagging the version, and drafting release notes.
---

# Release Prep

Work through these in order. Do not skip ahead, and do not mark the release ready until every step below is confirmed.

1. Compile the changelog from merged PRs since the last tag.
2. Run the full test suite, not just the changed files' tests.
3. Confirm the version number follows semver relative to the last tag.
4. Tag the release only after steps 1–3 pass.
5. Draft release notes from the changelog, grouped by feature, fix, and breaking change.
6. Flag any breaking change that isn't called out explicitly in the notes.

A six-step, strictly ordered procedure like this used to be a reasonable place to worry about drift. An agent losing track of "don't tag until tests pass" by the time it reached step 4. That's exactly the kind of long, sequential, low-tolerance-for-drift process that benefits most from a model built for sustained agentic work.

Multi-agent coordination: writer-verifier patterns without collisions

The other headline gain is coordination between multiple agent instances working on related pieces of the same task, specifically, writer-verifier patterns where fewer agents step on each other's output. That matters for skill design because it changes a real constraint that used to shape how you'd split work.

Previously, running two subagents against shared state carried a genuine risk: one agent's edits clobbering the other's, or both agents assuming they had sole ownership of a file or a draft. That risk pushed people toward either running subagents on strictly separate slices of work with no overlap, or building extra coordination logic into a skill's instructions just to guard against collisions. Better coordination behavior lowers that risk, which means you can compose skills as roles (a writer and a verifier working on the same deliverable) more confidently than before.

project/
├── .claude/skills/
│   ├── spec-writer/
│   │   └── SKILL.md
│   └── spec-verifier/
│       └── SKILL.md

---
name: spec-writer
description: Use when drafting a technical spec document from a set of requirements.
---

# Spec Writer

1. Read every requirement in the brief before writing a line.
2. Draft section by section. Do not skip ahead.
3. Flag any requirement you can't reconcile with another, rather than silently picking one.
4. Hand off the draft for verification before treating it as final.

---
name: spec-verifier
description: Use when checking a drafted technical spec against its original requirements for completeness and contradictions.
---

# Spec Verifier

1. Check that every requirement in the brief has a corresponding section in the draft.
2. Flag any section that isn't traceable back to a requirement.
3. Do not rewrite the draft yourself. Report issues back to the writer.

Two subagents, one loading spec-writer and the other spec-verifier, can work against the same draft with less risk of one silently undoing the other's work. Neither skill's instructions need to carry defensive coordination logic ("check if another process has already touched this section first"). That's exactly the kind of overhead better multi-agent handling starts to absorb.

This is the same underlying distinction covered in Agent Skills vs Subagents: a skill shapes how work gets done, a subagent decides who does it and where. What's changed with Opus 5 isn't that distinction. It's that the coordination cost of running several subagents against related work has come down, which makes composing skills-as-roles a more practical pattern than it used to be.

Claude Managed Agents: skills straight from a GitHub repo

Claude Managed Agents can load skills directly from a GitHub repository. Skills placed in the repo's root .claude/skills directory are discovered automatically at session start. There's no separate upload step and no copying a folder into a local agent-specific path.

your-repo/
├── .claude/
│   └── skills/
│       ├── deploy-checklist/
│       │   └── SKILL.md
│       └── incident-writeup/
│           └── SKILL.md
├── src/
└── README.md

Commit a skill to that path, and any Managed Agent pointed at the repository picks it up the next time it starts a session. There's no meaningfully different authoring step here. It's the same SKILL.md you'd write for any other agent. What's different is the install target: the repository itself, rather than a directory on a specific machine or a specific agent's local skills folder.

What this changes about deployment

For most of this format's life, "installing" a skill has meant getting a folder into a particular agent's directory, a laptop's ~/.claude/skills/, a project's .claude/skills/, or wherever the agent you're targeting expects it, per the platforms page. Managed Agents reading straight from a repo's root collapses that into one step for anyone running agents against that codebase: commit the skill, and it's live for every Managed Agent session against that repo from that point on.

That's a meaningful simplification for team workflows specifically. A skill added in the same pull request as the feature it operates now ships with that feature, no separate rollout to a fleet of individually-configured agents. It's worth being precise about what we do and don't know here: the brief confirms the discovery mechanic (root .claude/skills, read at session start) but nothing beyond that about scoping across multiple repos or how conflicts between repo-level and other skill sources are resolved. Treat anything past the core mechanic as unconfirmed until you've checked current documentation.

Our take: how skills should be written now

Our take: three adjustments are worth making in light of what actually changed.

Write skills as complete procedures, not shorthand. An under-specified skill used to get corrected mid-run by a human noticing drift after a step or two. A model built for longer unsupervised runs will follow an ambiguous instruction further before anyone notices, which means the instruction needs to be right from the start, not merely good enough to nudge the agent in roughly the right direction.

Reconsider skills you split up purely to manage attention span. If you ever broke one long procedure into two or three separate skills specifically because a longer single pass tended to drift, it's worth checking whether that split is still buying you anything. It may be simpler (and more reliable) as one coherent skill again.

When you do split work across subagents, write skills as named roles. spec-writer and spec-verifier beat a single "do the whole thing" skill loaded by one subagent trying to both produce and check its own output. Better coordination behavior is precisely what makes this pattern safer to lean on than it used to be.

Troubleshooting: skills written for a shorter attention span

A few specific patterns are worth auditing in existing skills now that the model underneath has changed:

Frequent, unnecessary check-in prompts. A skill with "confirm with the user before continuing" scattered after nearly every step was often a workaround for a model that tended to drift without a nudge. If those checkpoints exist purely as a drift guard rather than because the step genuinely needs human sign-off (a destructive action, an irreversible commit) they're now more likely to interrupt a run that would have completed correctly on its own.

Fixed output paths that assume a single running instance. A skill that always writes its output to the same file path breaks the moment two subagents load it concurrently, whichever model is underneath. This was a lower-probability problem when running multiple subagents against related work was itself less common; it's worth checking for explicitly now that writer-verifier compositions are a more practical pattern.

No explicit "not final until verified" instruction. If a skill's output is meant to be checked by a second pass before it's treated as done, say so directly in the instructions rather than relying on whoever orchestrates the subagents to remember to add a verification step separately.

Where to go next

If you're deciding how to split a task between a skill and a subagent at all, Agent Skills vs Subagents covers the underlying trade-off in full. If you haven't looked at the file format itself recently, The SKILL.md Format Explained is unchanged but worth a refresher. And if you're auditing what you've already installed, How AI Agents Discover and Activate Skills covers the matching mechanism a stronger model doesn't bypass. A skill still only loads when its description matches the request in front of it. Browse the current catalog at getclaudeskills.com/skills, filtered by platform if you're building specifically for Claude Code or Claude Cowork.