Where Did All the Code Playgrounds Go?

Where Did All the Code Playgrounds Go?

Tópico: Where Did All the Code Playgrounds Go?
Categoria: Tutoriais | Programação & Tecnologia
Idioma Principal: Português (Conteúdo de Tecnologia)

Descrição do Conteúdo / Informações:
-------------------------------------------------------------------------
I wanted to get better at technical interviews. That's really where this story starts.

A Course, Two Platforms, and a Problem

A couple of years ago I was taking Master the Coding Interview on Udemy — a course from ZTM (Zero to Mastery). It covers the fundamentals well: what algorithms actually are, what data structures do, and the relationship between time and memory that underlies almost every engineering decision you'll ever make. Many people criticize it. I thought it was good.

The instructor taught everything using Replit. All the examples, all the live coding — it happened right there in the browser. And Replit, at the time, was genuinely impressive. It felt like having a small VM at your fingertips. You could write code, run it, even get a terminal. Visually it was clean, comfortable to write in. I liked it.

But at the start of the course, the instructor mentioned something: if you want to follow along without paying for Replit, try Glot.io. So I did.

Glot wasn't as pretty. But it was free, it ran code in dozens of languages without any friction, and it didn't try to be anything other than what it was. I ended up doing most of my exercises there — pasting examples from the course, tweaking them, breaking them on purpose, understanding why. It worked exactly as a playground should.

Coming Back to a Different Landscape

A few years passed. I wanted to revisit those fundamentals — preparing for a certification, sharpening things up for interviews. So I went looking for the same tools.

I tried Replit first. I remembered how nice it looked, and I thought maybe things had improved. They had changed, just not in the direction I hoped. The moment I opened it, it was a chat interface. An AI coding assistant. I asked another AI what had happened to Replit — and it explained the pivot, then recommended PlayCode.io as an alternative.

PlayCode.io was also a chatbot.

I wasn't looking for an agent to write my code for me. I was trying to practice thinking. Those are very different things.

So I went back to Glot.io. Still alive, still free — and I still have exercises saved there. But the language runtimes hadn't been updated in years. If you wanted to test something from a recent version of Python or any actively evolving language, Glot just wasn't there anymore. Understandable: keeping free execution infrastructure running without any revenue model is genuinely hard to sustain. Glot did it for a long time and deserves credit for that. But it couldn't give me what I needed.

Why They All Became AI Agents (And Why It Makes Sense)

Here's the thing: the playgrounds that pivoted to AI didn't do it randomly. There was a logic to it.

These platforms already had the hard part built — the infrastructure to securely execute code in the cloud, at scale, across dozens of languages. That's genuinely difficult to build. And while they were building it, they were also accumulating something else: enormous amounts of code written by their users.

At the same time, the market was sending a clear signal. Most people don't want to learn how to code. They want an app. There's always been an invisible wall between technical people and everyone else — the DNS configurations, the deployment pipelines, the difference between a prototype and something real users can actually open. That wall is real, and it kept a lot of good ideas from ever becoming products.

So when AI arrived and made it possible to say "build me a todo app" and get something running, the playgrounds saw the obvious move: take the infrastructure you already have, add an AI layer on top, and sell directly to the massive market of people who just want their idea to exist.

That's not cynical. That's rational. Companies exist to solve problems, and the problem they chose to solve shifted from "I want to run code" to "I want software without writing code." The business case was clear.

The gap it left behind was apparently small enough that nobody rushed to fill it. But I don't think that gap is trivial. A place to think in code — to wrestle with a problem yourself, make mistakes, and understand why something works — is not the same thing as a place to ask an AI to solve it for you. Both have their uses. But only one builds the mental model.

A Gap Worth Filling

Here's the thing nobody talks about: the industry changed, but the hiring process largely didn't. Technical interviews still happen. Certifications still matter. Companies still expect you to reason through a problem on a whiteboard — or at least demonstrate that you can. The AI is in everyone's editor now, yes, but the bar to get through the door hasn't moved as much as people think.

And honestly? I think there's a reason for that. The people who get replaced by AI are the ones who let it think for them. The ones who don't are the ones who used it to go further. That gap comes down to understanding — and understanding comes from writing code, solving problems, and occasionally making things difficult for yourself on purpose.

That's why I wanted multiple languages in the mix. Learning a new programming language is its own kind of mental exercise — it forces you to see familiar problems differently. And esoteric languages take it further: if you can write something meaningful in Brainfuck, where you're managing memory one byte at a time, things like pointers and stack allocation in C start to feel less abstract. It's like solving a harder puzzle so the normal ones feel easier. Same idea behind supporting custom interpreters — building a language, even a tiny one, changes how you see all languages.

That's babelpad.dev. Multiple languages, including the weird ones. No account, no agent, no friction. Just code and output.

The Skill Underneath

There's something more personal behind all this, though. And it goes deeper than hiring pipelines.

When I used to tutor students, I'd sit them down with a set of problems and ask them to think out loud. Not to test what they memorized, but to watch how they think. That's the only way to see where someone's mental model breaks down and how to actually help them.

Algorithms and data structures do the same thing for software development. They train you to see patterns, recognize complexity, and reason about tradeoffs before you've written a single line. That's exactly what you need when you're reviewing code an AI wrote — and when you're deciding whether the architecture your agent just proposed is going to become a maintenance nightmare in two years.

You don't need to hand-code a red-black tree in production. But if you've never wrestled with one, you're going to have a harder time knowing when to reach for the right tool — or when to push back on the wrong one.

The tools changed. The underlying skill didn't.

That's why I built babelpad.dev. Not because I thought I could out-feature Replit or replace Glot. Just because I needed a simple place to run code and think — and I figured maybe someone else did too.

If you want to try it: babelpad.dev

Coming up: the technical stack behind Babelpad (Svelte + Cloudflare + Piston), esoteric languages and why I added support for building your own interpreter, and how I'm using Babelpad to teach programming.