Pediatric milestone charts cover rolling over, first words, and pedaling a tricycle. None of them cover the skill set that arguably matters most for the world these kids will inherit: computational thinking — sequencing, pattern recognition, conditional logic, decomposition, debugging.
This page is that missing chart. It lines up what developmental science tells us to expect against what these skills actually look like in ordinary play, age band by age band. It draws on Jeannette Wing’s framing of computational thinking as a universal skill, Marina Umaschi Bers’s decade-plus of research on computational thinking in early childhood, and a great deal of direct testing of every activity on a real child (sometimes mine).
One thing before the chart: kids are not firmware updates. They don’t install features on a schedule. A child who does some of these early and others late is a child developing normally. Use this to recognize what you’re seeing, not to grade it.
Ages 1–2: Cause and effect, first sequences
What’s developing: object permanence, intentional experimentation, proto-sequencing. The child is essentially booting the operating system, running constant input/output tests on the physical world.
What to look for
- Deliberately repeating actions to confirm a result (drop the spoon; drop it again; yes, it still falls)
- Pressing buttons, flipping switches, opening and closing things — input/output exploration
- Anticipating the next step of a familiar routine (heading for the high chair when lunch starts)
- First “again!” requests — the seed of loop thinking
What to do
- Narrate sequences out loud: “First socks, THEN shoes.”
- Provide safe cause-and-effect machines: stacking cups, pop-up toys, light switches they’re allowed to flip
- Keep routines consistent — predictable structure is what early sequencing is built on
Don’t worry if: they have no interest in sorting or patterns yet. That’s the next band’s work.
Ages 2–3: Sorting, patterns, if-then negotiation
What’s developing: classification, two-element patterns, conditional language, early debugging instincts.
What to look for
- Spontaneous sorting — cars by color, snacks into piles, “these go together”
- Completing simple patterns (big block, small block, big block, ___)
- If-then bargaining: “If I eat my meatball, then I can have blueberries?” — a conditional statement, used fluently
- Finding loopholes in your rules (rejecting the premise of “no dessert without dinner” by demanding a dessert snack). Loophole-hunting is how they test the edge cases.
- Noticing when something’s wrong, even if they can’t yet fix it
What to do
- Name the thinking casually: “You made a pattern!” “You sorted those!”
- Play one-rule sorting games with laundry, toys, trail mix
- Honor the if-then negotiations as logic practice (you can still say no)
- First directed building: with you typing, a child this age can tell an AI tool what game to make and react to the result. Direction is the skill, not syntax. (The exact session structure, with prompts, is in 12 Weeks of Tech Projects for Toddlers .)
Don’t worry if: patterns longer than two elements fall apart, or sorting rules are idiosyncratic (“these are the fast ones”). Inventing categories is more advanced than applying yours.
Use milestones to recognize what your child is practicing. They’re a lens, not a scoreboard.
Ages 3–4: Multi-step sequences, rules, deliberate debugging
What’s developing: three-plus step planning, rule creation, AND/OR conditions, cause-effect prediction, persistence through fixing.
What to look for
- Narrating plans before acting: “First I need the paper, then the crayons, then I can draw”
- Catching out-of-order steps and correcting them — including yours
- Multi-condition logic: “If I brush teeth AND pick up toys, then two stories?”
- Predicting outcomes before testing: “If I push this, it’s gonna fall”
- The shift from “it’s broken” (frustration) to “why is it broken?” (investigation)
- Building things that evolve mid-construction — a ramp becomes a driveway becomes a race course. That improvised, iterative style is a legitimate way to build , not a failure to plan.
What to do
- Scramble routine cards and let them debug the sequence
- Play conditional games: red light/green light with added rules and parameters
- Let towers fall and ask “what happened?” before offering fixes
- Weekly build sessions: child describes a game, parent types it into an AI tool, child evaluates and directs changes. The iteration is the lesson.
Don’t worry if: attention spans for any single activity are short. Interest-led beats curriculum-led at this age.
Ages 4–5: Decomposition, abstraction, variables
What’s developing: breaking big tasks into parts independently, telling essential from decorative, tracking changing quantities.
What to look for
- Tackling big tasks by starting with one part, unprompted
- Describing things by key features (“the big red one”) — abstraction in speech
- Drawing at deliberate levels of detail; knowing a circle with ears still “counts” as a cat
- Tracking scores and quantities: “I have 3 — if I get one more, I’ll have 4”
- Teaching a younger sibling or stuffed animal a routine by name
What to do
- Decompose together out loud: “What are ALL the pieces of this?”
- Play “what’s the simplest drawing that’s still a ___?”
- Keep visible score variables in any game you play
- Let them set the parameters: how many stirs, how many eggs, how fast
Ages 5–6: Composition, functions, original design
What’s developing: combining concepts fluidly, naming reusable procedures, designing systems from scratch.
What to look for
- Named routines they invent and expect others to know (“let’s do the cleanup dance!”) — effectively a function definition
- Chaining concepts: a game idea with a goal (condition), repetition (loop), and a score (variable)
- Designing original projects and directing their execution end to end
- Explaining concepts in their own words to other people
What to do
- Capstone projects: their idea, decomposed together, built with their direction, shown to family. Publishing — even just to grandparents — closes the loop between idea and reality.
- Start handing over more of the literal controls (typing, choosing) as reading emerges
How to use this chart
Read your child’s current band and the one after it. Do the “what to do” items for the current band; watch for the “what to look for” items in the next. If a concept isn’t landing, drop back to the physical version and wait — concrete before abstract, always (screen-free versions of every concept live here ).
Frequently asked questions
What age should I start watching for computational thinking milestones? You can start noticing the foundations around ages 1–2: cause and effect, repeated actions, anticipation of routines, and early sequencing language.
Should I worry if my child is late on one skill? No. Children don’t develop these on a strict schedule. Use the milestones to spot opportunities for play, not to grade your child.
What skills matter most for ages 2–4? For ages 2–4, the most visible ones are sorting, simple patterns, if-then language, multi-step sequences, and early debugging through play.
Do these milestones require screens or coding apps? No. Most of them show up through physical play: sorting toys, stacking blocks, following routines, negotiating rules, and fixing things that break.