K12 Lesson Differentiation

K-12 Lesson Differentiation

Adapts an existing K-12 lesson for below / at / above grade-level proficiency using research-based differentiation principles (Tomlinson framework + subject-specific access design). Works with or without the Learning Commons Knowledge Graph connector.

"The teacher" throughout this skill is the user you are talking with — the same person, never a third party. "Teacher-facing" names a document's audience: that user, as opposed to their students.

---

Keeping the teacher posted

Once the teacher's path is set (the draft offer answered), say in one or two sentences what you're about to do (e.g. "I'll read your lesson, ground it in the standard and curriculum materials, design the three tiers, and build the worksheets.").

When a task-list or to-do tool is available, also outline this skill's steps there so the teacher can watch them check off; the only reason to skip this is that no such tool exists in this conversation.

Teacher language only — name what the teacher is getting, never tool names, file names, "JSON", or "rendering".

---

Step 0 — Route (silent, before anything else)

1. Subject. Detect math / ELA / science / social studies from the source lesson or the

request, then read the matching reference file NOW:

• math → references/math.md
• ELA → references/ela.md
• science → references/science.md
• social studies → references/social_studies.md

Loading the matching reference file is mandatory. It carries the pedagogy for Steps 1 and 3 (source-lesson identification, curriculum detection, the eight differentiation rules R1–R8, the document content templates, and the differentiation.json mapping). Differentiating without first reading the subject reference is a critical failure on par with skipping the Knowledge Graph.

1. Curriculum. The subject file's "Identify the source lesson" section includes curriculum

detection (Illustrative Mathematics / OpenSciEd). When confirmed, use that curriculum's discourse language and structures in the teacher plan, per the subject file.

Curriculum is confirmed when: the teacher explicitly names it, OR the uploaded source lesson references it (a lesson from an IM unit or an OpenSciEd unit counts — the upload is implicit confirmation).

If curriculum is NOT confirmed (not detectable from upload or link, no explicit mention): never name a specific module, unit number, lesson number, or proprietary routine name anywhere in the output OR in any chat message — even if you recognize the routine from training. Describe the instructional move in your own generic terms ("a compare-strategies discussion", not the routine's trademarked name). This is a hard rule; violating it fails P9, and chat messages count. See Copyright guardrail (after Step 3) for the companion rule on verbatim reproduction.

1. Connector. Check whether the Learning Commons Knowledge Graph tools (e.g.

find_standard_statement) are available in this conversation. This decides which path Step 2 takes. The skill is fully functional without the connector.

1. State. Before any KG call, scan the conversation and any uploaded source lesson for

state signals and store as state:

• Teacher says "I teach in [state]," "I'm in [state]," or "We're in [state]"
• Standard codes in the prompt or source lesson follow a state-specific format:

TEKS 1xx.x.x → Texas; SOL → Virginia; OAS/PASS → Oklahoma; MA → Massachusetts; CA/HSS or CA/CCSS → California; other state-prefixed codes → check state

• Source lesson URL includes a state agency domain (tea.texas.gov, etc.)

If state found: store state = [state name]. Pass as jurisdiction="" in every find_standard_statement call in Step 2. Use state framework codes (not national proxies) in all output.

If state not found:

• for science, math, or ELA, proceed with national defaults (CCSS for math/ELA, NGSS for science). Add this single footer line to the teacher plan:

"Standards applied using [CCSS / NGSS] — if you're in Texas, Virginia, Oklahoma, or another state with a distinct framework, share your state and I'll re-anchor."

• for social studies, ask the teacher what state they teach in before proceeding.

---

Step 1 — Identify the source lesson

Follow the subject file's source-lesson section: Scenario A (lesson exists earlier in this conversation — use it directly, do not re-ask), Scenario B (teacher uploads a lesson — read it first; if unreadable, say so and ask to re-share, never silently fabricate), Scenario B2 (teacher links a lesson by URL — fetch and read it; if the fetch fails, ask them to paste or upload; fetching completes Step 1 only — the KG calls in Step 2 are still mandatory), Scenario B3 (math or science only — teacher names a curriculum lesson by position or title — e.g. "IM Grade 6, Unit 2, Lesson 3" or "the OpenSciEd lesson on ecosystem dynamics" — Step 1 is complete; proceed directly to Step 2 where find_curriculum_lessons will retrieve the lesson materials; do NOT ask the teacher to upload or link the lesson), or Scenario C (no source lesson present — ask the subject file's clarifying question before proceeding).

A fetched link lands in the conversation whole, so a document bigger than one lesson (a module or unit teacher edition) will not fit. When a link points at one, work from what the request itself tells you about the lesson and confirm the specifics with the teacher — topic, grade, and standard carry enough to build from, the same way Scenario C proceeds after its clarify.

Learner needs check (silent, runs every time): Before generating, scan the conversation for any mention of ELL levels, WIDA levels, IEP goal areas, 504 accommodations, or specific student needs. If found, incorporate into the tier design — especially the Below tier. Say "home language," not a specific language, unless the teacher names one.

If no learner needs are mentioned AND the pre-generation R8 ask hasn't fired (scope was already specified), add one sentence to the FIRST response: "No specific learner needs were provided — I've applied UDL defaults (sentence supports and vocabulary across all tiers). Share any ELL levels, IEP goals, or specific student data and I'll adjust."

This check must run even when scope is specified. Learner variability information should be captured before generation, not after.

---

Step 2 — Ground in standards

If the LC Knowledge Graph is connected: follow the subject's section in references/learning-commons-kg.md — call BEFORE drafting; not calling when connected is a critical failure. This applies no matter how the source lesson was obtained — uploaded, pasted, or fetched from a URL. Retrieving the lesson never satisfies this step.

If not connected: proceed from best knowledge and add this footer to the teacher plan: "Generated without the Learning Commons KG. Standard text, prerequisite grounding, and misconceptions reflect general best practice." Do not invent KG citations.

---

Step 3 — The differentiation rules

Apply all eight rules (R1–R8) from the subject file to every differentiated lesson. The rules are subject-specific (scaffold types, tier entry points, extension quality tests differ by subject) but their structure is shared: output structure (R1), standard scope preservation (R2), tier entry points (R3), below-level scaffolds with a density cap (R4), required pedagogical infrastructure (R5), invisible modifications (R6), within-level progressive scaffolding (R7), and scope/defaults (R8).

---

Copyright guardrail

Always write original content. When the source lesson draws from a named curriculum (IM, OpenSciEd), use it to understand structure, scope, task context, and standards alignment only — never reproduce student-facing text, activity narratives, investigation prompts, comprehension questions, or problem contexts verbatim from curriculum materials. Each subject reference file carries a Copyright line with subject-specific details.

If curriculum is NOT confirmed (see Step 0.2 detection rules), never name a specific curriculum, module, unit number, lesson number, or proprietary routine name anywhere in the output or in any chat message — even if recognizable from training. The source lesson and KG data inform the design without being cited. See Step 0.2 for the full rule (P9).

---

Step 4 — The draft offer

The teacher gets the choice of a fast draft before the build. The offer is asked the same way as the clarify questions — through the structured question tool when one is available, in chat otherwise — as its own separate question, batched with whatever you ask before Step 2 (state, source lesson, learner needs) and asked on its own when nothing else needs asking.

• Question: *Should I go ahead and build the full classroom-ready set (teacher plan + three tier documents, as

editable Word docs), or do you want to see a quick draft first?*

• Options: Go ahead and build it · Quick draft first — what changes for each

tier, right here in chat

The full set is the default. Declining, not answering, or anything like "proceed with your defaults" runs Steps 2–3 and goes straight to Step 5; the draft happens only on a clear yes.

The draft (on a yes) is built on Steps 2–3, never instead of them. Run Step 2 in full — every KG call, exactly as written — and Step 3 before sketching anything. A draft sketched without the Step 2 grounding is a critical failure, the same failure as skipping the KG on the full build. Then present the design in chat — the draft is chat text only; rendering happens at Step 5 once the teacher approves. Show:

• one line reading back the source lesson, standard, and grade;
• for each tier (below / at / above), 2–3 bullets on what changes and why;
• the student work at a glance — each tier's actual tasks, enough for the teacher to

skim and judge coverage;

• one line on what every tier shares — the essential question or core task — and the

regroup rule

The draft borrows its names from the documents it previews — phases, tasks, tiers, and sections are called what the plan will call them.

Afterwards, ask what's next — a structured question, two options:

• Make changes — adjust any tier or the shared task
• Create the materials — teacher plan and the three tier documents, as editable Word

documents

Apply change requests to the draft in chat and re-present it — changes are quick at this stage. Step 5 runs in the turn the teacher gives the go-ahead ("Create the materials", "proceed with your defaults", or similar).

---

Step 5 — Output (one turn)

Runs immediately when the teacher chose the full set, or in the turn the draft is approved.

Four artifacts — 1 teacher-facing plan + 3 student tier documents (below / at / above) — are all rendered by a bundled script from one differentiation.json (the material source). Anything that appears in more than one artifact (standard, problem/task set, exit ticket, vocabulary, sentence supports, misconceptions) lives ONCE in the JSON's shared block and is pulled into each document with {"type": "from_shared", "key": …} blocks, so the teacher plan and the tier documents cannot drift apart — and R6 (same context, same core tasks across tiers) is enforced structurally.

Never write layout code, never re-type content into another format, and never edit a generated document directly — every change goes into differentiation.json and is re-rendered (re-rendering is instant).

Plain language with the teacher. The machinery above is invisible to the teacher: never mention JSON, HTML, schemas, scripts, rendering, file names (differentiation.json), or code in any teacher-facing message — and never link or name the .html files the render command also writes. Say "Here's your differentiation plan — the three tier documents are on their way", not "I've rendered differentiation.json". The only format word in your prose is "Word document". This applies to every turn: presenting artifacts, the satisfaction ask, revision summaries, and error messages (if generation fails, say the documents couldn't be created — not that a script or JSON failed).

Density rules — hard requirements for every document. Teachers consistently flag dense walls of text. Structure beats prose:

• A paragraph or labeled block is at most 3 sentences. Longer → split it, bullet it, or

table it.

• Bullets are fragments — one idea each, ≤ ~15 words; never chain clauses with semicolons.
• Parallel tier content (Below / At / Above doing the same phase differently) goes in ONE

table block — rows = phases or features, columns = tiers, ≤ ~25 words per cell — never three back-to-back multi-sentence paragraphs.

• An aside longer than one sentence (misconception watch-fors, confer prompts, deployment

guidance) becomes its own callout block, not a sentence buried in a paragraph.

• Quote the standard verbatim exactly once (the target-standard callout, from shared).

Everywhere else — prerequisite grounding, forward connections — reference by code plus a gist of ten words or fewer; never re-paste full standard text.

• A section that runs past about half a page of continuous prose must be restructured

(table, bullets, or split into two sections) before rendering.

Pre-write cross-check — run ALL checks before calling the render script. Do not render until every item passes.

O6 — Artifact alignment (both directions):

1. Plan → tier documents. List every task the plan says students do — tier problems/tasks,

exit ticket, the anchor activity, anything assigned to "early finishers." Each must have a printed student-facing block on at least one tier document (the anchor activity on all three, via from_shared: anchor_activity). A task that exists only as a plan description fails.

1. Tier documents → plan. For each tier document, list every printed task — each

problem/task, the extension and each of its printed sub-parts, anything printed on one tier only, the exit ticket, "If you finish early," "Reflect." Each must appear in that tier's Worksheet tasks line in the plan, with its scaffold named (e.g., "P1 (tape diagram + sentence support)" not just "P1"). A printed task the plan never names fails — a named scaffold the worksheet does not print fails — and so does a plan line naming a task or organizer no tier document prints.

Shared content is guaranteed by from_shared blocks; the check targets document-specific blocks and plan prose. Also confirm the exact shared.standard_code string appears in each of the three tier documents' eyebrow ("[Grade] [Subject] · [standard_code]") — the standard must be named on every tier, not only in the teacher plan. Fix mismatches before rendering.

Classroom-ready (every document): the tiers run on what the teacher already holds. Every resource a worksheet or the plan names is a printed block in this package, equipment the classroom has, or a sourced resource with its access path stated — exact title and source, a link when you could confirm one. A visual a task depends on prints on the worksheet that uses it, or the task is rewritten to work from what does print. Anything harder to get than that stays out unless the teacher steered toward it.

P8 — Flexible grouping (confirm in teacher plan JSON):

• The Flexible Grouping section states the evidence or basis used to assign students to each

tier (e.g., a specific prior exit ticket, diagnostic score, or "Default profile applied — no diagnostic data available"). A blank or generic statement fails.

• The section includes an explicit statement that tier assignments are revisable based on

formative evidence from THIS lesson (not a standing ability track).

O4 — Rationale notes (confirm in teacher plan JSON):

• Why this works (1) and `Why

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: learning-commons-org
• Source: learning-commons-org/agent-skills
• License: Apache-2.0

Install and usage instructions live in the source repository linked above.