Claude Skills Replaced Half My Workflow. Subagents Did the Other Half.

Most people are still arguing about whether AI can write production code.

Meanwhile, two features quietly shipped inside Claude Code that completely rewrote how I work. Not "made me 20% faster." Not "saved me an hour a day." Actually rewrote what my day looks like.

Skills and subagents.

If you haven't touched either of these yet, you're using Claude Code the way someone in 2008 used the iPhone — as a slightly better version of the thing they had before. The whole point is sitting right there and most people are walking past it.

Here's what they actually do, why they matter, and the exact setup I've been running for the last few months.

What Even Is a Skill

A Skill is a markdown file with frontmatter that Claude auto-invokes when the task matches.

That's it. That's the whole feature.

---
name: kamilia-script
description: Use when the user asks to write or revise a short-form
  video script for the Kamilia presale condo project in Langley, BC.
---

# Voice
- 30-40 seconds, conversational
- Open with a hook, close with a clear CTA
- Never say "luxury living" or "act now"

# Structure
1. Hook (3 seconds)
2. Problem the buyer feels
3. What Kamilia solves
4. CTA

Drop that in ~/.claude/skills/kamilia-script/SKILL.md and from now on, every time I say "draft me a Reel for Kamilia," Claude automatically loads that file and follows the rules. No copy-paste. No "remember to do X." No re-explaining context for the hundredth time.

You've just turned tribal knowledge into a tool the model can pick up by itself.

I have skills for:

Writing blog posts in my voice (the rules that wrote this post)
Generating short-form video scripts for client projects
Reviewing UI changes against my design system
Running n8n workflow audits
Polishing landing pages for my portfolio

Every one of them used to live in my head, or in a Notion doc I'd paste into the chat every time, or — worst case — nowhere at all, just hoping I remembered.

Now they're files. The model finds them. The model uses them. I don't have to remember anything.

The Part That Made It Click

Here's the moment Skills stopped being a neat feature and became the thing I'd build my workflow around.

I asked Claude to add some animations to my portfolio. Without me prompting it to, without me even knowing the skill existed, it auto-loaded the animate skill, announced what it was doing, and followed a checklist for purposeful motion design.

I didn't tell it to. The description on the skill said "use when the user mentions adding animation, transitions, micro-interactions" — and Claude matched my request against that and pulled in the file.

That's the leap. Skills are not "prompts you save." They're conditional capabilities the model decides to load.

Once that clicked, I started thinking about my whole workflow differently. Anywhere I had a repeatable process — review this, write this, polish this, harden this — that's a skill. Once. Forever.

Then Subagents Took Out the Other Half

Skills handle what to do. Subagents handle who does it.

A subagent is a specialized Claude instance with its own context window, tools, and focus. You dispatch it like a task and it goes off, does the work, and reports back. The main session doesn't pollute its context with the search results, the file dumps, or the dead ends.

The subagents I actually use:

Explore — read-only search agent. When I need to find every place a function is referenced, or trace a config value through 40 files, I dispatch Explore. It burns through the codebase in its own context and hands me back the summary. My main session never sees the noise.

Plan — architect agent. Hands me back a phased implementation plan with file lists and tradeoffs. I read it, push back, and only then start writing code.

general-purpose — catch-all for multi-step research tasks. "Audit this branch for what's left before we can ship." "Figure out why the build is 2× slower than last month." It goes, it digs, it reports.

Custom ones — I've built a few of my own. A claude-code-guide agent for answering "how do I do X in Claude Code." A frontend-design agent that follows my exact aesthetic rules.

The mental model that finally made this stick: main session is the manager, subagents are the team.

The manager's job is to think clearly. The team's job is to go gather information and come back with the relevant findings. You don't want the manager reading every file in the repo. You want the manager making decisions with a clean head.

What This Actually Looks Like Day-to-Day

Real example from this week.

I wanted to add a new section to my portfolio. Used to be: I'd open the editor, start poking around, hit Claude with a vague prompt, and we'd iterate for an hour. Half of that hour was Claude re-discovering my codebase every single time.

This time:

I told Claude what I wanted to build.
The brainstorming skill auto-loaded and walked me through requirements before any code got written.
I asked for an implementation plan. The Plan subagent ran in parallel, came back with a phased breakdown.
I approved it. The frontend-design skill auto-loaded for the actual build.
I asked it to verify the change worked. The verification-before-completion skill kicked in and made it actually run the dev server, not just claim success.

I touched the keyboard maybe four times. The output was better than what I would've shipped manually, because every step had a discipline attached to it that I no longer had to remember to apply.

That's not "AI coding faster." That's a different kind of work entirely.

The Uncomfortable Take

Skills and subagents have been available for months now. Most developers I talk to still haven't built a single one.

Here's why I think that is — and it's not lazy, it's something more interesting.

People are still in the "treat the AI like a prompt box" mindset. Type a question, get an answer, type another question. That's the chat interface. That's what everyone learned with ChatGPT in 2023.

Skills and subagents require a different mental model. You're not chatting. You're designing a system. You're saying: "Here's the rule I want followed every time this class of task shows up. Here's the agent I want spawned for this kind of work. Here's the discipline I want applied without me having to ask for it."

That's engineering. That's actual systems thinking. And it takes a couple of weekends to build up the muscle.

But once you've built it, you don't go back. I don't write blog posts without my writing skill loaded. I don't refactor without dispatching Plan first. I don't claim a feature is done without verification-before-completion gating it.

The compounding effect is the same one I wrote about with Claude Max: behaviors stack. A skill makes a subagent more disciplined. A subagent gives a skill better context to work with. The whole thing turns into a workflow that's running circles around anyone still typing prompts into a box.

What I'd Tell You to Build First

If you're reading this and you haven't touched either feature, start here.

Build one skill. Pick a task you do over and over and explain in plain English every time. Writing PRs. Writing commit messages. Reviewing code for a specific pattern. Generating content in a specific voice. Anything you've ever copy-pasted from a Notion doc into Claude is a skill waiting to happen.

mkdir -p ~/.claude/skills/my-first-skill
# create SKILL.md with frontmatter + your rules

Use it for a week. Refine the rules every time Claude gets it slightly wrong. By the end of the week you've turned tribal knowledge into a reusable capability.

Dispatch one subagent. Next time you'd normally ask Claude to "search the codebase for X," dispatch the Explore agent instead. Watch how clean your main session stays. Watch how much more accurate the answer is because Explore had room to actually read 50 files instead of cherry-picking 3.

That's the on-ramp. Two small changes, one week, and you'll feel the gap between how you used to work and how you work now.

The Fence Is Still on Fire

Last time I wrote about going all-in on AI tools, I said the fence was on fire and every week you spent evaluating was a week your competitors spent shipping. That was a month ago.

The fence is more on fire now. Skills and subagents are not the ceiling — they're the floor. Whatever ships next is going to make this look quaint.

You don't have to use any of this. You can keep writing every prompt from scratch, keep dumping context manually, keep treating Claude as a fancier autocomplete. That's a choice.

But the people building systems around the model are about to make the people prompting the model look like they're typing in slow motion.

Build a skill. Dispatch a subagent. Stop typing.