We Found a Bug in Arvoe. My 11-Year-Old Fixed It.

We found a bug in Arvoe.

Not a critical one. The kind that sits quietly on the backlog for weeks because there are always bigger things to ship. Something looked wrong on the Controls page, and every time I saw it, I thought: I'll get to that at some point.

My 11-year-old son Sebastian got to it first.

If you read Why We Built Arvoe, you'll know I mentioned teaching Seb to think alongside AI as part of the reason we ended up building for education. This is that story in full.

The Upgrade app

Before I get to the bug, I need to go back a bit.

Last year, Lovable ran a competition. 72 hours of free credits and a simple brief: build something. The timing landed in school holidays, so I saw an opportunity. Seb had been curious about what I was working on, so I sat him down and set him a challenge: let's build something together.

The idea came from a game we play in the car. It's called Upgrade. You spot a nice car on the road, you call out "upgrade," and you claim it as yours. The person with the best car at the end of the trip wins. Gold Coast is good territory for this. Supercars are an instant win.

We decided to build an app that codified the game. I set Seb up with Claude as his guide and Lovable as his build tool. He was off.

He built a working prototype. It wasn't perfect, but it worked. Time moved on and the Upgrade app got shelved.

What I didn't realise at the time was that the experience had planted something.

A different kind of lesson

A few months ago, Seb started asking lots of questions about Arvoe. Not "what does it do" but "how does it work." He'd been watching me build for long enough that he was curious about the underneath.

So I decided to show him.

Not through a toy project. Not through a simplified version. I pulled out a notebook, found a blank page, and drew him the real thing.

I drew it as I explained it. A front end, a database, the AI models we connect to, the source control that holds it all together. And at the bottom, the things the app actually does: manage People, Risks, and Controls for schools.

He got it faster than I expected.

Then I drew the SDLC.

Development. Changes. Test. Push. Production. With Claude Code at the foundation, Linear tracking the work, and Notion holding the knowledge. He asked good questions throughout. And somewhere in the middle of all of it, I drew him one more thing.

A simple chart. Stuff around on the x-axis. Find out on the y-axis. A rising curve with X marks scattered along it, each one an attempt, some that worked and some that didn't, but every one of them moving you further up the curve. You don't start at the top. You earn your way up.

You may have heard this principle by another name. We called it "stuff around and find out," and it's less a rule than a posture — the willingness to explore before you know the answer.

He laughed when I drew it. Then he understood. That framing became the thread running through the rest of the afternoon.

The bug

I showed Seb the issue on the Controls page. When you increased the number of rows visible in the table, the layout broke. Two scrollbars appeared side by side, fighting for space. It looked wrong. Every other module sat cleanly inside the viewport. This one didn't.

I walked him through the process we use at Arvoe when something needs fixing: investigate first, understand the root cause before you touch any code, make the change on a dev branch, test it, push it through to production.

He followed the steps. We've built a pretty solid workflow that makes it easy to implement, but more on that another time.

He compared the broken page against the working ones. Asked good questions with Claude's help. Worked out what was structurally different. The fix was small and surgical, and it made the whole thing sit neatly inside one scrollable region, exactly like the other modules.

He made the changes on a dev branch. Tested it. Pushed it through to main. On 21 March 2026, the fix went to production.

The Controls page has sat cleanly in the viewport ever since.

What he said afterwards

He told me he got more out of that session than he did building the Upgrade app.

I asked him why. He thought about it for a second.

"Because it was real."

That was the word he used. Real. Not a toy. Not a demo. A real product that real schools are using. A real bug that had been annoying me for weeks. A real fix that went into production.

And then he said something I wasn't expecting.

He said he wants to grow up and be CEO of Arvoe one day. And he's happy to start at the beginning and work his way up.

Looks like we've found our next junior dev.

What the beginning even looks like

I've been thinking about that since.

When Seb is 18, what does the beginning of a career in tech look like? Honestly, I can't tell you. The tools will be different. The workflows will be different. Some of the roles that exist today may not exist. New ones most likely will.

But here's what I think will still matter: knowing how things work, being willing to try things until you figure it out, and being able to use whatever tools are in front of you to get to an outcome. That's not a CV skill. It's a posture, a way of approaching problems that no job description will ever quite capture.

Vibe coding with Lovable was fun. Seb enjoyed it. But it didn't stick the way this did. I think the reason is simple: there was nothing at stake. A fun car-game app that never got finished doesn't have the same weight as a real bug in a real product that means something to someone you love. The stakes made it real, the process gave it structure, and the outcome gave him confidence.

What schools should be teaching

I think about this a lot. We're a company building AI governance tools for schools, and one of the questions I keep coming back to is: what does it actually mean to prepare kids for an AI-enabled world?

The conversation usually goes to policy — acceptable use, preventing cheating, guardrails.

Those things matter. Genuinely. It's part of why we built Arvoe. Getting the guardrails right is the foundation, not an afterthought. We've written about what that looks like in practice in What Mature AI Governance Actually Looks Like, and about why the national framework leaves schools without a roadmap.

But the other side of the conversation, the one I think gets missed, is about what it looks like to actually embrace AI. Not watch it from a distance. Not ban it and hope for the best. Actually give kids the tools, show them how to use them safely and with proper guardrails in place, and let them build confidence through real experience.

Seb didn't learn how to code that afternoon. He learned how to think like a builder — what a stack looks like, how bugs have root causes you can trace if you follow the process, why AI is a collaborator and not a magic button. He learned that the process is what produces the outcome. That's the shift I want schools to be building toward: not AI literacy as a subject, but AI confidence as a habit.

The "stuff around and find out" curve applies here too. You don't learn it by reading about it. You earn your way up with X marks.

The Upgrade app might get another look

Seb mentioned it the other day. "Maybe we should go back to the Upgrade app."

I think we will. But this time it'll be different, because he brings something to it he didn't have before: he knows what a stack looks like and how it hangs together, he knows what the SDLC is and how to ship something from idea to reality, and he understands the process end to end.

He'll probably build something better than I would.

Ryan Speak is co-founder and CTPO of Arvoe, an AI governance platform built for Australian K-12 schools. He's also the dad of four kids who are all figuring out this AI thing in real time.