Congratulations, You've Been Promoted to Code Janitor

A meditation on what we traded for velocity

It was 2001. I was building a platformer.

---

Hey, I’m Lakshmi — I help developers build, deploy, and distribute their SaaS without hiring a team. I also run Stacksweller and Supabyoi.

New here? Start with Why Your AI Wakes Up Every Morning With No Memory or Clean Code Is Dead.

---

Not “building” in the modern sense, where you describe what you want and a language model hallucinates it into existence. I mean building. DJGPP. Allegro. A DOS compiler that ran on Windows 98 and made you feel like a wizard for getting it to work at all.

I spent three weeks figuring out how platform scrolling worked.

Three weeks. Not because I was stupid — though jury’s still out — but because nobody had written a Medium article explaining it. Stack Overflow didn’t exist. The Allegro documentation was a text file that assumed you already knew what a framebuffer was. I had to think.

And then one night, around 2am, I got it working.

My little sprite — a 16x16 pixel abomination that was supposed to be a knight but looked more like a confused rectangle — walked across the screen. I pressed the arrow keys and the platform scrolled. The background moved. The character stayed centred.

I decided, right then, that I wanted to be a game programmer.

(I didn’t become a game programmer. Life had other plans. But that’s not the point.)

The point is: I remember that moment with perfect clarity. The dopamine hit. The sense of creation. I had figured something out. I had made something move. I understood, down to the register level, why it worked.

I couldn’t tell you the last time I felt that.

The Joy We Traded

There’s a thread on r/ClaudeAI that’s been haunting me. 624 upvotes. Title: “We are not developers anymore, we are reviewers.”

The author nails it:

“Coding used to be a creative act. You enter a ‘flow state,’ solving micro-problems and building something from nothing. Now, the workflow is: Prompt → Generate → Read Code → Fix Code. We have effectively turned the job into an endless Code Review session.”

And then the kicker:

“Let’s be honest, code review has always been the most tedious part of the job.”

Yeah. That landed.

I used to joke that the worst part of being a senior engineer was reviewing other people’s code. All the cognitive load of understanding a system, none of the satisfaction of building it. You’re not creating — you’re auditing. You’re the IRS of software development.

Congratulations. That’s your whole job now.

The Janitor Effect

One commenter called it the “reverse centaur.”

The dream was that AI would be the centaur’s horse — we’d ride it, directing its power, multiplying our capabilities. We’d be the brains, it’d be the muscle.

Instead, we’re the cleanup crew.

Claude writes 400 lines of code in 30 seconds. Impressive. Looks right. Probably compiles. But there’s a subtle bug on line 247 where it’s comparing a string to an integer in a way that JavaScript will happily accept and silently mangle. There’s a race condition in the async handler that only manifests under load. There’s a variable named data that shadows another variable named data three scopes up.

You know. Junior developer stuff.

Except this junior developer types at 10,000 words per minute and never gets tired. So now you’re reviewing 10x more code per day, and every review requires you to maintain the mental context of code you didn’t write.

I spent 20 years building mental maps of codebases. Line by line. Function by function. When you write the code yourself, the map builds automatically. You know why that flag exists because you added it at 3am to fix a production incident. You know that module is haunted because you were there when the haunting began.

When Claude writes the code, you get none of that. You just get the artifact. A fully-formed thing that appeared, Athena-like, from the forehead of a language model. And you have to reverse-engineer the intent from the implementation.

This is debugging someone else’s code.

Forever.

The Uncomfortable Truth

Here’s what nobody wants to say out loud: the implementation was the fun part.

Not the architecture. Architecture is meetings. Architecture is diagrams that nobody reads and Jira tickets that nobody updates. Architecture is important, yes, but it’s not fun.

The fun was the 2am breakthrough. The fun was that moment when the tests finally pass and you understand why. The fun was the flow state — that hypnotic trance where hours feel like minutes and you emerge, blinking, having built something that didn’t exist before.

LLMs took that part.

They left us the meetings.

The “Promoted to Manager” Cope

There’s a certain cope that shows up in these discussions. “Well, actually, you’ve been promoted! Now you’re like a tech lead! You’re directing instead of doing!”

Sure. And my 2001 self was “promoted” from game programmer to accountant the moment Excel learned formulas.

Here’s the thing about being promoted: you’re supposed to want it. The tech leads I know who love their jobs? They love mentoring. They love the big-picture thinking. They love watching junior devs grow.

Nobody loves reviewing AI-generated code. The AI doesn’t grow. It doesn’t learn from your feedback. It just generates more code for you to review tomorrow. You’re not mentoring — you’re babysitting. And the baby has unlimited energy and zero object permanence.

What We Actually Lost

Let me be clear: I’m not a Luddite. The productivity gains are real. I ship faster than ever. I build things in hours that would have taken weeks.

But something shifted.

When I built that platformer in 2001, I was a craftsman. Slow, inefficient, probably writing terrible code — but a craftsman. I understood my tools. I understood my materials. I understood, deeply, what I was making.

Now I’m a project manager for a very fast, very unreliable contractor.

The contractor doesn’t care about the code. It has no pride in the work. It optimizes for “looks plausible” rather than “is correct.” It will happily generate the same bug in 15 different files if you don’t catch it in the first one.

And catching it is your job now. Not building. Catching.

The Question Nobody Wants to Answer

The Reddit thread ends with a question:

“Do you miss the actual act of coding, or are you happy to just be the ‘director’ while the AI does the acting?”

I think about my 2001 self. That kid who spent three weeks understanding platform scrolling. Who felt genuine joy when a rectangle moved across a screen.

Would I trade that experience for “just ask Claude to make a platformer”?

I honestly don’t know.

But I know this: that kid would be horrified by how I work today. Not impressed — horrified. Because to him, the coding was the point. The game was just an excuse to code.

And now the code is just an excuse to ship.

The Adaptation

Look, I don’t have a tidy conclusion here. The models aren’t getting worse. The productivity isn’t going away. We’re not going back to DJGPP and Allegro and three-week debugging sessions.

Maybe the joy comes back in a different form. Maybe it’s in the architecture, once we learn to love it. Maybe it’s in building the tools that build the tools. Maybe it’s in the meta-game of prompt engineering and workflow optimization.

Or maybe we just mourn quietly and move on.

I’ve gotten good at code review. I’ve built mental models for reading AI-generated code quickly, spotting the common failure modes, knowing where to look for the bugs. It’s a skill. Not the skill I wanted, but a skill.

And sometimes — rarely, but sometimes — I still drop into the code myself. Ignore Claude. Write it by hand. Feel the flow state kick in, just for a moment.

It’s slower. It’s inefficient. It’s probably a waste of time.

But that little rectangle still needs to walk across the screen sometimes. Even if nobody’s watching.

I help developers build, deploy, and distribute their SaaS without hiring a team. If this resonated, you might also like Why Your AI Wakes Up Every Morning With No Memory.