Module 7 of 10

Extending AI — skills & plugins.

Module 7 is the module where the student stops being a consumer of AI systems and becomes an author of them. Modules 3 through 6 were about directing — the student held the steering wheel, the agent did the work. Module 7 is about building the steering wheel. You name a job. You describe it. You give it a trigger, a body, an output contract, a failure-modes block. You hand the folder to the agent, and from that point on the agent reaches for it on its own when a matching request shows up. The headline technical insight of the module is description-as-classifier — the description field of a skill is not decoration; it is the live prompt the agent uses to decide which tool to fire. The headline failure mode is pile-up — extensions accumulate, collide, drift, and silently degrade the workflow. The rail that prevents it is the extension-register-v1.md you freeze as the seventh capstone artifact, alongside one custom Claude Code skill and one custom Cowork plugin — a triplet, not a single file.

Recipe Book status for this module

Module 7 splits its authoring across two tools by design: skills are authored as SKILL.md files inside the Claude Code CLI's .claude/skills/ folder convention (Lesson 7.3), and plugins are authored as Cowork-tab plugin bundles (Lesson 7.4). The two are different artifact types, not redundant paths. Module 7 is a mix of CORE and RECIPE — the SKILL.md frontmatter and folder conventions in 7.3, the Cowork-tab plugin manifest and the create-cowork-plugin scaffolding walkthrough in 7.4, the install-and-smoke-test flows in 7.2, and the freezing procedures (uninstall test before freeze, changelog-per-tuning-round, traces under traces/) throughout. Every recipe in this module was last verified 2026-04-18 and is on the next-review queue for 2026-07-18. When a SKILL.md field name changes, when the Cowork-tab plugin manifest schema bumps, when a plugin framework adds a new permission prompt — flag it. Those drift reports are what keep the quarterly refresh honest.

CORE blocks (the six-place taxonomy in 7.1, the off-the-shelf-first heuristic and minimum viable audit in 7.2, the description-as-classifier insight and three-round tuning loop in 7.3, the bundling conditions and security questionnaire in 7.4, and the hygiene ritual and five retirement signals in 7.5) are tool-agnostic and will still be true when Claude Code looks different, when the Cowork manifest schema has been renamed, and when three of the current plugin frameworks have been replaced by things that do not exist yet. They are the durable part of Module 7.

Lessons in this module CORE + RECIPE

Work through these in order. Each lesson ends with a project checkpoint that adds one or more rows to your extension register draft, or freezes one of the three capstone artifacts; Lesson 7.5 runs the hygiene ritual across every row and freezes the register as the seventh capstone artifact of the course.

  1. 7.1   What an extension actually is.

    Mostly CORE

    The mental-model lesson of Module 7. The six-place taxonomy (one-off prompt, saved prompt, memory, skill, plugin, MCP connector), the three-part threshold test that tells you when a prompt earns promotion to a skill, the pile-up failure mode the register is designed to prevent, and the Module 6 rule audience = only you carried uniformly forward into everything the student authors. You stand up an empty register, add an Extension Posture block to my-first-loop.md, and sort five candidate workflows from your own life.

    Open Lesson 7.1 →

  2. 7.2   Evaluating and using existing extensions.

    Mostly CORE

    The off-the-shelf-first posture and the four conditions that flip it. The minimum viable audit — five questions (what it does, what tools it grants, what data it reads, what it sends, how it handles credentials) that every candidate extension answers before it enters the register. Reading a manifest, a description, and a changelog for drift. The outbound decision matrix (install clean / install drafts-only / install with platform-scoped permissions / decline / conscious override). You audit four off-the-shelf extensions — keep two, decline two — and file four register rows.

    Open Lesson 7.2 →

  3. 7.3   Building your first custom skill (Claude Code path).

    Mostly RECIPE · headline authoring lesson

    The module's headline authoring lesson and the home of its headline technical insight: description-as-classifier. The anatomy of a skill (frontmatter + body); the three description failure modes (vague / overfit / triggerless) and the descriptive + inclusive + exclusive fix; the five-section body (purpose, inputs, procedure, output contract, failure modes); the three-round tuning loop (trigger test / body test / scope test) with one dated changelog entry per round. You author, install, invoke, and iterate a real skill against your own work, run the Description-tuning drill to calibrate your eye, and freeze /capstone/custom-skill-v1/ with SKILL.md, README.md, CHANGELOG.md, and two real-use traces.

    Open Lesson 7.3 →

  4. 7.4   Building and packaging a custom plugin (Cowork path).

    CORE + RECIPE

    The bundling lesson. Three conditions that make a plugin the right shape rather than a loose skill (shared scope / shared install-uninstall / share with others), the seven-field manifest (name, version, description, author, bundled skills, MCP connectors, permission surface), the seven-question security questionnaire (the five audit questions from 7.2 + S6 what installing removes from the user's control + S7 update posture), and least-privilege as a design tool. You wrap your 7.3 skill in a Cowork plugin, run a clean install, pass the uninstall-and-reinstall test (mandatory before freeze), and file /capstone/custom-plugin-v1/ with manifest, bundled skill, SECURITY.md, and two real-use traces.

    Open Lesson 7.4 →

  5. 7.5   Extension hygiene, sharing, and the register freeze (capstone).

    Mostly CORE

    The discipline lesson and the capstone freeze. Three kinds of drift that the ritual surfaces (tool drift, work drift, ecosystem drift), the five-step hygiene ritual (read aloud, check permissions vs audit, check review dates, look for collisions, decide per row), the four per-row decisions (keep / refactor / replace / retire), the five retirement signals (use stopped, tool changed, description drifted, permission widened, better option matured), the sharing posture (A do-not-share default / B private share / C public share), and the Module 7 retrospective in my-first-loop.md. You run the ritual across every row, apply refactors and retires, and freeze /capstone/extension-register-v1.md — the seventh capstone artifact of the course — with 5 to 7 active rows and every authored extension carrying its own SECURITY.md and CHANGELOG.md.

    Open Lesson 7.5 →

Module wrap-up

End-of-module check.

Ten questions across 15 points — six multiple choice, two short-answer, two applied. Closed-book for the recall sections; open-workstation for the applied pair, where you diagnose the failure mode of your own skill's first-draft description from your CHANGELOG.md, then walk through the hygiene ritual on the row in your frozen register whose keep / refactor / replace / retire call was hardest. Passing bar: 11.5 / 15 with full credit on at least one applied question. The parent scoring summary makes it straightforward to document as a module assessment on a transcript.

Open the end-of-module check →

Resources for this module RECIPE

Seven printable companions and one interactive activity run alongside the lessons. Each printable is a print-to-PDF page that prints cleanly on letter paper. Use them in the order their lessons reference them.

  • Extension register — row template — printable for Lesson 7.1. The header block (copy once into extension-register-v1-draft.md) and the row template (copy once per extension), plus the columns the register enforces (name, type, what it does, where it lives, invocation, audience, budget/model, next review, keep-or-retire) and one fully worked example row. The scaffold that grows across all five lessons into the capstone artifact.
  • Minimum viable audit — printable for Lesson 7.2. The five-question worksheet (what it does / what tools it grants / what data it reads / what it sends / how it handles credentials) you fill once per candidate extension. Plus the outbound decision matrix (Options A–E) and the three-part manifest / description / changelog read. You print four copies for the activity.
  • Skill planner — printable for Lesson 7.3. The pre-authoring worksheet where most of the thinking should happen: name, what the skill does in one sentence, inputs, outputs, procedure in 4–7 numbered steps, output contract, and at least three failure modes. Fill this in before you touch YAML.
  • Description-tuning drill — interactive HTML activity for Lesson 7.3. Five pre-baked skill descriptions, each with five test requests; for each pair you predict whether the skill fires and name which of the three failure modes (vague / overfit / triggerless) the description would exhibit. Reveal-on-submit scoring. The rep that installs the description-as-classifier muscle.
  • Plugin planner & security questionnaire — printable for Lesson 7.4. The seven-field manifest draft, the three-bundling-condition check, the permission surface union, and the seven security questions (S1–S7) that become the plugin's SECURITY.md. Plus the uninstall-test checklist that gates the freeze.
  • Hygiene ritual — printable for Lesson 7.5. The five-step per-row block (read aloud, check permissions vs audit, check review dates, look for collisions, decide), the per-row decision tree (keep / refactor / replace / retire) with the five retirement signals named, and the aggregate sweep sheet that surfaces collisions across rows. You print one copy per quarterly sweep.
  • Sharing posture worksheet — printable for Lesson 7.5. The three postures (A do-not-share / B private / C public), the minimum documentation checklist for each, and the readiness test — three questions that tell you whether your extension has survived enough hygiene cycles to share. Most Module 7 students end on Posture A; the worksheet is for when you revisit the question in 6–9 months.
  • Module 7 retrospective — template — printable for Lesson 7.5. The four-question prompt (what did I ship / what surprised me / what would I build next / one concrete thing I learned about description-as-classifier) that produces the 300–500 word retrospective in my-first-loop.md. Written for future-you to read at the 90-day and 180-day marks.

What you should have when this module is done CORE

By the time you close out Module 7, you should be able to point to six concrete things on your machine and in your capstone folder:

  • A populated ~/.claude/skills/<your-skill>/ or <project>/.claude/skills/<your-skill>/ folder on your machine with the custom skill you authored — SKILL.md (frontmatter + body), any supporting scripts, a CHANGELOG.md with at least three dated tuning entries, and a traces/ subfolder containing two real-use invocation traces on requests that came from your actual work. Not a skill that only ever fired in tuning tests.
  • A Cowork plugin installed on your machine wrapping your custom skill (or a second one of its size), with a clean install and a verified clean uninstall-and-reinstall cycle. The plugin's manifest enumerates every tool, every read scope, every write scope; its SECURITY.md answers all seven questions (S1–S7) honestly; its CHANGELOG.md is dated.
  • A completed hygiene ritual artifact saved as /capstone/extension-artifacts/hygiene-ritual-<date>.md covering every register row, with at least one row honestly marked retired (or declined, from the Lesson 7.2 audit) and the five-step ritual completed on each live row.
  • A frozen /capstone/extension-register-v1.md containing, in order: a one-paragraph reflection from the hygiene ritual, 5–7 rows (at least two installed, at least two declined, your custom skill, your custom plugin, and any MCPs you wired), and both safety norms (drafts, not sends from Module 5 and audience = only you from Module 6, extended to every extension you author in Module 7) pasted verbatim at the bottom.
  • An extension set that respects its ceiling — the soft ceiling you set in your Extension Posture is respected, every live row has a next review date within 90 days, and you can name the keep-or-retire condition for every live row from memory. A register row you cannot describe without looking is a row ready to retire.
  • The completed end-of-module check in your portfolio, scored at 11.5 / 15 or better with full credit on at least one applied question.

If any of these is missing, go back to the checkpoint that produced it and finish before moving on. Module 8 assumes the extension layer is already clean — the orchestration patterns it introduces compose the skills and plugins you built here. A messy Module 7 register makes Module 8 miserable.

Coming next

Module 8 — Agent orchestration.

You have named, described, and frozen reusable pieces of capability. Now you compose them. Module 8 is the module where multiple agents, multiple skills, and multiple tools hand off work to each other in a pipeline — sequential, parallel, hierarchical — and where the clean register you just shipped earns its keep a second time.

Module 8 opens when the Module 7 portfolio is complete — the six items above, including the end-of-module check.