Technological Pedagogical Content Knowledge Developer Agent Skill

Develop TPACK for integrating a specific technology or AI tool into subject teaching with pedagogical alignment.

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

What it does

Develop TPACK for integrating a specific technology or AI tool into subject teaching with pedagogical alignment. Use when adopting new ed-tech, reviewing AI tools, or planning technology integration.

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.

ai-in-educationdocumentationed-techmishra-koehlerpedagogical-content-knowledgeprofessional-learningtechnology-integrationtpack

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.md43.9 kB · preview
--- # AGENT SKILLS STANDARD FIELDS (v2) name: technological-pedagogical-content-knowledge-developer disable-model-invocation: false user-invocable: true effort: medium # EXISTING FIELDS skill_id: "professional-learning/technological-pedagogical-content-knowledge-developer" skill_name: "Technological Pedagogical Content Knowledge Developer" domain: "professional-learning" version: "1.0" evidence_strength: "moderate" evidence_sources: - "Mishra & Koehler (2006) — Technological pedagogical content knowledge: A framework for teacher knowledge" - "Koehler & Mishra (2009) — What is technological pedagogical content knowledge?" - "Voogt et al. (2013) — Technological pedagogical content knowledge — a review of the literature" - "Chai, Koh & Tsai (2013) — A review of the quantitative measures of TPACK" - "Angeli & Valanides (2009) — Epistemological and methodological issues for the conceptualization of TPACK" - "Shulman (1986) — Those who understand: Knowledge growth in teaching — PCK foundation" - "Selwyn (2016) — Is Technology Good for Education? Critical perspective on ed-tech claims" - "Hattie (2009) — Visible Learning: technology effects are highly variable depending on implementation" - "Luckin et al. (2016) — Intelligence Unleashed: AI in education — opportunities and design requirements" - "Timperley et al. (2007) — Teacher Professional Learning and Development: content-specific PD" input_schema: required: - field: "teaching_context" type: "string" - field: "technology_in_use" type: "string" - field: "learner_stage" type: "string" - field: "teacher_background" type: "string" optional: - field: "pck_output" type: "string" - field: "intended_learning_outcome" type: "string" - field: "school_technology_context" type: "string" output_schema: type: "object" fields: - field: "tpack_diagnosis" type: "object" - field: "technology_content_knowledge" type: "object" - field: "technology_pedagogy_alignment" type: "object" - field: "ai_specific_guidance" type: "object" - field: "tpack_development_plan" type: "object" - field: "ethical_and_equity_considerations" type: "object" chains_well_with: - "pedagogical-content-knowledge-developer" - "curriculum-knowledge-architecture-designer" - "critical-thinking-task-designer" - "lesson-observation-protocol-designer" teacher_time: "10 minutes" tags: ["TPACK", "technology-integration", "AI-in-education", "pedagogical-content-knowledge", "Mishra-Koehler", "professional-learning", "ed-tech"] ---
81# Technological Pedagogical Content Knowledge Developer
82
83## What This Skill Does
84
85Takes a description of what a teacher is teaching, the technology they are integrating, and their background, then diagnoses their technological pedagogical content knowledge gaps and produces a development plan. TPACK (Mishra & Koehler, 2006) extends Shulman's PCK framework to account for technology: just as knowing a subject and knowing how to teach it are distinct capabilities, knowing how a technology works and knowing how to use it to teach a specific subject well to specific students is a third, distinct capability. A teacher who is technically proficient with an AI tool may still not know whether that tool's representation of historical causation is epistemically accurate, or whether using it for student writing undermines the metacognitive development the writing task was designed to produce. This skill addresses those intersections. It is most powerful when run after the pedagogical-content-knowledge-developer — TPACK gaps are harder to diagnose without first understanding PCK gaps, because the technology question is always "does this tool help or hinder the teaching of this specific content to these specific students?" and that question requires PCK to answer. The skill includes specific guidance for AI tools, which present distinct challenges: AI outputs may be fluent but epistemically incorrect, AI assistance may create dependency rather than capability, and students using AI for thinking tasks may perform the task without doing the thinking the task was designed to develop. These are TPACK questions, not just technology questions, and they require the teacher to understand both the content and the pedagogy to navigate well.
86
87## Evidence Foundation
88
89Mishra & Koehler (2006) proposed TPACK as a framework for understanding the knowledge teachers need to integrate technology effectively, building on Shulman's (1986) PCK. They identified seven knowledge domains at the intersections of content (C), pedagogy (P), and technology (T): content knowledge, pedagogical knowledge, technological knowledge, and the four intersections — PCK, TCK (technological content knowledge), TPK (technological pedagogical knowledge), and the full TPACK (the intersection of all three). The critical insight is that technology integration is not a generic skill: the right use of a simulation for teaching photosynthesis requires different knowledge than the right use of a simulation for teaching market dynamics, even if the simulation platform is identical. Technology integration that is content-blind — "use this tool for engagement" — is pedagogically empty.
90
91Koehler & Mishra (2009) extended the framework, arguing that effective technology integration requires understanding the "wicked problem" of how technology, content, and pedagogy interact in specific contexts. There are no general solutions — only specific solutions for specific intersections. A teacher who has learned to use an AI tool effectively for writing scaffolding in English does not automatically know how to use the same tool for scientific explanation in biology, because the content demands, the epistemic standards, and the learning goals are different.
92
93Voogt et al.'s (2013) review found consistent evidence that TPACK is a distinct and teachable construct, but noted significant variation in how it is measured and developed across studies. Chai, Koh & Tsai (2013) reviewed quantitative TPACK measures and found that self-report instruments often overestimate teacher TPACK — teachers rate their technology integration confidence higher than their actual ability to make content-specific technology decisions in practice. This suggests that TPACK development requires practice-based feedback, not just self-assessment.
94
95Angeli & Valanides (2009) argued that TPACK should be treated as a unique body of knowledge that is more than the sum of its parts — not just the intersection of three separate domains but a qualitatively distinct form of knowing that emerges from experience with specific technology-content-pedagogy combinations. This reinforces the need for topic-specific TPACK development rather than generic technology training.
96
97Hattie's (2009) meta-analysis found that technology in education has highly variable effects — effect sizes range from strongly negative to strongly positive depending on implementation. The meta-analytic average (d = 0.31) is modest, but the variation is enormous. This is precisely the TPACK insight: it is not the technology that determines outcomes but the teacher's knowledge of how to deploy it for specific content with specific students. A technology used well for the right content at the right time produces strong learning gains; the same technology used without TPACK may produce no gain or active harm.
98
99Selwyn (2016) provides a necessary critical counterweight to technology enthusiasm in education. Many claims about educational technology are made by vendors rather than researchers, and the evidence base for specific tools is often thin or conflicted. Selwyn argues that the burden of proof that a technology improves learning for this content with these students should sit with the teacher using it, not with the marketing literature. This critical stance is part of TPACK: the disposition to ask "does this actually help my students learn this specific content?" rather than assuming technology is beneficial by default.
This is a preview of SKILL.md. Download or install the skill to get the whole thing.
In the file
SKILL.md6,268 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,290
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
9,685
on trigger
The instruction body, read only when the skill fires.
5.5%
of a 200k window
Ten skills this size would take about 55% of the window before you open a file.
050k100k150k200k context window

11k 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, 43.9 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md43.9 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.

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

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/technological-pedagogical-content-knowledge-devel/ 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/technological-pedagogical-content-knowledge-devel/bundle.tar.gz && tar -xzf "$t/bundle.tar.gz" -C "$t" && [ -d "$t/technological-pedagogical-content-knowledge-devel" ] && { [ ! -e ~/.claude/skills/technological-pedagogical-content-knowledge-devel ] || { mv ~/.claude/skills/technological-pedagogical-content-knowledge-devel "$t/.previous" && echo "Previous copy moved to $t/.previous"; }; } && mv "$t/technological-pedagogical-content-knowledge-devel" ~/.claude/skills/ && echo "Installed ~/.claude/skills/technological-pedagogical-content-knowledge-devel" (macOS, Linux) — or add --global to the npx line. The curl line replaces .claude/skills/technological-pedagogical-content-knowledge-devel/ 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. It appears as technological-pedagogical-content-knowledge-developer in Gemini CLI, Codex, Copilot and Grok (its own name); Claude Code lists it by the folder name, technological-pedagogical-content-knowledge-devel.

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/technological-pedagogical-content-knowledge-devel

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