playbooks

home / skills / simhacker / moollm / constructionism

constructionism skill

/skills/constructionism

This skill helps you learn by building and inspecting MOOLLM microworlds, turning state and files into verifiable, modifiable knowledge.

npx playbooks add skill simhacker/moollm --skill constructionism

Review the files below or copy the command above to add this skill to your agents.

Files (5)
SKILL.md
4.8 KB
---
name: constructionism
description: Educational philosophy — learn by building inspectable things
allowed-tools: []
tier: 0
protocol: CONSTRUCTIONISM
origin: "Seymour Papert — Logo, Mindstorms (1980)"
lineage:
  - "Seymour Papert — Constructionism, Logo, Mindstorms (1980)"
  - "Marvin Minsky — Society of Mind, K-lines (1986)"
related: [play-learn-lift, society-of-mind, leela-ai, manufacturing-intelligence, room, yaml-jazz, adventure, skill, schema-mechanism, debugging]
tags: [moollm, philosophy, education, papert, microworld, learning]
---

# Constructionism

> *"If you can build it, you can understand it. If you can inspect it, you can trust it."*

Seymour Papert's educational philosophy: you learn best by **building things** you can **inspect and modify**. Not passive consumption. Not abstract explanation. **Construction.**

## The Tradition

**Logo Microworlds** — Children don't learn geometry from textbooks. They teach a turtle to draw shapes:

```logo
TO SQUARE :SIZE
  REPEAT 4 [FORWARD :SIZE RIGHT 90]
END
```

The child:
1. **Builds** the procedure
2. **Runs** it and sees results
3. **Debugs** when it's wrong
4. **Understands** geometry through construction

## MOOLLM as Microworld

| Logo | MOOLLM |
|------|--------|
| Turtle | Agent/Character |
| Canvas | Room floor |
| Procedures | Skills |
| Variables | YAML state |
| Drawing | File creation |

**Everything is inspectable.** Open `ROOM.yml` — see the state. Read `session-log.md` — see the history. Modify `character.yml` — change the world.

## Core Principles

### Low Floor
Easy to start — no setup, just explore:
```
> LOOK
You are in the workshop.
> EXAMINE hammer
A simple claw hammer.
```

### High Ceiling
Unlimited complexity — build custom skills, complex pipelines, new protocols.

### Wide Walls
Many paths to many goals — adventure games, workflow automation, knowledge organization.

## Learning by Doing

### The Debug Cycle

1. **Try** something — it doesn't work
2. **Inspect** state — see what happened
3. **Hypothesize** — "maybe the path is wrong"
4. **Modify** and retry — test the hypothesis
5. **Understand** — now you know how it works

### Cheating is Learning

From Don's Logo Adventure:

> Type `PRINT :ITEMS` to see where everything is.
> Type `MAKE "RNUM 5` to teleport to the treasure room.
> **If you cheat, you win by learning Logo.**

"Cheating" in MOOLLM:
```
> Open character.yml directly
> Add "magic_sword" to inventory
> You've learned YAML and file structure!
```

The system rewards curiosity with knowledge.

## Micropolis: The Dream

Don's Micropolis for OLPC applied the same philosophy to SimCity:
- Open source simulation
- Scriptable in Python
- Kids can modify the rules
- The city IS the curriculum

MOOLLM applies this to LLM agents:
- Open file state
- Scriptable in any language
- Users can modify the rules
- **The filesystem IS the microworld**

### Embed Micropolis in MOOLLM

```
cities/downtown/
├── ROOM.yml           # Room metadata
├── city.save          # Micropolis save file
├── state.yml          # Extracted game state
├── newspaper/         # Generated stories
├── advisors/          # Expert cards
└── session-log.md
```

LLM reads state, plays the game, summons advisors.

## PLAY-LEARN-LIFT

Constructionism in action:

1. **PLAY** — Explore manually, make messes
2. **LEARN** — Notice patterns, understand
3. **LIFT** — Extract principles, create skills

You don't design skills in the abstract. You **build them** from experience.

---

## Drescher's Schema Mechanism

Gary Drescher's *Made-Up Minds* (1991) extends constructionism into a computational theory of how minds learn causal models. Drescher was a student of Minsky at MIT.

**See: [../schema-mechanism/](../schema-mechanism/)** for the full treatment.

### The Core Idea

A **schema** is a causal unit: `Context → Action → Result`

The agent discovers schemas through experience, refining them via **marginal attribution** -- tracking which conditions correlate with success.

### Connection to PLAY-LEARN-LIFT

| Schema Mechanism | PLAY-LEARN-LIFT |
|-----------------|-----------------|
| ACT + OBSERVE | PLAY |
| ATTRIBUTE (marginal attribution) | LEARN |
| SPIN OFF (refine schemas) | LIFT |

### Why LLMs Complete Drescher

| Aspect | Deterministic | LLM + YAML Jazz |
|--------|---------------|-----------------|
| Items | Opaque tokens | Grounded meanings |
| Patterns | Statistical correlation | Semantic understanding |
| Spin-offs | Mechanical | Creative generalization |
| Explanations | None | Natural language |

> *"The YAML provides the skeleton; the LLM provides the soul."*

---

## The Insight

> *"If you can build it, you can understand it."*
> *"If you can inspect it, you can trust it."*
> *"The filesystem IS the microworld."*

See also: [schema-mechanism](../schema-mechanism/) for Drescher's computational extension.

Overview

This skill presents constructionism as a hands-on educational approach: learn by building inspectable, modifiable artifacts. It frames a microworld workflow where files, YAML state, and logs are the playground for experimentation and discovery. The emphasis is on play, iterative debugging, and lifting general principles from concrete tinkering.

How this skill works

The skill models learning as cycles of doing and inspecting: perform an action in the microworld, read the resulting YAML/state and session logs, form hypotheses, modify files or skills, and retry. Everything is intentionally transparent: room files, character state, and session history are human-editable so learners can trace cause and effect. It also maps Drescher’s schema mechanism (Context → Action → Result) onto this workflow to help learners discover causal rules.

When to use it

  • Teaching programming and systems thinking through concrete projects.
  • Designing interactive learning environments where state is inspectable and editable.
  • Prototyping agent skills that must be debuggable and explainable.
  • Introducing learners to YAML, file-based state, and reproducible experiments.
  • Exploring causal learning and schema induction with human-guided trials.

Best practices

  • Start with a low-floor example (a single room, one agent, a simple file) so learners get immediate feedback.
  • Encourage making mistakes: inspect state and logs rather than hiding internals.
  • Keep state files small, well-documented, and human-readable (YAML recommended).
  • Iterate in short cycles: try, inspect, hypothesize, modify, and re-run.
  • Expose history (session-log) so learners can replay and reason about past actions.

Example use cases

  • A classroom activity where students teach a virtual agent to navigate rooms by editing behavior files and observing the results.
  • A workshop that teaches YAML and debugging by having participants add items to character.yml and observe consequences.
  • Building a mini-sim (Micropolis-style) where learners modify simulation rules and see city behavior change.
  • Rapidly prototyping LLM-driven skills by iterating on skill files and reading session logs to refine behavior.
  • Using the schema mechanism to help learners extract causal rules from repeated trials in a microworld.

FAQ

How is this different from passive tutorials?

Constructionism emphasizes building and inspecting real artifacts rather than following step-by-step instructions; learners form and test hypotheses by modifying the system itself.

Do learners need programming experience?

No. Start with simple, guided edits (e.g., change a value in YAML) and escalate complexity as confidence grows.