Claude Code: 6 Common Mistakes and a Checklist to Catch Them

"I built a CLAUDE.md, made a skill, even wired up a hook, is any of this actually connected right?"

Six mistakes account for most of the trouble in this stretch: a CLAUDE.md so long it costs you every session, a skill you built that Claude never calls, a subagent that slows things down because you used it on a job too small for it, a plugin you installed and never touched again, automation piling up until you lose track of what's even running, and a scheduled task that just won't fire because of a plan or platform condition. Last lesson got you handing off the start button to hooks and schedules; today's about checking which of the five tools tripped you up, and closing out the track. If you're here confused about where things went wrong, this lesson alone covers it.

Track checklist

Here's everything you've done by hand once already, somewhere across the last six lessons. Reading about something and having actually done it are different things, so mark each one yes or no, honestly.

1. I opened .claude and ~/.claude and confirmed where each of the five tools actually lives.
2. I wrote formatting and naming conventions into my project's CLAUDE.md and confirmed they loaded with /context.
3. I registered a marketplace, installed one plugin for real, and confirmed it under the Installed tab in /plugin.
4. I turned a repeated procedure into a SKILL.md and actually ran it as a slash command.
5. I created a subagent file, delegated to it for real, and got back a summarized result.
6. I wired up one hook, confirmed it registered in /hooks, and actually triggered it.
7. I picked one scheduling method, cloud routine or desktop scheduled task, and confirmed its plan and platform requirements.

The 6 most common mistakes

Where the misses land is pretty predictable. Traps flagged earlier in the track are exactly where people trip again here.

Mistake 1: A CLAUDE.md so long it costs you every session

If sessions feel a little sluggish to start, and Claude starts missing rules that actually mattered, this is the symptom. As confirmed in Lesson 2, CLAUDE.md loads into context in full every time a session starts, and the cause is usually pushing past the 200-line guideline by stuffing in reference material or tutorials that don't belong there. Keep it under 200 lines, and move anything that isn't always needed into a skill, as covered in Lesson 4.

Mistake 2: A skill you built that Claude never calls

If calling it directly with /skill-name works fine, but it never shows up with a description in the menu, or Claude just doesn't reach for it on its own in relevant conversation, this is the symptom. As flagged in Lesson 4, the cause is usually a vague description, or broken indentation or a missing space after a colon in the frontmatter YAML that leaves the body readable but the frontmatter parsed as empty. Rewrite description around a specific situation, and reopen with claude --debug to check for parsing errors.

Mistake 3: A subagent on a job too small for it

If a job as small as checking one file's value still opens a new context and makes you wait for a result to come back, this is the symptom. As confirmed in Lesson 5, subagents are designed for side work big enough to fill the conversation with search results or logs, and the cause is delegating a quick check that falls short of that bar. Do anything you need to watch live, or anything that finishes fast, yourself, and save subagents for side work that would actually clutter the conversation.

Mistake 4: A plugin you installed and never touched again

If your skill menu has grown but you can't remember what you installed or why, this is the symptom. As flagged in Lesson 3, the cause is usually installing first without checking the inventory beforehand, and Claude Code separately surfaces plugins unused for over 2 weeks and over 10 sessions under "Not used recently" (August 2026 behavior). Check a plugin's inventory, skills, hooks, MCP servers it bundles, before you install, and periodically clean out what you're not using from the Installed tab in /plugin.

Mistake 5: Losing track of what runs automatically

If you can't explain why a file just got edited automatically, or why a notification just showed up, this is the symptom. As flagged in Lesson 6, the cause is usually leaving a hook's matcher empty or too broad, so it fires in situations you never intended. Keep matcher as narrow as possible, and check back on /hooks for what's currently registered every so often.

Mistake 6: A scheduled task blocked by plan limits

If the report draft that was supposed to show up on the first of the month never does, this is the symptom. As confirmed in Lesson 6, cloud routines, which need to run even with your computer off, aren't supported on the Free plan, and desktop scheduled tasks skip a run entirely while your computer's asleep and only catch up the single most recent one within the last 7 days. If your computer's off a lot, check the plan requirement for cloud routines first; if it's a local schedule, either keep your computer awake or build a safety net into the prompt itself that assumes a run might get missed.

After the journey ends

Five or more checks on that list, and you've made it through all five Growth Ladder tracks. Track 1 had you talking to AI for the first time. Track 1.5 set you up with artifacts and projects as a workspace. Track 2 connected outside services. Track 3 moved you into a terminal and fired up Claude Code for the first time. This track tamed it your own way, with CLAUDE.md, skills, subagents, and hooks and schedules.

There's a direction to go deeper, too. Agent views, agent teams, and dynamic workflows, mentioned in passing back in Lesson 5, are where that lives. Scattering multiple sessions to check back on later, multiple agents collaborating, orchestrating large jobs by script, these are bigger than what you need right now and lean toward developer territory, so this track left them out. No need to touch them yet, just remember the names for when a job actually shows up too big for a single subagent to carry.

Skills, plugins, subagents, and hooks are all core Claude Code features, so the details shift release to release. The commands and screens described across this track's six lessons are no exception. Build on what this track taught you, and make a habit of skimming the official docs' changelog every few months. The role each of the five tools plays, and the order you learn them in, that skeleton doesn't change easily. Even when the details go unfamiliar, you can come back to the bar this track set and look them up again.

Now that I've worked through this track myself, here's what my own setup actually looks like. In my writing project, skills carry most of what a single piece goes through, from finding a topic to drafting, fact-checking, and the thumbnail. Hooks work quietly in the background, checking a few things whenever a session opens, and subagents get built on the spot whenever a job actually calls for one. My work-side project mixes things differently. Subagents carry more weight there than skills do, with a role split where judgment calls go to a stronger model and mechanical verification goes to a lighter one. There's also a gate that runs a skeptical second pass over anything before it ships. Same five tools, but the mix shifts completely depending on the shape of the work. And in either project, my home folder carries a skill for building skills, a skill for building hooks, and a skill for building subagents.

That last line is really where this track lands. Honestly, I don't keep the five tools cleanly separated anymore, myself. What used to require a person to design this kind of structure strictly has turned into something I build out by talking it through with an agent instead. Start the conversation with something like this keeps repeating, can't it just run itself, and the agent is right there with me, from picking the right tool to actually building it. That doesn't mean these six lessons were wasted effort, though. You can only ask for what you know is possible to ask for, and the eye that checks what an agent hands back still comes from the distinctions you learned right here.