Repository navigation
Control of Error in Practice
Quick Scan
For: Educators, instructional designers, learning scientists
Time to first insight: 12 minutes
Prerequisites: Experience designing learning environments
What you'll understand: How your expertise in control of error translates directly to ML system design
If you've ever designed a self-correcting activity, you've implemented a principle that spans centuries of teaching practice: the learner must be able to detect and correct their own errors without external supervision.
Educators discovered this through systematic observation. Machine learning researchers formalized it with mathematical notation. Both communities arrived at the same insight independently—which is how you know it's real.
The technical term is "self-supervised learning with intrinsic reward signals." You've been doing it since your first year teaching.
Maria Montessori systematized what effective teachers have always done instinctively. Control of error is a design principle with three components that you recognize immediately:
The material itself reveals errors without delay. A puzzle piece that doesn't fit. A tower that topples. A word that doesn't match the picture.
Modern parallel: Dylan Wiliam's work on formative assessment loops. Feedback must be faster than the forgetting curve.
Technical translation: Observable prediction error as a learning signal. The system sees the discrepancy between prediction and outcome.
Errors are safe to make. The tower falls but doesn't break. The child tries again without shame, punishment, or resource cost.
Modern parallel: Carol Dweck's growth mindset research. Mistakes are information, not judgments.
Technical translation: Online learning with bounded regret guarantees. Each error contributes finite cost to the learning process.
The goal emerges from the task structure, not from teacher approval. The child knows when the tower is straight, the cylinders are ordered, the colors match.
Modern parallel: Self-determination theory (Deci & Ryan). Competence feedback from the environment, not from social comparison.
Technical translation: Task-aligned value functions. The system learns to predict outcomes that matter for the actual objective.
Let's map your existing practice to formal structures. These aren't metaphors—they're isomorphisms: the same underlying pattern, recognized across disciplines.
What you do: Start with the Pink Tower (10 cubes, clear size differences) before moving to the Brown Stair (same differences, less visual contrast) before combining both (integration task).
Why it works: Success on simpler tasks builds the perceptual discrimination needed for harder tasks. The error signal is stronger when differences are obvious.
Modern research: Bengio et al. (2009) on curriculum learning; Elman (1993) on "starting small" in language acquisition; Rohde & Plaut (1999) on staged training.
Technical parallel: Our system learns on high-confidence decisions first (large utility gaps, low boundary entropy) before adapting to ambiguous cases. The metric updates faster when prediction errors are clear.
graph LR
A[Clear Differences] --> B[Subtle Differences]
B --> C[Integration Tasks]
A --> D[Strong Error Signal]
B --> E[Refined Discrimination]
C --> F[Flexible Application]
style A fill:#e3f2fd
style B fill:#e3f2fd
style C fill:#e3f2fd
style D fill:#fff3e0
style E fill:#fff3e0
style F fill:#e8f5e9
Figure 2: Graduated difficulty progression. Simple tasks provide clear feedback; complexity increases as competence builds.
Code manifestation:
[Notebook content will be embedded by CI]
Generalization for you: When designing digital learning environments, the error signal should scale with task difficulty. Clear feedback on appropriately-challenging problems accelerates learning.
What you do: The Red Rods differ only in length. The Color Tablets differ only in hue. Control one dimension, hold others constant.
Why it works: Attention is limited. Learners—whether children or ML systems—learn most efficiently when they can focus on one dimension of variation at a time.
Modern research: Chi et al. (1989) on self-explanation; Schwartz & Bransford (1998) on contrasting cases; Kellman & Massey (2013) on perceptual learning modules.
Technical parallel: Our ablation studies disable one component at a time (metric updates off, controller off, coherence off) to measure causal contribution.
Code manifestation:
[Notebook content will be embedded by CI]
Generalization for you: When a learning system fails, you need to know which component failed. Design for inspectability. Every module should be independently testable.
What you do: Materials are sized for small hands. Shelves are at child height. Rugs define work spaces. The room itself guides behavior.
Why it works: Constraints reduce cognitive load. When the environment enforces boundaries, the learner's attention goes to the core task.
Modern research: Kirschner et al. (2006) on minimal guidance; Sweller (2011) on cognitive load theory; Kalyuga (2007) on expertise reversal.
Technical parallel: Our constraint solver enforces hard boundaries (privacy, regional restrictions) so the energy function can focus on utility trade-offs.
Code manifestation:
[Notebook content will be embedded by CI]
Generalization for you: When building adaptive systems, separating hard constraints (non-negotiable boundaries) from soft preferences (optimizable trade-offs) lets learners focus their energy where it matters most.
What you do: The child can see the tower getting taller, the map taking shape, the reading becoming fluent. Progress is visible in the artifact.
Why it works: Metacognitive awareness—knowing what you know—enables self-regulation. Learners adjust strategies based on perceived progress.
Modern research: Zimmerman (2002) on self-regulated learning; Schraw & Moshman (1995) on metacognitive theories; Azevedo & Witherspoon (2009) on scaffolding.
Technical parallel: Our certificates make prediction uncertainty visible. The system knows when it's confident (small utility gap, low entropy) vs. uncertain (boundary case).
Code manifestation:
[Notebook content will be embedded by CI]
Generalization for you: Confidence scores alone don't tell the full story. Learners benefit from understanding why they're uncertain (gap too small? contradictory evidence? novel context?). Multi-dimensional uncertainty representations support better self-regulation.
What you do: The child doesn't stack the Pink Tower once. They stack it dozens of times, with slight variations (different speeds, different orders, different focuses).
Why it works: Repetition builds automaticity. Variation prevents overfitting to one solution path. The combination develops flexible, robust knowledge.
Modern research: Bjork & Bjork (2011) on desirable difficulties; Rohrer & Taylor (2007) on interleaved practice; Soderstrom & Bjork (2015) on learning vs. performance.
Technical parallel: Our coherence functional learns from repeated successful routing decisions in similar contexts. The KDE captures distribution of successful states, not just one prototype.
Code manifestation:
[Notebook content will be embedded by CI]
Generalization for you: When designing practice systems, weight repetitions by success level. This creates a rich representation of what "good" looks like across various contexts, rather than just counting attempts.
These five strategies share a common foundation—one that appears across disciplines precisely because it reflects how learning actually works:
Learning requires a closed feedback loop where:
- The learner makes predictions (attempt)
- The environment reveals outcomes (feedback)
- The discrepancy drives adaptation (update)
- The process stabilizes over time (convergence)
Educators have always known this. Montessori systematized it in 1907. Control systems engineers formalized it mathematically in the 1940s. Reinforcement learning researchers explored it computationally in the 1980s. Neuroscientists found it in brain architecture in the 2000s.
Different fields. Same fundamental pattern. Same effective pedagogy.
graph TD
A[Student Attempts Task] --> B[Material Reveals Outcome]
B --> C[Student Observes Error]
C --> D[Student Adjusts Approach]
D --> A
C --> E[Competence Builds Over Time]
style A fill:#e3f2fd
style B fill:#fce4ec
style C fill:#fff3e0
style D fill:#e8f5e9
style E fill:#e3f2fd
Figure 1: The closed learning loop. Students predict, materials respond, errors drive adaptation, competence emerges through iteration.
Wiliam's "five key strategies" (clarifying learning intentions, eliciting evidence, providing feedback, activating learners as resources, activating learners as owners) map directly to observable error signals, low-stakes practice, and metacognitive monitoring.
Key insight: The classroom must be an information-rich environment where evidence of learning is continuously generated and used.
Connection to Compitum: Our certificates are formative assessment artifacts. They don't just report "model X chosen"—they expose why (utility components), how confident (boundary analysis), and what changed (drift status).
Hattie's meta-analyses identify feedback (effect size 0.70), metacognitive strategies (0.69), and self-questioning (0.55) as high-impact interventions.
Key insight: Learning is most efficient when the thinking is visible—to the teacher, to peers, and to the learner themselves.
Connection to Compitum: We make system thinking visible through decomposed utility (quality, latency, cost, distance, evidence). Not a black box score.
Wiggins argued that assessment should come first in curriculum design. If you can't specify how you'll know students learned it, you haven't defined "it" clearly enough.
Key insight: Backward design from observable evidence of understanding.
Connection to Compitum: We designed certificates before routing logic. The question wasn't "how do we pick models?" but "what evidence would prove we picked well?"
Duckworth's work on persistence connects to Ericsson's deliberate practice: improvement requires focused effort on weaknesses with immediate feedback.
Key insight: Not all practice is equal. Undirected repetition doesn't build skill.
Connection to Compitum: Our coherence functional weights samples by success. A routing decision that barely met constraints contributes less to the learned distribution than one that exceeded them.
Khan Academy's insight: don't move forward until current material is mastered. Traditional education's flaw is time-based progression regardless of understanding.
Key insight: Competence, not seat time.
Connection to Compitum: Our metric doesn't update on every decision—only when prediction error exceeds the trust radius. Don't learn from noise.
The central question: "What errors must students detect and correct to demonstrate mastery?"
When you can answer this clearly, you've identified where control of error belongs. Design materials—activities, assessments, environments—that contain their own feedback. Technology can then help scale these feedback loops while preserving their pedagogical integrity.
The opportunity: Build systems that help students see their own errors clearly.
The Pink Tower doesn't tell the child "wrong, try again." It falls. The child sees. The child adjusts. This immediate, judgement-free feedback drives learning.
Digital environments can implement the same principle: make thinking visible, make errors informative, make progress observable.
The opportunity: Uncertainty is information. When a student is confused, they're often at the edge of their current understanding—exactly where learning happens most effectively.
The research frontier: We have robust methods for training on clean labels. The next frontier is developing robust methods for learning from confusion, hesitation, and productive failure.
Montessori demonstrated this with physical materials. Digital equivalents remain an open and exciting challenge.
Here's a task for you (no coding required):
Design a self-correcting activity for teaching statistical inference.
Constraints:
- No teacher feedback allowed
- The material itself must reveal errors
- Errors must be low-stakes
- The student must know when they've succeeded
This is challenging because statistics is abstract. But if you can design this, you've internalized control of error at a deep level.
And: The design principles you use—graduated difficulty, isolated variables, observable progress—are precisely the principles our router implements in code.
Hint: Think about prediction games. Coin flips. Dice rolls. Sampling distributions. Can you design a sequence where the student makes predictions, sees outcomes, and the discrepancy teaches the concept?
That's what Compitum does. We just replaced coins with model performance and predictions with routing decisions.
Software engineers talk about "technical debt"—shortcuts that make code harder to change later.
Educators recognize a parallel challenge: systems that optimize for test performance without building understanding, feedback loops that reward compliance over competence, metrics that measure seat time instead of learning.
When you design with control of error from the start, these problems don't arise. The system either produces observable improvement or it doesn't. There's no middle ground where it appears to work while actually gaming the metric.
Compitum adopts your standards: We measure evidence of learning, not proxies. We expose uncertainty rather than hiding it. We make decisions observable.
When educators inform system design, everyone benefits from higher standards.
- Audit one unit you teach: Where does feedback come from? (You? Peers? The task itself?)
- Redesign one assessment to be self-correcting
- Notice where students learn fastest—that's where control of error is strongest
- Map your learning objectives to observable student actions
- For each action, specify: What error could they make? How will they know?
- Prototype materials where the error signal is embedded, not externalized
- Read Montessori's The Discovery of the Child (Chapter 8: "The Prepared Environment")
- Read Sutton & Barto's Reinforcement Learning (Chapter 1: "The Reinforcement Learning Problem")
- Notice they're describing the same closed-loop learning system
- Ask: What problems in my domain have this structure?
- Run
python examples/pedagogy_control_of_error.py - Watch evidence increase with practice
- Ask: What would this look like in my teaching context?
We built Compitum because educators have been solving the online learning problem for over a century. Machine learning provides notation that makes these solutions mathematically rigorous and computationally scalable.
Your pedagogical expertise translates directly to system design. You don't need to learn our math to contribute meaningful insights.
Concrete collaborations we'd value:
-
Formative assessment specialists: Help us design better certificate formats. What information do practitioners need? In what order? With what visualizations?
-
Montessori trainers: Review our technical documentation. Where does the pedagogy mapping strengthen? Where might it be extended?
-
Learning scientists: Help us design experiments. How do we measure whether a system genuinely learned versus merely overfit, especially without traditional test sets?
-
Curriculum designers: Prototype "control of error" activities for abstract domains (ethics, system design, architectural planning). What principles generalize beyond concrete manipulables?
This is about recognizing that multiple communities have been working on the same fundamental problem—how do learners improve through interaction with their environment?—and building bridges between our different languages for describing solutions.
Montessori had classroom observation. We have certificate logs. Same feedback loop. Different medium. Equally valuable perspectives.
You might notice we cite both learning scientists and ML researchers without distinguishing "theoretical" pedagogy from "applied" mathematics.
This is intentional.
Montessori's control of error makes falsifiable predictions: If materials contain their own feedback, learning accelerates. If errors are high-stakes, exploration decreases. If progress is invisible, self-regulation suffers.
These predictions can be tested empirically. They have been tested across contexts. They hold consistently.
Rigor means clarity, testability, and accountability to evidence.
Your expertise in designing learning environments is rigorous. Our mathematics formalizes principles you already apply successfully.
Welcome to Compitum. Your field has been pioneering these ideas for generations.
- Montessori, M. (1967). The Discovery of the Child. Ballantine. [Start with Chapter 8]
- Wiliam, D. (2011). Embedded Formative Assessment. Solution Tree Press.
- Hattie, J. (2009). Visible Learning. Routledge. [See synthesis tables]
- Wiggins, G. & McTighe, J. (2005). Understanding by Design. ASCD.
- Sutton, R. & Barto, A. (2018). Reinforcement Learning: An Introduction. MIT Press. [Chapter 1, no math required]
- Bjork, R.A. & Bjork, E.L. (2011). "Making Things Hard on Yourself, But in a Good Way." In Psychology and the Real World. Worth Publishers.
For technical readers: Our Mathematics page provides formal treatment. But everything in this page is testable in classrooms without code.