Uk English Lesson Planning

---
name: uk-english-lesson-planning
description: >
  Creates an England KS3/KS4 English lesson plan, student-facing materials, and observation template. Load this skill BEFORE asking the teacher any clarifying question about year group, key stage, text, focus, or timing. Use when a secondary English teacher in England needs a Key Stage 3 or Key Stage 4 (GCSE) English lesson built from scratch — reading, writing, spoken language, language study, or literature — even if the year group, focus, or text isn't yet stated. Do NOT load for marking, a rubric, exam feedback, a quiz, or a curriculum lookup — answer those directly. Triggers on explicit requests (lesson plan, mini-lesson, scheme of work, do-now) and implicit teacher intent: "I'm teaching the opening of Jekyll and Hyde to Year 10," "need a lesson on descriptive writing for my Year 8s tomorrow." Core signal: an English teacher needs new instructional content created. Board-agnostic — anchors KS4 to the DfE GCSE subject content and assessment objectives, never a single exam board. English only (KS3 & KS4); not for other subjects, and not for differentiating an existing lesson.
license: Complete terms in LICENSE
---

<!--
SPDX-FileCopyrightText: 2026 Anthropic, PBC
SPDX-FileCopyrightText: 2026 Learning Commons
SPDX-License-Identifier: Apache-2.0
Adapted for England KS3/KS4 English, grounded in the DfE AI-in-Education Content Store (AIECS).
-->

# England KS3/KS4 English — Lesson Planning

Produces a teacher-ready, curriculum-aligned English lesson plan + student-facing materials +
teacher observation template as editable Word documents in a single output turn, rendered from
one material-source JSON via bundled scripts. Grounds each lesson in the statutory England
curriculum — the DfE **Key Stage 3 English Programmes of Study** or the board-agnostic **GCSE
English Language / English Literature subject content and assessment objectives** — and, where
available, real curriculum content retrieved from the DfE AI-in-Education Content Store.

"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.

England terms only — Year 7–11, Key Stage 3 / Key Stage 4, GCSE, assessment objectives (AO1–AO6),
reading / writing / spoken language. Never American schooling language (grade, ELA, SWBAT, Lexile,
Common Core, state standards).

---

## 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 look up the relevant part of the national curriculum, pull in supporting
ideas from Oak National Academy where they exist, then build your lesson plan, student materials,
and observation template."*).

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",
"API", or "rendering".

---

## Step 0 — Route (silent, before anything else)

1. **Confirm English.** This skill is for English. If the request is clearly another subject,
   say so and stop.

2. **Key stage.** Determine Key Stage 3 (Years 7–9) or Key Stage 4 / GCSE (Years 10–11) from the
   prompt and any prior conversation. If a year group is named, map it. If neither is stated, it
   is a clarify priority (Step 1).

3. **Strand.** Determine the lesson's primary strand:
   - **reading / literature** — studying a text (novel, play, poetry, non-fiction), close analysis,
     comprehension, whole-text study. At KS4 this maps to **English Literature** unless the text is
     an unseen extract used to teach reading skills (then it is **English Language** reading).
   - **writing** — creative/descriptive/narrative writing, transactional/non-fiction writing,
     writing for audience and purpose. At KS4 this is **English Language** writing.
   - **spoken language** — discussion, debate, presentation, drama-based work (the KS4 Spoken
     Language endorsement; not separately graded but statutory).
   - **language study** — grammar, vocabulary, Standard English, language change/variation.

   Then read the reference file NOW: `references/english.md`. It defines the clarify priorities,
   the key-stage-band pedagogy, the section structure, and the lesson.json mapping. Do not draft
   before reading it.

4. **Grounding connector.** This skill grounds through a bundled script, `scripts/aiecs.py`, which
   queries the DfE AI-in-Education Content Store. It needs the subscription key in the environment
   variable `AIECS_SUBSCRIPTION_KEY`. Check whether it is set (Step 2 says what to do either way).
   The skill is fully functional without it — it falls back to the statutory curriculum and expert
   knowledge.

---

## Step 1 — Clarify

Read `references/english.md` first — its clarify section defines the priorities and defaults. Ask
0–2 clarifying questions — your judgment on what's relevant. Priority order: (1) key stage / year
group if not inferrable; (2) text or topic if missing; (3) the specific reading or writing focus
if a text is named but the angle isn't. Apply defaults silently for everything you don't ask about
(duration 50–60 min; board-agnostic GCSE at KS4; a suitable, widely-taught text when none is named,
flagged as a suggestion).

The **draft offer** (Step 4) travels with this message's questions as its own separate question —
output logistics, not lesson content — so it doesn't count toward the 0–2. When nothing needs
clarifying, the offer is asked on its own.

---

## Step 2 — Ground in the curriculum

Grounding anchors the lesson to the statutory England curriculum and, where the content store has
it, enriches it with real curriculum material. Full call sequences are in
`references/aiecs-content-store.md` — read it before grounding.

**If `AIECS_SUBSCRIPTION_KEY` is set:** run the grounding sequence in
`references/aiecs-content-store.md` BEFORE drafting — resolve the curriculum anchor
(`aiecs.py anchor …`) and, at KS4, retrieve supporting content (`aiecs.py enrich …`). Extract only
what that file specifies, then proceed to Step 3. Do not summarise the retrieval in chat.

**If it is not set (or a call fails):** draft from the statutory curriculum and expert knowledge,
and add this footer to the lesson plan: *"Curriculum focus reflects the statutory national
curriculum; built without live curriculum-store retrieval."* Do not invent citations or attribute
content to materials you have not seen.

**Key-stage reality (do not skip):** the content store has rich KS4 English content but essentially
no KS3-tagged English content. So:
- **KS4** grounds on the DfE GCSE subject content + assessment objectives AND real Oak National
  Academy lessons retrieved by `aiecs.py enrich --key-stage KS4`.
- **KS3** grounds on the DfE Key Stage 3 English Programmes of Study + your expert knowledge; any
  enrichment (`aiecs.py enrich --key-stage KS3`) returns English material from adjacent key stages
  to adapt — use it for ideas only, pitch it to KS3, and if you lean on it, tell the teacher the
  enrichment was adapted from adjacent key stages.

---

## Step 3 — Build the lesson

Follow the build section of `references/english.md`: key-stage-band structure, section structure,
and non-negotiables. Respect the **Copyright guardrail** below — never reproduce curriculum
student-facing text verbatim.

---

## Copyright guardrail

Always write original content. Retrieved curriculum materials (Oak National Academy, DfE, exam
material in the store) inform structure, scope, text selection, task design, and lesson-arc design
only — never reproduce their student-facing text, teacher notes, comprehension questions, model
answers, or activity narratives verbatim. The **one** exception is a short verbatim quote of a
statutory curriculum statement or assessment objective in the single "Curriculum focus" callout;
everywhere else, reference it by name plus a short gist.

A literary text a student reads is either public domain (a short extract may ship on the student
page, cited) or copyrighted (named in Materials with its source; the teacher provides copies —
say so in chat). Never reproduce copyrighted literary text in the package.

---

## Step 4 — The draft offer

The teacher gets the choice of a fast draft before the build. Ask it 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 Step 1's questions when there are any.

- Question: *Should I go ahead and build the full classroom-ready packet (lesson plan + student
  materials, as editable Word documents), or do you want to see a quick draft first?*
- Options: **Go ahead and build it** · **Quick draft first** — the lesson at a glance, right here
  in chat

**The full packet is the default.** Declining, not answering, or "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, then
Step 3, before sketching. Then present in chat only (rendering happens at Step 5 once approved):
- one line naming the year group / key stage, text or topic, and the curriculum focus the lesson is
  anchored to (name plus a gist of ten words or fewer, and the AO at KS4);
- a summary of at most 3 sentences (what students do and why it works for this class);
- the sequence as one bullet per phase (name, minutes, one line);
- the student work at a glance — the actual tasks students will do;
- what the lesson assumes students already know (prior learning / key vocabulary);
- the exit task.

Afterwards, ask what's next — a structured question, two options: **Make changes** ·
**Create the materials**. Apply change requests in chat and re-present. Step 5 runs the turn the
teacher gives the go-ahead.

---

## Step 5 — Output (one turn)

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

The artifacts are rendered by bundled scripts from **one material-source `lesson.json`**. It holds
a `shared` block (content registered once) and a `documents[]` array (each document authored as
free-form `sections`). A section's `heading` renders as a large title above its blocks; a block's
`label` renders as a bold lead-in. A label that repeats its section heading prints twice — labels
carry what the heading doesn't. You compose every page — lesson plan, student materials, observation
template, and any others the lesson needs (e.g. a source packet) — directly in `documents[]`.
Anything on more than one page is registered once in `shared` and pulled in with
`{"type": "from_shared", "key": …}`, so pages cannot drift.

Never write layout code, never re-type lesson content into another format, and never edit a
generated document directly — every change goes into `lesson.json` and is re-rendered (instant).
**Do not open, cat, head, or grep the renderer scripts** — their behaviour is fully specified by
§5a–5d and `references/example_lesson.json` is the complete schema.

**Plain language with the teacher.** The machinery is invisible: never mention JSON, HTML, schemas,
scripts, rendering, an API, file names, or code in any teacher-facing message — and never link the
`.html` files. Say *"Here's your lesson plan — the student materials and observation template are on
their way"*, not *"I've rendered lesson.json"*. The only format word in your prose is "Word
document". This applies every turn: presenting artifacts, the satisfaction ask, revisions, and
errors (if generation fails, say the documents couldn't be created).

**Density rules — hard requirements for every document.** Clear, brief, easy to skim. Include what
a teacher needs to teach it; leave out what merely demonstrates rigour. Headings use sentence case.
Structure beats prose:
- A `paragraph` or `labeled` block is at most 3 sentences. Longer → split, bullet, or table it.
- Write like a colleague's note: plain, direct sentences.
- Bullets are fragments — one idea each, ≤ ~15 words; never chain clauses with semicolons.
- Parallel variants (per-group supports, per-phase moves, tiered look-fors) go in ONE `table` —
  rows = phases/features, columns = variants, ≤ ~25 words per cell.
- A callout marks the few must-not-miss moments — a warning, a collect-before-moving-on, the one
  make-or-break move. A page where everything is boxed highlights nothing. Teacher asides go in
  `labeled` or `instructions` blocks.
- Each instruction lives in exactly one place; a phase's prose sets up and its blocks carry content.
- Quote the curriculum focus verbatim exactly once (the `special` callout). Everywhere else,
  reference by name + a ten-word gist.

**Everything matches — hard requirements.** A teacher trusts the package because every part agrees:
- The materials list and the phases agree exactly: every listed item is used by a named phase.
- **Classroom-ready:** the lesson runs on what the teacher already holds — a page this package
  ships, equipment the classroom has, or a sourced resource with its access path stated (exact
  title and source; a link only when confirmed). A printable the lesson depends on ships with the
  package.
- A task worded in two places (plan's "Students see" and the student page) uses identical wording.
- Student tasks match the skill named: reading and writing happen on paper; spoken-language tasks
  get spoken, discussed, or performed responses. At KS4, tasks rehearse the named assessment
  objective and, where relevant, the exam question style — board-agnostic (no board-specific paper
  numbers or mark schemes unless the teacher named a board).
- Model answers and worked examples are final text: every step decided before it lands.
- Exit-task sort buckets partition the answers: each example fits exactly one bucket.
- An answer space mirrors its ask: lines match what's requested; every box sits under a prompt.

**Reading level and workload.** Student-facing text reads at the students' reading level, which the
teacher may state separately from the year group ("my Year 9s read around age 8–10" means Year-9
content in sentences a weaker reader can access). Size the work to the lesson's minutes. Say "home
language", and print translations only into a language the teacher has named.

**Sentence supports** are plain text where students write — a sentence starter ("The writer
presents… ") or a fill-in frame with blanks. A support helps the student start, not answer. Place
each on the task whose writing move is hardest; weaker readers/writers and multilingual learners get
one on every task asking for composed sentences. Tasks that take a single word or annotation need
none.

**Spell out framework names** in teacher-facing documents — *assessment objective 2*, not bare
*AO2*, on first use in a document.

**Document integrity.** Every document is finished prose a teacher hands out or works from: every
in-document reference points at something in the package; Materials and the lesson match both ways;
phase minutes include transitions and sum to the stated period; teacher notes read as finished
sentences and a predicted error names one specific wrong response a real student would give; verify
every quotation and every AO reference.

### 5a. Write the complete `lesson.json` (same turn)

Write ONE `lesson.json` with two top-level keys: `shared` and `documents`.

**`shared` is a content registry.** It always carries the lesson identity — `grade`, `subject`,
`duration`, `standard_code`, `standard_text` (and `prerequisite_standard` when applicable). Beyond
that, register any content that appears on more than one page under a key you choose. A key's value
can be a string, a single block, a list of blocks, or a faceted object
`{teacher: …, student: … or null, stimulus?: [blocks]}`. On a **student** page only the `student`
facet (after any `stimulus`) renders — `student: null` prints nothing, which keeps oral or
teacher-led tasks off the worksheet. On a **teacher** page both facets render: the teacher facet as
plain script, then the student facet as one "Students see" line. Apart from `standard` (which
assembles `standard_code` + `standard_text` into the Curriculum-focus callout), key names carry no
special rendering.

**England identity fields — bind these correctly:**
- `grade`: the **year group as "Year N"** (e.g. `"Year 10"`). Use a year, never "Key Stage 4" here
  — the renderer sizes writing space from the number, and "Key Stage 4" mis-reads as a Year-4 pitch.
  Show the key stage in `eyebrow`/`meta` instead. If the request is whole-key-stage with no year,
  pick a representative year (KS3 → "Year 8"; KS4 → "Year 10").
- `subject`: `"English Language"`, `"English Literature"`, or `"English"` (KS3 general).
- `standard_code`: the curriculum-focus label — KS3 e.g. `"KS3 English — Reading"`; KS4 e.g.
  `"GCSE English Language — AO2"` or `"GCSE English Literature — AO1 & AO2"`.
- `standard_text`: the verbatim statutory statement (KS3 programme-of-study line) or assessment
  objective wording (KS4), from the Step 2 anchor.
- `prerequisite_standard`: prior learning, one line (renders as "Builds on").
- Do **not** set `smps` (a maths field).

**`documents[]` is where you compose each page.** Each entry:
`{id, audience: teacher|student, eyebrow, title, meta?, theme?, sections[{heading, blocks[]}]}`.
Include at minimum:
- `id: "lesson_plan"` (`audience: "teacher"`) — the section structure from `references/english.md`.
- `id: "observation_template"` (`audience: "teacher"`) — how-to-use, look-fors, misconceptions, a
  `fill_table` for student notes, and the exit-task sort.
- `id: "student_materials"` (`audience: "student"`) — **when students hold a printed page** (nearly
  always for KS3/KS4 English; a purely oral spoken-language lesson may have none). A text-heavy
  lesson may add a separate `id: "source_packet"`. If the teacher asked for tiered materials, label
  them Group A / B / C (A = additional support, B = core, C = greater depth); level wording stays in
  the teacher-facing documents.

Pull registered content with `{"type": "from_shared", "key": "…"}`; adding `"label": "1"` renders it
as a numbered item. Within one document, pull each key once. Content on only one page can be inline.

**Schema** — sufficient on its own; do not read any other file for the schema:

```
shared:
  grade("Year N"), subject, duration, standard_code, standard_text   (required identity)
  prerequisite_standard?
  <any key you choose>: string | block | block[]
                      | {teacher: …, student: … or null, stimulus?: block[]}
  (only `standard` is special — it assembles standard_code+standard_text)
documents[]: {id, audience: teacher|student, eyebrow, title, meta?, theme?,
              sections[]: {heading, color?, blocks[]}}
block types:
  {type: from_shared, key}
  {type: paragraph, text} | {type: labeled, label, text}
  {type: callout, kind: special|student-task|teacher-note|student-note, label, text}
  {type: h2|h3, text} | {type: list, label?, ordered?, items[]}
  {type: phase_header, name, minutes} | {type: cards, items[{title, text}]}
  {type: table|data_table, headers[]?, rows[[]]}
  {type: fill_table, headers[], blank_rows: int, row_height_pt?}
  {type: source_card, title, author?, date?, origin?, excerpt}
  {type: answer_box, height_pt?, ruled?} | {type: page_break}
  {type: group, blocks[]} | {type: columns, left[], right[]}
```

`references/example_lesson.json` is a filled-in worked example (a KS4 English Language lesson). Keep
writing tight; no emoji in JSON content. Print-safety: never markdown pipe tables (use
`table`/`data_table`). The renderer cannot draw images — anything the teacher displays lives in the
lesson plan (named in Materials and the phase script). A student page carries only what is printed
on it.

**Which block when** — pick by what the content *is*:

| Block | Use it for |
|---|---|
| `callout` `kind: special` | The one anchoring fact per document — the curriculum focus. Once. |
| `callout` `kind: student-task` | Any task students do: a starter, an analysis task, the exit task. |
| `callout` `kind: teacher-note` | An aside the teacher reads but doesn't say aloud: a watch-for, a conferring move. |
| `list` `ordered: true` | A numbered sequence (a set of questions, procedure steps). Unordered otherwise. |
| `phase_header` | A lesson phase; its `minutes` across all phases sum to `shared.duration`. |
| `h3` | A title above one block (a table, the look-fors, an annotation key). |
| `cards` | 2–4 parallel items of similar length — exit-task sort buckets, tier summaries. |
| `table` (no `headers`) | Term/definition pairs; a quotation/analysis reference. |
| `table`/`data_table` with `headers` | Real tabular data (misconceptions, method-analysis grids, an annotation model). |
| `fill_table` | An organiser students write into — a quotation-analysis grid, an evidence collector, an observation log. |
| `source_card` | A text extract students read: title/author/date + the excerpt (public-domain or teacher-supplied only). |
| `answer_box` | Writing space after a task. `ruled: true` draws lines for composed sentences; omit for open annotation space. |
| `group` | Keeps a task's prompt, stimulus, supports, and answer box together across a page break. |

### 5b. Render every Word document — one command, same turn

```bash
bash scripts/render_all.sh lesson.json "$OUTPUT_DIR"
```

This writes one editable `.docx` per `documents[]` entry, named by `id`, plus `.html` twins and the
`lesson.json` working file. Render into `$OUTPUT_DIR` and leave everything in place — revision turns
re-render from the working files. Then list `$OUTPUT_DIR` and confirm every document has both its
`.docx` and `.html`; if either is missing or tiny, rerun. Present the Word documents together —
attach the lesson plan last so it lands on top. If there's no `student_materials`, say so plainly.
If the script errors, fix `lesson.json` (almost always malformed JSON) and rerun. If generation
fails entirely, say so — never silently fall back to chat-only delivery.

### 5c. The satisfaction ask + iteration options (every output turn)

End with EXACTLY ONE closing message that: (1) if Materials names a printable this lesson wrote
(annotation grid, extract, sorting cards), notes it ships with the pack; (2) asks whether the
teacher is satisfied with **every artifact** or wants changes — *"Take a look at the lesson plan,
student materials, and observation template — anything you'd like me to adjust?"*; (3) offers 3–4
specific iteration options customised to the text and focus — e.g. *"Would you like me to (1) add
more scaffolding for lower-prior-attainment readers, (2) build in an exam-style question with a
model paragraph, or (3) extend it into a two-lesson sequence?"* Never write "let me know if you want
changes".

### 5d. Revisions — one edit, every artifact stays in sync

Make **targeted edits to `lesson.json`**, then re-render (instant). If the change touches content
registered in `shared` (a task, an extract, the exit task, vocabulary, look-fors), edit it **in
`shared`** — every document that pulls that key updates. After any context/text/quotation change,
re-read every prose block in every document and update every sentence still naming the old text or
quotation — stale prose is the most common failure. A change aimed at one document goes in that
document's `sections`. Styling: `theme` fields (`primary`, `title_size`, `body_size`) apply to every
artifact; keep colour minimal so pages print cleanly in black-and-white.

### 5e. Supplementary artifacts in their best format

The `lesson.json` pipeline is for the lesson's document set. An artifact whose value depends on its
form — cut-out cards, a display poster — belongs outside it, as its own file in whatever format
produces the best version (e.g. a print-ready PDF). Source any shared content from `shared` so pages
can't drift, and name the file in Materials like any other page.