Pedagogy
Meta-content about teaching and learning videogame design.
Pedagogy Entries
| Entry | What it covers |
|---|---|
| Play → Name → Make → Reflect | The weekly rhythm of VG101 |
| Why Unity | The engine as workshop for constraints |
| The Final Project | Make one action feel undeniable |
| Debugging as Literacy | Reading and responding to systems |
| Accessibility as Craft | Inclusive design as design quality |
| Code as Material | Design through implementation |
Core Insight
Videogame design is learned by making, not by absorbing theory. The pedagogical approach here is: experience first, vocabulary second, making third, understanding fourth. The Play → Name → Make → Reflect cycle.
Code isn't a prerequisite; it's a material. Debugging isn't remediation; it's literacy. Accessibility isn't compliance; it's craft.
VG101 Structure
The full VG101 course structure lives in the course materials, but the rough shape:
| Weeks | Focus | Core Concept |
|---|---|---|
| 1-4 | Core Framework | Gesture, Aesthetic Heritage, Permissions |
| 5-8 | Feel & Communication | Feedback, Readability, The 30-Minute Action |
| 9-12 | Meaning & Synthesis | Ludonarrative, Procedural Rhetoric, Final Project |
Each week follows Play → Name → Make → Reflect.
For Educators
These entries explain how we teach the Framework concepts, not just what they are. If you're adapting this material for your own teaching, the Pedagogy section tells you the reasoning behind the sequence.
Why This Section Exists
Most videogame design resources present content as if teaching it is straightforward: here's the knowledge, now students know it. But teaching videogame design is its own craft.
The Pedagogy section makes explicit what's often implicit: why concepts are sequenced the way they are, what common misconceptions arise, how to assess design thinking rather than rote recall.
Using These Pages
Each Pedagogy page has:
- Practice: The approach itself - what students do
- Craft: Teaching notes - how to implement it
- Theory: Theoretical grounding - why it works
The Craft register on Pedagogy pages is meta-pedagogy: teaching teachers how to teach the approach.
Assessment Philosophy
VG101 assesses reflection and making, not vocabulary recall. If the rhythm is play → name → make → reflect, assessment should match. Students demonstrate understanding by making things and articulating what they learned, not by defining terms on a test.
Theoretical Foundations
The VG101 pedagogical approach draws from several traditions:
Experiential Learning (John Dewey, David Kolb): Learning by doing. Experience precedes abstraction. The philosophical backbone of the Play → Name → Make → Reflect cycle.
Studio Pedagogy: Art, architecture, and design schools use variations of make-critique-reflect-iterate. VG101 adapts this for videogame design.
Constructionism (Seymour Papert): Learning happens through making things. The Code Bank and making exercises reflect this.
What We're Resisting
The lecture-exam model: Videogame design isn't learned by absorbing information. It's learned by making things and understanding what you made.
Theory-first approaches: Students learning words without referents. "Ludonarrative dissonance" means nothing until you've felt the dissonance.
The naturalistic fallacy: Just playing doesn't teach design. Unstructured play is valuable, but it's not education. Structure (naming, focused making, reflection) is essential.
Unresolved Questions
- How does this approach scale? Studio pedagogy is labor-intensive. How do you run it with 100 students?
- Does every concept benefit from the full cycle, or are some better taught directly?
- How do we assess process-oriented learning without distorting it?
References
- Dewey, John. Experience and Education (1938)
- Kolb, David. Experiential Learning (1984)
- Schön, Donald. The Reflective Practitioner (1983)
- Papert, Seymour. Mindstorms (1980)
- Fullerton, Tracy. A Playful Production Process (2024)
Related
- Play → Name → Make → Reflect - the core weekly rhythm
- Why Unity - the engine as design workshop
- The Final Project - make one action feel undeniable
- Debugging as Literacy - failure as learning
- Accessibility as Craft - inclusive design
- Code as Material - design through implementation