Fork the Evals: Writing Rubric-Based Tests for Your Own Education Skills
Anthropic open-sourced not just the K-12 teaching skills but the evals/ framework and rubric CSVs that judged them. Here's how to fork that harness to test your own teaching skills for rigor, alignment, and usability.
Most people who clone the K-12 teaching skills go straight for the plugin/ directory — the skills, the thing you install. Walk past evals/ and you'll miss the more valuable half. That folder holds the evaluation framework and the rubrics Anthropic used to judge the skills, and it's the closest thing the education-AI world has to a shared, forkable standard for "is this teaching skill actually any good?"
Here's the argument: if you're building teaching skills of your own, the single most useful thing in the k12-teacher-skills repo isn't the two skills — it's the rubrics that graded them. The skills tell you what good output looks like once. The evals tell you how to keep checking that your own skill produces good output every time you change it. Fork the harness, swap in your rubrics, and you've bought yourself the one thing homegrown education tools almost always lack: a way to know when they regress.
What "evaluated" actually meant here
The teaching skills weren't shipped on vibes. They were co-developed with Learning Commons, evaluated for rigor, pedagogical alignment, and classroom usability, and refined through early classroom feedback — including at Prospect Schools in Brooklyn. Those three criteria are worth memorizing because they're the ones your own evals should target too: rigor (is the content correct and demanding enough?), pedagogical alignment (does it reflect how the subject is actually taught and learned?), and classroom usability (can a real teacher use this on a real Tuesday?).
The repo also ships a technical write-up of the evaluations, so you're not reverse-engineering intent from CSV headers. Read that write-up alongside the rubrics; together they show not just what was measured but why those measures were chosen. That pairing — a machine-readable rubric plus a human-readable rationale — is the template to copy.
What's in the evals folder
The evals/ directory organizes its rubrics as CSVs, split so that general and subject-specific criteria don't get tangled. If you're deciding what to fork, this is the map:
| Rubric | What it evaluates |
|---|---|
Per-subject: ela, math, science, social_studies | Discipline-specific rigor and pedagogical fit — what "good" means for a lesson in that subject |
shared | Cross-subject criteria that apply to any lesson, regardless of discipline |
clarifying_question | Whether the skill asks the right questions before generating, instead of guessing at grade, standard, or context |
differentiation | Whether tiered versions hold the core content consistent across below-, at-, and above-level materials |
The shape here teaches the lesson before you read a single row. General quality and subject quality are separated, so a math lesson is judged partly by universal criteria and partly by "is this good math teaching." The clarifying_question rubric treats asking good questions as a first-class skill behavior — a genuinely sharp move, since a teaching tool that assumes instead of asks produces confidently wrong lessons. And the differentiation rubric encodes the hardest promise the skills make — consistent core content across tiers — as something you can actually score.
Rubrics are how you turn "this lesson feels good" into "this lesson scored well on rigor, alignment, and usability." Without them, every change to your skill is a coin flip you can't see the result of.
Why rubric-based evals fit education so well
You might ask why not just eyeball the output. Because teaching quality is exactly the kind of thing that's easy to judge loosely and hard to judge consistently. Two reviewers will disagree about whether a lesson is "rigorous" until you give them a rubric that says what rigor means for fourth-grade fractions. A rubric turns a vague professional judgment into repeatable criteria — the same reason teachers grade student work with rubrics instead of gut feel.
That repeatability is what makes iteration safe. Change a prompt in your skill and you want to know: did that help or did it quietly break the science lessons? Run the rubrics before and after and you get an answer instead of a hunch. This is the difference between a skill you hope is good and a skill you can demonstrate is good — the second one is the only kind a district should deploy or a builder should publish.
Rubric-based evals also travel. A per-subject CSV is legible to a curriculum specialist who has never written code. They can read your math rubric, tell you a criterion is wrong, and you can fix it — no engineering required. In education, where the domain experts and the builders are often different people, that legibility is a feature, not a footnote.
How to fork it for your own skill
The mechanics are less about tooling and more about discipline. Start by cloning the repo and reading the technical write-up and a couple of rubric CSVs end to end, so you understand the format and the intent. Then adapt rather than reinvent: keep the split between shared and subject-specific criteria, keep a clarifying-question check, and — if your skill differentiates — keep a differentiation rubric, because those three structural choices are the hard-won part.
Now swap in your own content. Rewrite the subject rubrics for the grade band and discipline you actually target; a high-school chemistry skill needs different rigor criteria than an elementary science one. Assemble a small set of representative tasks — the real prompts a teacher would give your skill — and score the outputs against your rubrics. Do it once to get a baseline, then re-run every time you change the skill. That loop is the whole point: baseline, change, re-score, compare. Wire it into your repo the way the K-12 project does, with evals/ living beside plugin/ so the tests ship with the source but not inside the install bundle.
If your skill leans on standards you don't have a connector for, your evals are also where you catch the resulting drift — the same concern covered in adapting the skills without Learning Commons. A rubric that checks standards alignment will flag a lesson that wandered because the grounding was thin.
Evals are how education AI earns trust
There's a bigger reason to care about this than tidy engineering. The whole premise of Claude for Teachers is that AI for teachers can strengthen instruction where AI for students has been mixed and implementation-dependent — and Anthropic is backing that with real study, including a pilot evaluation in the Detroit Public Schools Community District looking at educator wellbeing and practice. Evaluation isn't a side quest in this space; it's how the claims get earned.
Your own teaching skill deserves the same rigor at its own scale. You won't run a district pilot, but you can run rubrics — and rubrics are how you show, not just assert, that your tool is rigorous, aligned, and usable. Fork the evals/ folder, make the rubrics yours, and hold your skill to a standard you can point to.
To go deeper on what the rubrics revealed about the skills' design, read Reading the Rubrics; to put a skill worth evaluating in front of them, start with Build Your Own Teaching Skill. And if you want to study production-grade teaching tools alongside your own, browse Education Agent Skills and Exam Blueprint in the marketplace.
Part of the Claude for Teachers series. Related: Reading the Rubrics: How Anthropic Evaluated the Teaching Skills · Build Your Own Teaching Skill: Lessons from Anthropic's SKILL.md Design. Browse AI tutoring skills or more builder insights.