Inside k12-lesson-planning: How the Open-Source Skill Works

Most "AI lesson planner" demos hand you a wall of chat text and call it a plan. The skill Anthropic shipped with Claude for Teachers is a different kind of thing, and the best way to understand it is to read the source. k12-lesson-planning is one of two teaching skills the company open-sourced at github.com/anthropics/k12-teacher-skills, and its architecture tells you exactly what separates a toy from a tool a teacher can lean on.

The short version: this skill builds classroom-ready, standards-aligned lesson plans, optionally aligned to a teacher's own curriculum. It draws on widely used curricula mapped to state standards, plus the fine-grained learning components and progressions beneath each standard, then drafts a plan and the student-facing materials you'd actually hand out. The design decisions that make that possible are the interesting part — and because the repo is public, you can inspect every one of them.

What the skill is built to produce

The skill was co-developed with Learning Commons and designed around the tasks teachers said mattered most. It's not open-ended. Give it a grade, a subject, and a standard — or point it at your curriculum — and it produces a coherent draft: a lesson plan structured the way a teacher expects to see one, together with the materials students touch. That distinction matters. A plan without student-facing materials leaves you doing the second, longer half of the job yourself. The skill treats the handout, the worksheet, the prompts as part of the deliverable, not an afterthought.

Crucially, the output is a draft to revise, not a final answer. The skill's job is to get you to a strong first version fast, grounded in real curricula and standards, so your time goes into the pedagogical judgment only you can make. That framing — Claude does the drafting, you keep the professional call — runs through the whole Claude for Teachers launch, and the lesson-planning skill is where it's most concrete.

It's also worth knowing how the skill got to be what it is. It was designed around the tasks teachers said mattered most, then refined through early classroom feedback — including at Prospect Schools in Brooklyn. That matters when you read the source: the design choices aren't theoretical, they've been corrected by contact with real periods and real teachers deciding whether the output was usable. Inside the product, this maps directly to one of the named use cases — plan a lesson from high-quality instructional materials, aligned to your state's standards — so the skill you're reading in the repo is the same one doing that job for verified educators.

The repo layout is the lesson

Open the repository and the structure is refreshingly legible. Two top-level directories carry the weight:

• plugin/ — the skills packaged as a Claude Code plugin, bundled alongside teacher-focused third-party MCP servers that users can enable. This is what makes the skill installable outside Claude for Teachers.
• evals/ — the evaluation framework and rubrics used to judge the skills for rigor, pedagogical alignment, and classroom usability.

Inside the lesson-planning skill itself, two subdirectories do the real work:

• references/ — per-subject guidance files: ela.md, math.md, science.md, social_studies.md, and learning-commons-kg.md. Each holds the domain-specific expectations for planning in that subject, so the skill doesn't reason about a science lesson the way it reasons about an ELA one.
• scripts/ — code that renders a lesson JSON into distributable files: render_lesson_docx.py and render_lesson_html.py, with a shared theme.css. The skill produces a .docx and an .html you can print, edit, or post — not chat you have to copy-paste.

Read that layout and the philosophy comes into focus. Knowledge lives in files, formatting lives in scripts, and the model orchestrates between them. It's a pattern any skill author can steal.

How standards get baked in, not bolted on

The reference file to pay attention to is learning-commons-kg.md. The skill is written to use the Learning Commons Knowledge Graph connector, which gives Claude academic standards across all 50 states — and beneath each standard, the smaller learning competencies it's built from and the order students typically learn them. That last piece, the learning progressions, is what lets the skill scaffold. When Claude knows a standard decomposes into competencies that students acquire in a typical sequence, it can plan a lesson that meets students where the progression says they are, rather than dropping the full standard on them at once.

Because the skill pulls standards and their progressions at plan time, lessons come out standards-aligned and scaffolded by construction — not retrofitted to a standard after the fact.

This is the difference between "write a lesson on fractions" and a lesson that reflects how fraction understanding is actually built up. The skill also draws on widely used curricula mapped to those standards, so its raw material is vetted instructional content, not generic internet knowledge about the topic. If you want the deeper argument for why this matters, the companion pieces on the connector and on standards-alignment-by-construction go further; this piece stays on the skill's mechanics.

What happens if you don't have the connector

Because the skill is open source, it's honest about its assumptions. The references/ files make clear the skill expects the Learning Commons Knowledge Graph connector to be present. If you install it in a plain Claude Code environment without that connector, you adapt: bring your own standards and curriculum as context, and the skill still drafts and renders. The instructions for installing outside Claude for Teachers are right in the repo:

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

Inside Claude for Teachers, of course, the skill and the connector are already there — you just ask for a lesson. Outside it, you're wiring up the grounding yourself, which is exactly why reading the source pays off. You can see which parts are load-bearing.

Why open-sourcing this one was the right call

There's a strategic reason a lesson-planning skill, specifically, is a good thing to make public. Lesson planning is the task every teacher does and every education tool tries to automate — and most automate it badly, producing plausible-looking plans with no real standards grounding and no printable artifact at the end. By publishing a reference implementation, Anthropic gives other education builders a concrete example of what "done right" looks like: subject-specific reference files, a real connector for standards, and scripts that finish the job by producing a file.

For a teacher, the takeaway is trust. You can see what the skill knows and how it decides. For a builder, the takeaway is a template. If you're writing your own teaching skill, the references/-plus-scripts/-plus-evals/ structure is a pattern worth copying wholesale. Either way, the open repo turns a product feature into a public good — and it's the clearest window we have into how Claude for Teachers actually plans a lesson.

If you want to try the pattern in a marketplace skill today, lesson-plan-studio and the broader education agent skills are good starting points, and the AI tutoring category collects the rest.

---

Part of the Claude for Teachers series. Related: Inside k12-lesson-differentiation · From Skill to Printable Lesson. Browse AI tutoring skills or more builder insights.