KUD Knowledge Type Mapper Agent Skill

Classify curriculum content into Know, Understand, and Do categories to align teaching and assessment approaches.

Context cost
11.5k tokensestimated from the bundle, loaded when it triggers
Bundle
1 file · 46.0 kBtext throughout, nothing executable
Licence
not declarednone named by its author
Last change
—v1.0
Servers it uses
Noneruns standalone

What it does

Classify curriculum content into Know, Understand, and Do categories to align teaching and assessment approaches. Use when planning units, writing objectives, or selecting assessment methods.

What this skill changes about the agent has not been set out here as a list. Its SKILL.md, shown below, says it in the author’s own words.

assessment-routingbernsteincurriculum-mappinghierarchicalhorizontalknowledge-typekudwiggins-mctighe

The skill itself

A skill is instructions the model reads, so you can see what you are getting: below is the start of its SKILL.md. The front matter loads with every session, the body loads when the skill triggers, and the whole file comes with the install.

SKILL.md46.0 kB · preview
--- # AGENT SKILLS STANDARD FIELDS (v2) name: kud-knowledge-type-mapper disable-model-invocation: false user-invocable: true effort: medium # EXISTING FIELDS skill_id: "curriculum-assessment/kud-knowledge-type-mapper" skill_name: "KUD Knowledge Type Mapper" domain: "curriculum-assessment" version: "1.0" evidence_strength: "moderate" evidence_sources: - "Wiggins & McTighe (2005) — Understanding by Design: Know/Understand/Do as the unit-level planning architecture" - "Wiggins & McTighe (2011) — The Understanding by Design Guide to Creating High-Quality Units: KUD as the bridge from standards to assessment" - "Bernstein (1999) — Vertical and horizontal discourse: hierarchical vs horizontal knowledge structures" - "Bernstein (2000) — Pedagogy, Symbolic Control and Identity: recontextualisation and knowledge type" - "Hattie (2009) — Visible Learning: surface, deep, and transfer as learning phases with distinct assessment needs" - "Hattie & Timperley (2007) — The power of feedback: feedback must be calibrated to the type of learning" - "Wiliam (2011) — Embedded Formative Assessment: assessability as a design constraint, not an afterthought" - "Deci & Ryan (1985, 2000) — Self-Determination Theory: autonomy-supportive assessment for dispositional development" - "Muller (2009) — Forms of knowledge and curriculum coherence: conceptual vs contextual coherence" - "Maton (2014) — Knowledge and Knowers: Legitimation Code Theory (Semantics dimension)" input_schema: required: - field: "curriculum_input" type: "string" - field: "learner_stage" type: "string" optional: - field: "knowledge_architecture_output" type: "string" - field: "existing_learning_targets" type: "string" - field: "competency_framework" type: "string" - field: "programme_purpose" type: "string" output_schema: type: "object" fields: - field: "kud_chart" type: "object" - field: "do_split" type: "object" - field: "assessment_routing_plan" type: "object" - field: "sequencing_notes" type: "object" - field: "gap_analysis" type: "object" - field: "design_flags" type: "object" chains_well_with: - "curriculum-knowledge-architecture-designer" - "learning-target-authoring-guide" - "coherent-rubric-logic-builder" - "dispositional-knowledge-assessment-designer" - "developmental-band-system-designer" teacher_time: "5 minutes" tags: ["KUD", "knowledge-type", "assessment-routing", "Wiggins-McTighe", "Bernstein", "curriculum-mapping", "hierarchical", "horizontal", "dispositional", "backwards-design"] ---
79# KUD Knowledge Type Mapper
80
81## What This Skill Does
82
83Takes a curriculum input — a unit description, competency set, or project brief — and produces a complete Know/Understand/Do chart where every element is labelled with its knowledge type (Hierarchical, Horizontal, or Dispositional) and routed to the correct assessment approach. This is the operational bridge between the Curriculum Knowledge Architecture Designer (which diagnoses what types of knowledge are present) and the assessment skills that build the actual instruments: Coherent Rubric Logic Builder for skills, Dispositional Knowledge Assessment Designer for dispositions. Most KUD charts treat all three columns as equivalent. They are not. A Hierarchical Know element (facts with right/wrong answers) and a Horizontal Know element (contested conceptual knowledge) require fundamentally different assessment — the first can be auto-assessed, the second requires interpretive judgment. A Do that is a skill (assessed by rubric against criteria on a specific task) and a Do that is a disposition (assessed through multi-informant observation over time) cannot be assessed the same way — and routing a disposition to a rubric actively undermines it. This skill makes those distinctions explicit so that every element in the KUD chart has a clear, defensible assessment pathway before teaching begins. AI is specifically valuable here because producing a knowledge-typed KUD chart requires simultaneously applying curriculum epistemology (Bernstein's knowledge structures), assessment design logic (Wiliam's assessability constraints), learning science (Hattie's surface/deep/transfer distinction), and motivation theory (Deci & Ryan's autonomy conditions) — a combination that is rare in any single educator and that most planning processes skip entirely.
84
85## Evidence Foundation
86
87Wiggins & McTighe (2005, 2011) established Know/Understand/Do as the canonical unit-level planning architecture within Understanding by Design. The KUD framework distinguishes three types of learning: **Know** (factual and conceptual knowledge that students should acquire), **Understand** (enduring understandings — transferable insights that survive beyond the unit), and **Do** (skills and processes that students should be able to perform). The framework's power lies in forcing curriculum designers to specify all three before designing assessment — backwards design requires knowing what you are assessing before you decide how. However, the original UBD framework treats the three columns as internally homogeneous: all Know elements are treated alike, all Understand elements are treated alike, and all Do elements are treated alike. This is the gap the present skill addresses.
88
89Bernstein (1999, 2000) demonstrated that knowledge is not a single substance. **Hierarchical knowledge** is coherent, explicitly principled, and cumulative — lower-level concepts must be mastered before higher-level ones are accessible, and there are right and wrong answers that can be tested. **Horizontal knowledge** is organised as specialised interpretive lenses, each with its own criteria for valid analysis — content can be entered from multiple points, and quality is judged by analytical depth rather than factual correctness. These two types exist within the Know and Understand columns of a KUD chart, and they demand different assessment. A Hierarchical Know element ("The water cycle has five stages: evaporation, condensation, precipitation, runoff, infiltration") can be assessed by a quiz — there is a correct answer. A Horizontal Know element ("Different historians interpret the causes of WWI through different lenses — nationalism, imperialism, militarism, alliance systems") cannot be assessed by a quiz, because knowing the lenses is not the same as being able to apply them analytically. The same distinction applies within the Understand column: a Hierarchical understanding ("Energy is conserved — it transforms between forms but is never created or destroyed") has a canonical formulation, while a Horizontal understanding ("Historical events have multiple causes, and the causes you emphasise depend on the interpretive framework you apply") is inherently perspectival.
90
91Hattie (2009) identified three phases of learning — **surface** (acquiring new knowledge and skills), **deep** (integrating and consolidating, making connections), and **transfer** (applying learning to new contexts and problems). Each phase requires different teaching and different assessment. Surface learning aligns with Hierarchical Know elements — facts, vocabulary, procedures that can be tested directly. Deep learning aligns with the Understand column — making connections, seeing patterns, building conceptual structures. Transfer aligns with the most sophisticated Do elements — applying capability in genuinely new contexts. Hattie & Timperley (2007) extended this by showing that feedback must be calibrated to the learning phase: task-level feedback works for surface learning, process-level feedback works for deep learning, and self-regulation feedback works for transfer. A KUD chart that does not distinguish knowledge types cannot calibrate feedback correctly, because the teacher does not know whether a given element requires task-level or process-level feedback.
92
93Wiliam (2011) argued that assessment is only useful if it generates evidence that can be acted upon — and that the design of assessment must begin from the question "What would count as sufficient evidence that this student has learned this?" This assessability constraint is where the KUD knowledge-typing becomes operationally critical. Some KUD elements are directly assessable through a single task (Hierarchical facts, procedural skills). Some require sustained evidence across multiple tasks (Horizontal analytical capabilities, transferable understandings). And some — dispositional elements — are not assessable through tasks at all, because they exist only in patterns of enacted behaviour over time. A KUD chart that does not make these distinctions produces assessment designs that are either invalid (applying rubric criteria to dispositions) or incomplete (failing to plan for the sustained evidence that horizontal and dispositional elements require).
94
95Deci & Ryan (1985, 2000) established through Self-Determination Theory that assessment contexts experienced as controlling — where the learner perceives judgment rather than support — undermine the autonomy and competence needs that are prerequisites for dispositional development. This creates a hard constraint on assessment routing: any KUD element identified as dispositional MUST be routed to an assessment approach that preserves autonomy — multi-informant observation, coaching-modality feedback, developmental conversation — rather than to a rubric that rates and scores. Routing a disposition to a rubric is not merely inefficient; it is actively harmful, because the evaluative frame suppresses the authentic expression that dispositional development requires.
96
97## Input Schema
This is a preview of SKILL.md. Download or install the skill to get the whole thing.
In the file
SKILL.md6,357 words
Files1
Licencenot declared
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈1,050
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
10,450
on trigger
The instruction body, read only when the skill fires.
5.8%
of a 200k window
Ten skills this size would take about 58% of the window before you open a file.
050k100k150k200k context window

11.5k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

The procedure it runs

The procedure has not been set out here step by step. It is in the body of its SKILL.md: the start of it is shown above, and the whole file comes with the install.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

Its SKILL.md does not declare which tools it asks the agent for, so what it touches is whatever the instructions themselves ask for — read them before you install it.

What it asks for
Writes filesnot declared
Network accessnot declared

This SKILL.md carries no allowed-tools line, so neither is declared. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

1 file, 46.0 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md46.0 kB
What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file you can review in full before installing.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

# KUD Knowledge Type Mapper · 11.5k tokens when loaded · macOS, Linux mkdir -p .claude/skills && t=$(mktemp -d) && curl -fsSL -o "$t/bundle.tar.gz" https://mcprush.com/api/skills/kud-knowledge-type-mapper/bundle.tar.gz && tar -xzf "$t/bundle.tar.gz" -C "$t" && [ -d "$t/kud-knowledge-type-mapper" ] && { [ ! -e .claude/skills/kud-knowledge-type-mapper ] || { mv .claude/skills/kud-knowledge-type-mapper "$t/.previous" && echo "Previous copy moved to $t/.previous"; }; } && mv "$t/kud-knowledge-type-mapper" .claude/skills/ && echo "Installed .claude/skills/kud-knowledge-type-mapper"
On Windows, or any OS with Node 20+
npx mcprush@latest skill add garethmanning/kud-knowledge-type-mapper

Windows PowerShell says 'running scripts is disabled on this system'? Run Set-ExecutionPolicy -Scope CurrentUser RemoteSigned once, or type npx.cmd instead of npx (codex.cmd, gemini.cmd, grok.cmd likewise). PowerShell 7 needs neither. Writes to .claude/skills/kud-knowledge-type-mapper/ in the current project. For every project instead, run mkdir -p ~/.claude/skills && t=$(mktemp -d) && curl -fsSL -o "$t/bundle.tar.gz" https://mcprush.com/api/skills/kud-knowledge-type-mapper/bundle.tar.gz && tar -xzf "$t/bundle.tar.gz" -C "$t" && [ -d "$t/kud-knowledge-type-mapper" ] && { [ ! -e ~/.claude/skills/kud-knowledge-type-mapper ] || { mv ~/.claude/skills/kud-knowledge-type-mapper "$t/.previous" && echo "Previous copy moved to $t/.previous"; }; } && mv "$t/kud-knowledge-type-mapper" ~/.claude/skills/ && echo "Installed ~/.claude/skills/kud-knowledge-type-mapper" (macOS, Linux) — or add --global to the npx line. The curl line replaces .claude/skills/kud-knowledge-type-mapper/ only after the download succeeds, so files left there by another skill of the same name, or by an older release, do not mix in. A copy already there is moved aside, not deleted, and the line prints where.

Which clients pick it up on their own

A skill is a folder of text. Most of these read a skills folder and pick it up without being told; the rest take the same folder another way — an upload in the app, a parameter on an API call — and then choose it by its description just the same.

Claude Code.claude/skills/
Claude DesktopCustomize › Skills
ChatGPTSkills › Create › Upload
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok Build.grok/skills/
Microsoft CopilotSkills › Upload a skill
PerplexityComputer › Skills › Upload a skill
DeepSeek Harness.dsh/skills/
Zed.agents/skills/
Devin Desktop.devin/skills/
Windsurf (legacy).windsurf/skills/
OpenAI Agents SDKInstructions or sandbox Skills
HTTP / APIa request parameter
This release
Version1.0
Publishedno release date on file
PriceFree
Referencegarethmanning/kud-knowledge-type-mapper

Versions

v1.0 is what is on the shelf; no release here carries a date. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v1.0
  • No earlier releases have been published to the marketplace.
Pinning

The install command always fetches the release that is current the day you run it — v1.0 today — and cannot ask for an earlier one. The copy on your disk does not change until you run it again.

Reviews

—no reviews yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Sign in to review it

A review is tied to an account so it can be answered, edited and taken down by the person who wrote it.

Sign in
Who can post

Anybody with an account, one review each. It carries the version that was current when you wrote it, and the publisher may reply once.

Publisher
Servers0
Claim this skill