Port Frontier Workflows to Opus/Sonnet with Agent Skills

The durable gap is method, not only model brand

Much of the gap between “frontier-quality” output and mid-tier models is not only model brand—it is the implicit working method: how goals are compressed, how claims are checked, how failures are recovered, and how reports stay honest.

📑Table of Contents

1. What to encode: Skills, subagents, teams, packages
2. Why codify the working method
3. Official difference: subagents vs agent teams
4. Cost constraints before you add teammates
5. Practice: transfer steps into Skills and team definitions
6. Adoption checklist
7. FAQ
8. Conclusion

For developers who use Claude Code daily, the durable move is to encode that method as Agent Skills and role separation (subagents vs agent teams), so Opus/Sonnet-centric workflows still hold when access or cost envelopes change.

---

Primary sources and scope

This article grounds the comparison, enablement flags, cost constraints, transfer steps, and a go/no-go checklist in the following primary sources:

• Claude Code’s official agent teams and costs docs
• Anthropic’s Skills announcement
• A shippable team package (ccteams on npm / GitHub toffyui/ccteams)

Popularity signals are discovery context only; facts come from primary sources.

---

What to encode: Skills, subagents, teams, packages

Skills and subagents

Mechanism	What you encode	Communication	Cost posture	How it is enabled
Agent Skills	Procedures, failure catalogs, verification recipes (e.g. SKILL.md)	Load on demand	Less always-on context bloat	Product feature (apps / Code / API)
Subagents	Role, tools, model; return results to the parent	Report to main only	Relatively lower	Standard delegation pattern

---

Agent teams and packaging

Mechanism	What you encode	Communication	Cost posture	How it is enabled
Agent teams	Independent sessions + shared tasks	Peer messaging allowed	Higher (~7× in plan mode)	CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 (off by default)
Team packaging (e.g. ccteams)	Multiple subagents + orchestration + playbooks applied as a unit	CLI / plugin	Package + per-agent usage	npm ccteams 0.2.2 / GitHub toffyui/ccteams

---

Sources

Sources (as of July 2026):

• Claude Code agent teams
• Claude Code costs
• Anthropic Skills
• npm ccteams
• GitHub toffyui/ccteams

---

How to read the table

• Skills hold the method
• Subagents are usually enough when you only need a focused result
• Agent teams fit when peers must debate or cross-check
• Packages like ccteams redistribute a team definition

Decide what belongs in SKILL.md before scaling headcount.

---

Why codify the working method

Procedure before a smarter model

Before reaching for a smarter model, check whether you have a reproducible procedure and role definitions.

Frontier behavior often decomposes into:

• Goal compression
• Evidence checks
• Hypothesis-and-test loops
• Recovery after failure
• Honest reporting

If that stays only in chat history, it does not survive a model tier or session change.

---

What Skills package

Anthropic Skills package instructions, scripts, and resources in folders and load them when relevant.

Official properties:

• composable
• portable (same format across Claude apps, Claude Code, and the API)
• efficient (progressive load)
• powerful (may include executable code)

Prefer on-demand skills over bloating always-on project instructions. Because skills can run code, treat untrusted skill packs as supply-chain risk.

---

Practical transfer loop

A practical transfer loop:

1. Have a frontier model draft goal compression, verification steps, and a failure catalog once
2. Have a human review the draft
3. Ship it as a skill

That is the durable vehicle for “port the working method,” not a vague reminder to “be careful.”

---

Official difference: subagents vs agent teams

The communication fork

There are at least two parallelism systems. The fork is whether communication is parent-only or peer-to-peer.

Aspect	Subagents	Agent teams
Context	Own window; results return to caller	Fully independent sessions
Communication	Report to main only	Teammates message each other
Coordination	Main agent manages work	Shared task list + self-coordination
Best fit	Focused tasks where only the result is needed	Work that needs debate / mutual review
Token cost	Relatively lower	Relatively higher

Source: Claude Code agent teams (as of July 2026).

---

Enablement

Agent teams are disabled by default. Enable with either of the following:

• CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in the environment
• The same key under "env" in settings.json

Then describe the task and roles in natural language. Official guidance highlights parallel research/review, clear ownership of new modules, competing debugging hypotheses, and cross-layer work—not sequential same-file edits or dense dependency graphs.

---

Experimental limits

Experimental limits matter operationally:

• In-process teammates do not restore via /resume / /rewind
• Task status can lag
• One team per session
• No nested teams
• Lead is fixed
• Permissions inherit from the lead at spawn

If you do not need peer messaging, prefer subagents.

---

Cost constraints before you add teammates

Plan-mode multiplier

Parallelism trades latency for tokens. Official costs docs state agent teams can use about 7× more tokens than a standard session when teammates run in plan mode, because each teammate is a separate instance with its own context.

---

Official management tips

Official management tips:

• Prefer Sonnet for teammates when coordination allows
• Keep teams small
• Keep spawn prompts focused (teammates may still auto-load CLAUDE.md, MCP, and skills)
• Shut down teammates when done
• Leave the feature off by default until you have a reason

Enterprise averages on the same page (planning anchors, not guarantees):

• About $13 per developer per active day
• $150–250 per month
• Costs remain below $30 per active day for 90% of users

Extra levers:

• Pin simple subagents to model: haiku
• Offload verbose work with skills/hooks
• Watch /usage

---

Reader action

Reader action: pilot with at most three teammates on research/review work; for implementation, split ownership to avoid file collisions. Do not leave every teammate in plan mode for long-running jobs.

---

Practice: transfer steps into Skills and team definitions

Five transfer steps

1. Draft once with a frontier model — goal compression, verification recipe, failure catalog, report format; human review → SKILL.md candidates.
2. Install as project/user skills — on-demand load; avoid always-on instruction bloat.
3. Split subagents by role — tools / model / description matched to the job (e.g. review higher, implement Sonnet, trivial transforms Haiku).
4. Enable agent teams only for peer debate — experimental flag + shared tasks; otherwise stay on subagents.
5. Evaluate packaging for reuse — e.g. npm install -g ccteams, ccteams list, ccteams use <team>, then restart Claude Code. Plugin path: marketplace add toffyui/ccteams, install, reload.

---

Packaging notes (ccteams)

ccteams 0.2.2 is published as an Agent-Team Package Manager for Claude Code:

• Bundles of subagents plus orchestration under .claude/
• CLI and /ccteams:* plugin commands

Before applying third-party packs, confirm:

• License
• Overwrite scope
• Monorepo collision risk

---

Adoption checklist

• ✓ Skills document success criteria, forbidden patterns, and verification commands
• ✓ Subagent model/tools are not oversized for the role
• ✓ Agent teams are justified by true peer communication needs
• ✓ You can explain in one line why CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS is on
• ✓ Team size, plan-mode policy, and shutdown rules are explicit
• ✓ A small pilot measures /usage (or billing) before production use
• ✓ Package license and overwrite range are reviewed

Common failure modes

Common failure modes:

• Multi-mate edits on the same file
• Blocked dependencies when task completion lags
• Messaging teammates that no longer exist after resume

These track the official experimental limits.

For adjacent design topics on this site:

---

FAQ

Q1. Should I start with agent teams or subagents?

Start with subagents when a returned summary is enough. Use teams when mutual critique or cross-review is required (official comparison).

---

Q2. Does nothing happen without the flag?

Correct. Teams stay off unless CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 is set.

---

Q3. When do costs spike?

More teammates and plan mode. Official guidance: ~7× in plan mode; prefer Sonnet, small teams, early shutdown.

---

Q4. Are Skills enough alone?

Skills encode method. Parallelism and role isolation need subagents/teams. Use both.

---

Q5. Is a third-party team package safe?

Skills/agents can execute code and write files. Verify primary repo, license, collision guards, and trust the publisher.

---

Conclusion

Convert frontier advantage into a verifiable working method, then run it on Opus/Sonnet with Skills plus role separation.

Today’s next actions:

1. Complete the first three checklist items
2. Pilot a small review team under the official flag
3. Measure /usage before wider adoption

Skip agent teams when peer messaging is unnecessary, and measure plan-mode multipliers early.

Related articles:

• Herdr vs tmux for AI coding agents: state sidebar, install, and migration checks
• Gemma 4 Same-Name Update: FA4 Prefill, Tool Fixes, Re-pull Guide
• How to Assess an AI-Native Org: Enabled, Ready, Native Checklist

Related new article:

• Obsidian Visualization Tools: Graph, Canvas, Excalidraw (2026) – This published update adds current operational context for Port Frontier Workflows to Opus/Sonnet with Agent Skills.
• Kimi K3 Practical Guide: Pricing, Benchmarks, and API Caveats – This published update adds current operational context for Port Frontier Workflows to Opus/Sonnet with Agent Skills.