What comes after Scratch?

In brief

• Scratch gives kids a fantastic start. But the leap from blocks to typed code is a big one, and the blank screen and blinking cursor are where many young coders lose momentum.
• AI makes this more important, not less. Kids who can read, understand, fix and improve code grow up confident shaping technology, not just using it, however good AI gets.

• Research points to a useful bridge: start with existing code, fix before writing, and give kids a reason to care about what they're building. That's how we built Erase All Kittens.

Credit where it's due: Scratch is brilliant

If you've ever run a Scratch club, you know the moment. A student has built a platformer, a quiz, maybe a game where a dragon chases a taco across the screen forever. They're proud, they're hooked, and then they ask: "What's next?"

It's a great problem to have. But it's still a problem. The honest answer is "real code", and the first thing real code usually shows a child is a blank editor and a blinking cursor. That's the point where a lot of kids who loved Scratch quietly stop.

The blocks are genuinely clever. They take syntax off the table, so children can focus on how code thinks: sequences, loops, conditions, events and variables. Most importantly, they show kids, early and joyfully, that they can make things. That was the idea from the start: Scratch's creators wanted kids to move from simply using digital media to creating with it (Resnick et al., 2009).

So this isn't a "Scratch vs" post. Scratch does its job beautifully. This is about what happens next, when a child is ready to swap the blocks for the languages that actually run the web.

The gap: from snapping blocks to a blinking cursor.

The jump from blocks to typed code is bigger than it looks from the teacher's side of the desk. With blocks, kids can't make a typo, because every command is already written out for them. And like jigsaw pieces, blocks are shaped so they only fit where they belong. Typed code offers none of those safety nets. Suddenly a single missing character can stop everything.

Researchers have been studying this transition for years, and a few things stand out:

Scratch builds real foundations. Researchers at the Weizmann Institute followed students from Scratch in middle school into text-based programming in high school. The Scratch group did better on some concepts, such as loops, and reported higher self-efficacy and motivation (Armoni, Meerbaum-Salant & Ben-Ari, 2015).

But the gains don't carry over automatically. In a controlled classroom study, David Weintrop and Uri Wilensky found students learning with blocks made bigger gains early on than peers using text. After ten weeks of Java, that advantage had faded, and the blocks group's confidence and interest in further computing courses had dropped (Weintrop & Wilensky, 2019).

And the friction is very real. Computing education researchers Michael Kölling, Neil Brown and Amjad Altadmri catalogued 13 distinct problems in the blocks-to-text transition, from memorising syntax to typing commands character by character (Kölling, Brown & Altadmri, 2015).

Weintrop and Wilensky's conclusion is worth pinning above every curriculum lead's desk: what kids learn with blocks does "not automatically transfer" to text, so educators and tool designers need to actively support the move. They also point to an expert blind spot. Experienced coders can see that a block and a line of code mean the same thing. Learners often can't.

Those studies were with older students, but anyone who has watched a 9-year-old look at real code for the first time will recognise the problem. They may understand the concepts, but that doesn't mean they feel confident when they first see typed code. And when that first experience is a blank screen, there's nothing to hold on to.

Why it matters more now: AI writes the code, but kids still need to understand it

AI can now write code in seconds, and it's getting better fast. That doesn't make learning to code pointless. It changes what learning to code is for.

And the case for understanding code doesn't depend on AI making mistakes. Code that works isn't necessarily code that's right. Someone still has to decide what's worth building, understand what the code is actually doing, and judge whether it does what they meant.

Professional developers already feel this. Among those surveyed by Stack Overflow who'd experienced frustrations with AI, one in five said it had made them less confident in their own problem-solving. And when asked to imagine a future where AI could do most coding tasks, 61% said they'd still turn to a person when they wanted to truly understand something (Stack Overflow, 2026).

If that's how professional developers feel, imagine a 10-year-old who's only ever been handed the answer.

So the most important outcome of learning to code isn't typing from memory. It's understanding, and the confidence that comes with it. So perhaps the most important outcome of learning to code isn't being able to type everything from memory. It's understanding what's going on, and having the confidence to change it.

A child who can read code, work out what it's doing, fix it and improve it sees technology differently. Apps, websites and AI tools stop being magic boxes. They're things people made - and things they can change.

That's the mission Scratch started: kids as creators rather than just consumers. Real code carries that idea into the technology they use every day, AI included.

It also gives kids the confidence to look at something a machine produced and ask: "Is this actually what I wanted?"

And that confidence is built the way it always has been: by getting stuck, figuring something out and watching it finally work. Kids who are only ever handed finished answers by AI miss out on that.

(We explore this in more depth in Should Kids Still Learn to Code in the Age of AI?)

Why we built Erase All Kittens

This is the gap we built Erase All Kittens to close. We've spent more than ten years working on it, starting long before today's AI tools existed, because we kept seeing kids struggle to get from blocks to real code.

There are some good tools designed to help with this jump. Ours is a story-driven coding game for 7 to 12 year olds, exactly the age when many young Scratchers start asking "what's next?" Kids learn real HTML, CSS and JavaScript, the languages that build the web, by fixing and building the code behind the game world.

The story is deliberately quirky and absurd. The cute, fluffy animals of the Internet are fed up with kittens stealing all the views, so they've formed an evil army to erase them. Kids play as Arca, a tiny hero who uses coding powers to save the kittens (and all the other creatures of the Internet Universe, which is, naturally, made up mostly of kittens).

Along the way they meet characters like Tarquin Glitterquiff, a serial-entrepreneur unicorn mermaid, and a banana bird with questionable toilet habits.

There's a reason we built the game this way. Three things in particular help make that move to real code easier.

Start with existing code, not a blank page. Educational psychologist Jeroen van Merriënboer found that beginners who completed and modified existing programs picked up programming patterns better than those who wrote programs from scratch, partly because you can't finish someone else's code without studying it closely (van Merriënboer & de Croock, 1992). In Erase All Kittens, kids spend much of their time working with code that's already there - fixing and extending it rather than staring at an empty editor.

Read and fix before you write. The PRIMM approach (Predict, Run, Investigate, Modify, Make), trialled with around 500 students aged 11 to 14, builds on research showing that explaining existing code gives beginners the confidence to write their own (Sentance, Waite & Kallia, 2019). Many EAK levels work in a similar way. Kids open up the code, work out what's wrong and change it. Later, they extend it and build their own.

Give the code a reason to exist. When Caitlin Kelleher at Carnegie Mellon added storytelling to the Alice programming tool, middle school girls learned the same concepts but spent 42% more time programming, and were more than three times as likely to sneak in extra time (Kelleher, Pausch & Kiesler, 2007).

In EAK, every fix gets you somewhere. Paths open, platforms appear and kittens get rescued, with jokes, characters and collectable kitten cards along the way.

A few practical things matter in a classroom, too. Because the code is the world, changes show up straight away on screen. Because it's real HTML, CSS and JavaScript, kids are working with languages they can keep using. And the built-in tutorial and hints mean teachers don't need to be coding experts to run it.

Built for understanding, not just answers

A lot of EAK levels start with a world that doesn't quite work yet - a ledge that's too short, a door that won't open, a platform in the wrong place. Kids read the code, work out what's going on, change it and see what happens.

That's the important bit.

They aren't just typing an answer they've been given. They're reading, reasoning, trying things and checking the result.

It's what professional developers do every day. Our players just happen to be saving kittens at the same time.

It changes how kids feel about mistakes, too. Broken code isn't a sign they've failed. It's the puzzle. And fixing it changes something right there on the screen.

Six ways to help kids make the leap

You don't have to choose between Scratch and real code. The important thing is to build a bridge between them, whether you're a teacher, a parent or running a code club.

1. Look for the signs. They're confident with loops and variables in Scratch, building bigger projects and asking how "real" games and websites are made.

2. Show them the connection. The ideas they already know from blocks are about to turn up as typed code. Point those connections out as they appear.

3. Fix before you write. Let their first experience of real code involve reading and changing something that already exists, rather than facing a blank page.

4. Ask "What do you think will happen?" before a change. It turns trial and error into reasoning.

5. Celebrate bugs. Finding out why something doesn't work is part of programming, not evidence that you're bad at it.

6. Use AI to deepen understanding, not replace it. Once they're confident, encourage them to ask AI to explain code, as well as generate it.

The next step after Scratch

Erase All Kittens has been played by 350,000 kids in more than 100 countries, is used in over 5,000 schools worldwide, and has won eight awards, including two from MIT. Half of our players are girls, and 95% of kids want to keep learning to code after playing.

Teachers put it better than we can:

"Each time students are introduced to Erase All Kittens, the excitement and engagement is unreal." Tasneem Patel, Head of Computing

"I am bursting to share that Erase All Kittens is having an incredible effect on my pupils, far beyond anything I ever imagined." Drew Buddie, Head of Computing

Scratch shows kids they can build things with code. The next challenge is showing them that real code is something they can understand too.

That's where we think Erase All Kittens fits.

And as AI writes more of the world's code, understanding what's going on underneath becomes more useful, not less.

Try it: play the free demo or get a quote for your school.

Know a teacher, parent or club leader with a Scratch fan who's ready for the next step? Send them this post. There are kittens depending on it!

References

1. Armoni, M., Meerbaum-Salant, O., & Ben-Ari, M. (2015). From Scratch to "real" programming. ACM Transactions on Computing Education, 14(4), 25:1–15. Project summary

2. Kelleher, C., Pausch, R., & Kiesler, S. (2007). Storytelling Alice motivates middle school girls to learn computer programming. Proceedings of CHI 2007. Paper (PDF) · Summary

3. Kölling, M., Brown, N. C. C., & Altadmri, A. (2015). Frame-based editing: Easing the transition from blocks to text-based programming. Proceedings of WiPSCE '15, 29–38. doi.org/10.1145/2818314.2818331

4. Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., et al. (2009). Scratch: Programming for all. Communications of the ACM, 52(11), 60–67. Paper (PDF)

5. Scratch Foundation (2026). Impact. scratchfoundation.org/impact

6. Sentance, S., Waite, J., & Kallia, M. (2019). Teachers' experiences of using PRIMM to teach programming in school. Proceedings of SIGCSE '19. Abstract · PRIMM overview

7. Stack Overflow (2026, 30 September). Getting ready for 2026 results: A look back on Developer Survey findings. Stack Overflow Blog

8. van Merriënboer, J. J. G., & de Croock, M. B. M. (1992). Strategies for computer-based programming instruction: Program completion vs. program generation. Journal of Educational Computing Research. Abstract

9. Weintrop, D., & Wilensky, U. (2017). Comparing block-based and text-based programming in high school computer science classrooms. ACM Transactions on Computing Education, 18(1). Paper (PDF)

10. Weintrop, D., & Wilensky, U. (2019). Transitioning from introductory block-based and text-based environments to professional programming languages in high school computer science classrooms. Computers & Education, 142, 103646. Paper (PDF)