Confessions of a Code Monkey

Why I miss writing code by hand, and why I feel like a fast food cook once again.

A decade ago, software was eating the world.

But it wasn’t complex software that was doing it. It was code written thousands of times already - websites, newsletter signup forms, payment integrations, and various CRUD apps.

The thing was that suddenly everyone needed such software.

So we brute-forced its development by putting more hands on keyboards.

Academia took 3-4 years to produce engineers and problem solvers, but the industry needed writers.

We needed people writing code, people who could find a solution that matched the problem and reproduce it, people who spoke the language of the CPU well enough to translate somewhat optimal instructions to it.

But, again, these problems have been solved numerous times by countless developers around the globe, and there’s not that much problem-solving to do, but researching and pattern matching.

I was a product of that time.

On a subconscious level, I realized that I was doing a subset of what real software engineering was fairly quickly.

There’s this exact moment that kicked off a chain of neurological events in my mind.

My colleagues were discussing how the services in a new project would communicate with each other, and when someone asked me what I thought, another colleague said:

“Pfft, Alex, doesn’t even know what a pointer is...”

And he was right.

I didn’t know what a pointer was.

I could write code, I could build applications, but I didn’t know this fundamental piece of knowledge you learn in CS 101.

I was a fucking code monkey.

My job was to scour the web for solutions for my problems, remember a few pieces of syntax, and produce them again and again on the assembly line.

I was building applications without knowing what a pointer was.

My work was that simple.

I was a cook in a fast food restaurant who had no idea how to make a proper meal, but knew how to follow a system. I was tossing already-flavored meat on the grill, defrosting soups, and seasoning salads with an off-the-shelf mix.

But I wanted to be more.

I wanted to talk about microservices named after Greek gods (as was the fashion of the time), module structure, load balancers, and API design.

In the last decade, I saw the industry promise thousands of people that it doesn’t care about logical principles, that the fundamentals were a waste of time, that they could memorize APIs, and specialize in a technology as a career.

But that was a false promise, and a lot of people are feeling it.

People have long mistaken writing code for building software, and the industry now needs builders.

I’ll be honest, I loved writing code.

Maybe I loved it a little bit too much.

For a long time, that was the outlet for my creative aspirations, and I’d find places to express myself even in the margins of very simple code.

But I’m rarely doing this anymore.

I don’t explore technologies and problems with the depth that made me fall in love with this craft. It’s so tempting to gloss over library APIs, ask the LLM to summarize them, make a couple of changes, ensure maintainability, avoid a bug, and ship.

This isn’t an existential write-up about job security.

It’s about meaning and fulfilment.

The act of orchestrating agents is too... managerial for me. I moved away from engineering management and went back to being an individual contributor, but it seems this was an illusion of free will.

All roads lead to the same place.

I was watching “The Bear” the other night, and one of the characters said something that stuck with me.

“You found something that you love and it’s completely okay if you don’t love it anymore. Because the most special part about it is that you were capable of that love.”

I really feel like I’ve been forcing myself to love programming lately.

Don’t get me wrong, it’s fun to build things, it’s nice to see your ideas come to life quicker, to have a never-ending source of debugging ideas, to see computers doing new things.

But a part of me feels like it’s back to being a code monkey, only differently.

Writing code by hand gave me the pace of thought I needed to understand a problem deeply. After a couple of years at a company, I knew the codebase by heart, every corner of it, every service, and every script.

I find it difficult to say the same thing now.

“If you’re thinking without writing, you’re only thinking you’re thinking.”
― Leslie Lamport

I’ll miss the days when the Tab button was used to add a tabulation, not to accept a Cursor suggestion.

In many cases, it just doesn’t make sense to write code by hand anymore.

Agents are faster, cheaper, and they let me try out more ideas before I settle on a solution. I make small changes by hand, and I write the code myself when it’s too specific to explain.

But when I’m kicking off a new feature, I scaffold it with an agent. I tell it what interfaces I need, what structure I’m expecting, and then I fill in the blanks.

This makes me feel like I’m working in someone else’s codebase, though.

So I’m taking solace in learning more about distributed systems, UX, and how to be more of an editor and less of a writer.

I’m looking for that sense of meaning and creative satisfaction in different places.

It’s not easy.

But one day I’ll be telling my younger colleagues how I wrote entire applications by hand.

“Kids these days don’t know what real work is.”
— Me, in the future

I’ll be insufferable.