What Auditing Other Students at Zone01 Taught Me About Why We Still Need Developers in an AI World

I'll say the quiet part first: I've thought about whether I'm learning to code at the worst possible time.

I'm still a beginner. I'm still figuring out Go,React,Js, still getting humbled by git, still googling things I probably should already know. And the whole time I've been learning, AI has gotten better at writing code than me. Not "someday" better. Already better, in a lot of narrow ways. So the question sits there, uninvited, every time I sit down to work: if AI can write this faster than I can, what exactly am I becoming a developer for?

I didn't figure this out by reading a think piece. I figured it out by doing audits.

If you don't know Zone01: audits are peer review, but sharper than that name makes it sound. You sit across from another student, they walk you through their project, and your job is to actually determine whether they understand what they built — not just whether it runs. You ask questions until you know. It's uncomfortable for everyone involved, including the auditor, because you can't fake understanding someone else's code either. You have to actually get it before you can judge whether they get it.

The thing you notice when you're the one asking the questions

When you're the one learning, you don't really see your own process. You're too inside it. But when you're across the table auditing someone else's project, you start noticing exactly where real understanding lives — and exactly where it doesn't.

It's almost never "I don't know the syntax." Syntax is the easy part now — AI will hand you syntax all day. It's things like:

• Not knowing why the code in front of them actually solves the problem
• Not being able to tell me when a specific function would break
• Not having a mental model to fall back on when I push past the happy path

I've sat across from students who could walk me through their code line by line, confidently, and then completely stall the moment I asked "okay, what happens if I pass this an empty array" or "why did you choose this approach over the obvious alternative." They could operate the code. They couldn't reason about it. And an audit is specifically designed to find that gap, because reasoning about it is the part that matters once things get messy — which they always do.

The lexer moment

I got a small version of this myself, on the other side of the table, working through Writing an Interpreter in Go. I hit the lexer's position / readPosition / ch relationship and just... stalled. It's not complicated code. I could have asked an AI to explain it in ten seconds and walked into my next audit sounding like I understood it.

But I knew what an audit does to that kind of understanding. It finds the seams. So instead I sat with it uncomfortably long, drawing out what each pointer was doing on paper like it was 2005. And when I finally got it, I didn't just get that piece of code — I got a way of thinking about state that I've used since, in places that had nothing to do with lexers.

That's the difference between being told an answer and building the internal model that lets you defend it under questioning. AI is extremely good at the first one. It cannot do the second one for you. You have to actually sit in the confusion — because eventually, someone across a table is going to ask you why.

So what are we actually still needed for

Here's what auditing made obvious to me: AI doesn't replace developers. It replaces the output of a certain kind of developer — the one who was mostly translating requirements into syntax. That was always going to be automatable eventually, AI or not.

What it doesn't replace is the part where someone has to:

• Decide if the AI's answer is actually right, not just plausible-looking
• Know what question to even ask it
• Catch the bug that only shows up because you understand what the system is supposed to do
• Sit across from someone — an auditor, a teammate, a client — and defend why the code works, not just that it does

Every student I've audited who's doing well isn't the one avoiding AI. They're the one using it and still able to answer "why" when I push. That's the actual skill now. It was arguably always the actual skill — audits just made it impossible to fake, and AI made it tempting to try.

The uncomfortable part I still sit with

I won't pretend this fully kills the anxiety. I still wonder, some days, if I'm optimizing for a version of "developer" that's shrinking. But sitting on both sides of an audit gave me a better question to ask than "will I be replaced." It's: would my understanding survive someone asking me "why" three times in a row?

Watching other students freeze at that third "why" — and watching myself freeze at it too, some days — convinced me that question has a real answer, and it's mine to build toward. Not something AI decides for me.

If you're a beginner developer feeling the same thing I felt: keep sitting in the confusion a little longer than feels comfortable, even when AI could hand you the answer in ten seconds. That's not you being slow. That's the part of the job that's still yours — and it's the part every audit is going to test.

you fav developer-Pretty sure I'm still needed. Also pretty sure I still need to fix that lexer bug