Computational thinking: what it actually means, and why brick builds teach it better than most coding apps
Schools talk about computational thinking as if it requires a screen. It doesn't. The four pillars — decomposition, pattern recognition, abstraction, algorithms — are all present in a complex LEGO build.
"Computational thinking" has become an education buzzword, which means most parents have heard it without ever getting a clear explanation of what it actually means.
Here is that explanation — and why the LEGO Technic build on your child's desk is already teaching all four of its components.
The four pillars
Computational thinking was formalised as a concept by computer scientist Jeannette Wing in a 2006 paper that argued it should be considered a fundamental literacy alongside reading and arithmetic. She described four core components:
1. Decomposition — Breaking a complex problem into smaller, manageable parts.
2. Pattern recognition — Identifying similarities, trends, or regularities within and across problems.
3. Abstraction — Focusing on the essential features of a problem, ignoring irrelevant details.
4. Algorithms — Developing a step-by-step solution that can be followed consistently.
These four skills are not native to computing. They predate it by centuries. What computing did was make them visible — because a program that doesn't decompose, recognise patterns, abstract, and execute an algorithm simply doesn't run.
How brick builds engage each pillar
Decomposition in a complex build:
A child attempting to build a working crane from Technic doesn't start with "build a crane." They (often intuitively) break it into sub-problems: the base structure, the arm, the lifting mechanism, the gear system that controls the lift. This is decomposition — and it's the same operation a software engineer performs when they break a feature into functions and a function into lines.
Pattern recognition in structural design:
A child who has built several load-bearing structures begins to notice that certain brick arrangements appear repeatedly — staggered joints, corner reinforcements, central support columns. They start reusing these patterns without being taught to. This is the accumulation of a pattern library, which is exactly what experienced programmers use when they recognise that a new problem resembles one they've solved before.
Abstraction in planning:
Before placing any bricks, a child planning a complex build holds a mental model of the structure — an abstraction that contains the essential features (height, stability, function) without every specific detail. They're not thinking about which specific stud in row four goes first. They're thinking about the structure. This selective attention to what matters at a given level of detail is the definition of abstraction.
Algorithms in assembly:
Any reproducible build is an algorithm: a sequence of steps that, followed in order, produces a consistent result. A child who can teach another child to build something they invented has produced an algorithm. If they've ever said "no, you have to do the base first or it falls apart" — they've discovered a dependency constraint, which is a fundamental concept in both algorithms and software architecture.
Why screens often teach this less effectively
Most coding apps for children (Scratch, code.org block-based environments) present computational thinking concepts in a context that is already simplified and scaffolded. The problem is pre-defined, the tools are constrained, and the feedback is immediate and binary (does it work or not).
Physical builds present open-ended constraint problems where the child must define the problem, choose the tools, and interpret ambiguous feedback. A structure that's "almost stable" requires more nuanced analysis than a program that either runs or crashes.
This is not an argument against coding tools — they're valuable. It's an argument that physical construction and computational thinking are more connected than most curricula acknowledge.
What to say during a complex build
- "What's the first thing that needs to be solved?" — Invites decomposition
- "Have you built something like this before?" — Invites pattern recognition
- "What's the most important thing for this build to do?" — Invites abstraction
- "If you were going to write instructions so someone else could build this, what would step one be?" — Invites algorithmic thinking
The next time your child is forty-five minutes into a build and you're wondering whether this is "educational" — it is. It is, structurally, what computer science education is trying to replicate. The screen isn't what makes it computational. The thinking is.