anthropics/k12-teacher-skills: four Claude skills for lesson planning, differentiation and formative checks

Four skills, one plugin, and the standards connector they assume

This repository is not a teaching application. It is the source for four agent skills that ship with Claude for Teachers, published so that people outside that product can read, install and evaluate them. The four are named `k12-lesson-plan-creation`, `k12-lesson-differentiation`, `k12-lesson-prep` and `k12-check-for-understanding`. Each covers a different moment in a teacher's week: building a plan, adapting a plan that already exists, rehearsing the student task before class, and writing a short formative check.

The audience is narrow and worth stating plainly. A K-12 teacher who already has Claude for Teachers needs nothing from this page, because the README says the skills are already installed. The people who do need it are teachers running Claude Code or another Claude surface, and developers or district technology staff who want to inspect the prompts and rubrics before allowing them near student-facing material. The repository also contains `evals/`, described as an evaluation framework with guidance on adapting it to your own use case. That folder is the part aimed at builders rather than teachers.

The dependency that shapes everything else is the Learning Commons Knowledge Graph connector. The README states that the skills are written to make effective use of it, and that the connector gives Claude access to academic standards across all 50 states plus the progressions beneath them. It then says directly: adapt the skills if your environment does not have access to these tools. That sentence is the honest boundary of the project. Without the connector, the skills still run, but the standards alignment that gives them their value is no longer grounded in a standards source.

How the skills split the work: plan, differentiate, rehearse, check

The mechanism is prompt-level rather than architectural. There is no service, no database and no API in this repository. The `plugin/` directory holds the skill content bundled as a plugin, and per the README it also includes teacher-focused third party MCP servers that users can enable. The skills themselves are instruction sets that shape what Claude does with a teacher's request, and `evals/` holds the rubrics used to judge the output.

The four skills differ in how much they constrain the model. `k12-lesson-plan-creation` is the open-ended one: it builds classroom-ready, standards-aligned lesson plans, with optional alignment to a teacher's own curriculum. `k12-lesson-differentiation` is tighter. It takes a lesson that already exists and produces tiered versions at below, at and above proficiency level, and the README notes the design constraint that core content stays consistent across tiers. That constraint matters, because the failure mode of tiered material is three unrelated worksheets rather than one task at three levels of support.

`k12-lesson-prep` is the smallest in scope and the most unusual. It works through the key student task with the teacher and leaves a short teacher-only prep note. Nothing goes to students. `k12-check-for-understanding` is the most specified: it builds a 1 to 3 item formative check for a math standard, and the README says the distractors are drawn from documented misconceptions, with a teacher guide that routes each possible response to a next step. That routing guide is the part that turns a quiz into an instructional decision, and it is also why the item count is capped so low. A 1 to 3 item check is a quick read of the room, not a unit test.

Installing the plugin in Claude Code

The README gives two paths. If you have a Claude for Teachers account, there is no extra install: the skills are already there. Everywhere else, you load the plugin or the skills manually, and the README shows the Claude Code route. Clone the repository, register the local directory as a plugin marketplace, then install the plugin named `k12-education` from it.

git clone https://github.com/anthropics/k12-teacher-skills
claude plugin marketplace add ./k12-teacher-skills
claude plugin install k12-education@k12-teacher-skills

Run these from the directory where you want the clone to live. The first command creates a `k12-teacher-skills` folder; the second points Claude Code at that folder as a marketplace; the third installs `k12-education` from it. If the install step reports that the plugin cannot be found, check that the path in the second command matches the folder the clone actually created.

A first real use is the differentiation skill, because it takes input you already have. Give Claude an existing lesson and ask for tiered versions. You should get below, at and above proficiency versions of the same task, with the core content held constant across the three, which is the behaviour the README describes. Before trusting the output, open `evals/` and read the rubrics, since that is where the project states what it considers a good result. If you are not in Claude for Teachers, also confirm whether the Learning Commons Knowledge Graph connector is reachable; without it, expect to edit the skills before the standards alignment means anything.

The connector dependency is the real limitation

The clearest constraint is stated by the project itself. The skills are written around the Learning Commons Knowledge Graph connector, which the README describes as included for all teachers using Claude for Teachers, and it tells you to adapt the skills if your environment lacks those tools. That is not a footnote. Standards alignment across all 50 states and the progressions beneath them is the substance of the lesson-plan and check-for-understanding skills. Strip the connector out and you are left with a well-worded prompt that produces plausible-looking standards codes from model memory.

There is a second boundary in the scope of the check skill. It is explicitly a 1 to 3 item formative check for a math standard. Teachers looking for a longer assessment, a rubric for an essay, or a check tied to a reading passage will not find it here. The distractor design, drawn from documented misconceptions, is the strongest idea in the repository, and it is confined to a format that takes a few minutes of class time.

A third thing to weigh is that this is a prompt and rubric repository, not a runtime. There is no versioned API, no changelog in the README, and no releases were retrieved. If your district needs a frozen artifact with a documented upgrade path, the unit of change here is a prompt file, and prompt files change meaning when the model behind them changes. That is a different kind of maintenance than a library with a lockfile.

The last push was on 2026-09-01, which is recent, and the repository is not archived. Those two facts are all this page can say about activity. Nothing here establishes how often the skills are revised.

Compared with writing your own prompts or using a generic assistant

The obvious alternative is a general-purpose assistant with no teaching skills installed. The difference is not intelligence, it is constraint. A generic assistant asked for a lesson plan will produce something readable, but nothing in the request forces standards alignment, forces the differentiated versions to share core content, or forces the distractors to come from documented misconceptions. These skills encode those requirements as instructions, and `evals/` encodes them as rubrics you can score against. That is the actual delta.

The second alternative is writing your own prompts, which many districts do. That gives you control and no dependency on a connector you may not have. The cost is that you also own the rubric, the misconception list and the routing logic for each possible student response. The `k12-check-for-understanding` skill is the one hardest to reproduce by hand, because the teacher guide that maps each response to a next step is the part most people skip when writing a quick prompt.

A third comparison is the plugin packaging itself. Because the content ships as a Claude plugin, you can install it with three commands and read every file first. That is a lower-commitment path than adopting a full learning platform, and a higher-commitment path than pasting a prompt into a chat window. The trade is that you inherit someone else's instructional assumptions, which is exactly why the eval folder is worth reading before classroom use.

Licence and what upgrading actually costs

The repository is Apache-2.0. That permits commercial and institutional use, modification and redistribution, and it includes a patent grant. The repository also carries a `NOTICE` file and a `CLA.md`, and Apache-2.0 expects the NOTICE contents to be preserved when you redistribute. If your district forks the skills and adapts them for a state whose standards the connector handles differently, keep the NOTICE and the licence text with the fork. This is a description of the licence terms, not legal advice; a district with a review process should route the fork through it.

The `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md` and `SECURITY.md` files indicate the project accepts outside contributions and has a stated security contact. `CODEOWNERS` names reviewers. For a district that wants to upstream a fix to a prompt, that path exists.

Upgrade cost is the harder question, and the repository does not answer it. There are no retrieved releases, so there is no changelog to diff between versions. Your practical options are to track `main` and re-read the skill files after each pull, or to pin a commit and treat prompt changes as deliberate migrations. The second is safer for a district, because a change to a differentiation prompt can alter what every teacher gets back the next morning, and nothing in the repository warns you when that happens. Budget for someone to read the diff. That is the maintenance line item, not the install.

Editorial conclusion

Adopt these skills if you already work inside Claude for Teachers, where the README states they are installed with no extra step, or if you run Claude Code and want standards-aligned lesson planning, tiered differentiation, prep notes and 1-3 item formative checks in one plugin. Do not adopt them if your environment has no access to the Learning Commons Knowledge Graph connector, because the README explicitly asks you to adapt the skills in that case, and do not expect a graded-essay or long-form assessment generator; the check-for-understanding skill is scoped to 1-3 items on a math standard. Verify first that the connector is present and that the standards you need are covered, then read evals/ to see what the rubrics actually score before you put any of this in front of students.

Frequently asked questions

Official sources

1. anthropics/k12-teacher-skills on GitHub
2. Issues
3. License: Apache-2.0
4. README