Course overview

You already know how to install Claude Code and run a task with it. This course is about everything that happens before you type the task.

Claude Code has four places where you can tell it what to do, and they are not interchangeable. CLAUDE.md holds instructions. settings.json holds configuration. Skill and subagent frontmatter hold per-task overrides. Hooks hold enforcement. Put a rule in the wrong place and one of two things happens. Either it never fires, or it fires as a suggestion when you needed a guarantee.

That distinction is the spine of this course. Anthropic’s own documentation is blunt about it. CLAUDE.md files are treated as “context, not enforced configuration.” If you need to block an action regardless of what Claude decides, you use a hook. Most of the trouble small teams have with Claude Code traces back to writing a policy in prose and expecting it to behave like a lock.

From there the course goes after your bill. You will learn the model alias table, the four-step precedence ladder that decides which model a session actually runs, how effort levels change what you pay, and why output tokens cost several times what input tokens cost. You will learn to set a project default so nobody on your team has to remember to pick the cheap model.

Then you extend the tool. Skills are folders with a SKILL.md file that Claude loads only when the work calls for it, which is why a long reference document in a skill costs almost nothing until it is needed. Subagents run in their own context window and return only a summary, which keeps your main session small and lets you route routine work to a cheaper model. MCP servers connect Claude Code to the systems your business already runs on.

The last two modules are about control and judgment. You will write a PreToolUse guard that exits with code 2 and blocks a tool call outright. You will write a PostToolUse handler that cleans up and logs. Then you will assemble all of it into one posture for one small business, and learn to recognize the point where a job has outgrown Claude Code.

This is a Delegate course, the fourth rung of the Nantucket AI trust ladder. Delegate is where you stop watching every step and start trusting a configured system. Configuration is what earns that trust. You do not delegate to a tool. You delegate to a tool plus the limits you put around it.

Who this is for

• Small business owners and operators who already use Claude Code and want it to cost less
• Nonprofit staff who need a repeatable setup a volunteer or seasonal hire can use safely
• Office managers responsible for client files that must never be deleted or exposed
• Anyone who has been asked to set Claude Code up for a team rather than for themselves

You do not need to be a developer. You do need to be comfortable editing a text file and running a command.

Prerequisites

Intro to Claude Code (Supervise level) or equivalent experience. This course assumes you have Claude Code installed, authenticated, and working, that you have run at least one real task with it, and that you know how the working loop feels. None of that is retaught here.

What you will be able to do

By the end of this course you will be able to:

• Name the four configuration surfaces and place any given rule on the right one
• Explain why a CLAUDE.md instruction cannot enforce anything, and what can
• Write a CLAUDE.md that stays under the documented size guidance and still carries the context your business needs
• Describe the settings.json precedence stack and choose between project, local, user, and managed scope
• State the four-step model precedence ladder and set a persistent project default
• Choose between the documented model aliases for a given job, and explain the cost consequence
• Explain effort levels, thinking tokens, and why turning reasoning up costs money even when the answer is short
• Author a SKILL.md with correct frontmatter, including a model override that routes the work to a cheaper model
• Decide when a skill should run inline and when it should fork to a subagent
• Write a subagent definition that limits tools and pins a model
• Explain what an MCP server does and at what scope to configure one
• Write a PreToolUse hook that blocks a dangerous command using exit code 2
• Write a PostToolUse hook that cleans up or writes an audit line
• Assemble instructions, configuration, skills, and a guard hook into one coherent posture for a small team
• Recognize the point at which a workload has outgrown Claude Code

Assessment

Each module ends with a short quiz. The course ends with a final assessment covering all six modules.

Passing grade: 70 percent. Retakes are unlimited. Your score is not published or shared.

A note on currency

Claude Code changes quickly. Field names get added, aliases move, and version numbers advance. This course teaches the mental models, which are durable, and names exact fields only where they were verified against the official documentation for this build. Where a detail is likely to drift, the lesson tells you to check the current docs page instead of memorizing a value. The Claude Code documentation lives at code.claude.com.

Modules

1. The Four Surfaces (4 lessons) – What each surface is for, why prose is not configuration and configuration is not enforcement, and a placement test you can apply to any rule.
2. Model Selection and Cost (4 lessons) – The alias table, the precedence ladder, effort levels and thinking tokens, and what actually drives your bill.
3. Skills (3 lessons) – SKILL.md structure, the frontmatter override surface, and forking work to a cheaper model.
4. Subagents and MCP (3 lessons) – Isolated context, constraint by tool list, and MCP as the tool bus.
5. Hooks and Governance (4 lessons) – Lifecycle events, the PreToolUse exit-code-2 block, PostToolUse cleanup, and hooks as permission, policy, and audit.
6. Putting It Together (3 lessons) – One posture for one small business, what Delegate-level responsibility means, and when to graduate beyond Claude Code.

After this course

Delegate is the top rung of the trust ladder as this catalog defines it. The natural next step is not another rung. It is applying this to your own organization: a CLAUDE.md and settings.json baseline, a small skill library for the work you actually repeat, and one or two enforcement hooks around the things you cannot afford to lose.

Frequently asked questions

Do I need to be a developer to take this course?

No. Every example is a Nantucket business: a property management office, a restaurant, a retail shop, a nonprofit, a real estate office. The work is documents, reports, and records, not software. You do need to be comfortable editing a text file and running a command.

How is this different from Intro to Claude Code?

Intro covers what Claude Code is, installing it, the working loop, and running a first real task. This course starts after that and covers configuration only: where rules live, what they cost, and what actually enforces them. There is no overlap by design.

Will this actually lower what I spend?

It gives you the four levers that decide the number: which model runs, how much reasoning it does, how much context you resend every turn, and how long the output is. All four are configuration, not habits. The course also shows you how to use /usage to see which skill or subagent is responsible for a spike.

Claude Code changes constantly. Will this be out of date?

The mental models are durable and the field names are not. This course names exact fields only where they were verified against the official documentation for this build, and where a detail is likely to drift, the lesson tells you to check the current docs page instead of memorizing it. Reading the docs is a skill the course teaches on purpose.

Is a hook the same thing as a permission rule?

No, and the difference matters. A permission rule in settings.json is declarative and the client enforces it. A hook is a program that runs on an event and can inspect the specifics before deciding. Use the permission rule where one can express your rule. Reach for a hook when the decision depends on something a declarative rule cannot see.

What do I have at the end?

A written configuration posture: a CLAUDE.md under the documented size guidance, a settings.json with a deliberate model default and permission rules, at least one skill with a model override, at least one subagent constrained by its tool list, and one guard hook you have tested by trying the thing it forbids.

Where this course sits

This is a Delegate course, the fourth rung of the Nantucket AI trust ladder. If you are still learning to get reliable results out of AI on a single task, start with the H.E.L.P. method instead. Prerequisite: Intro to Claude Code.