Coding Should Be Fun and I'm Done Pretending Otherwise

I’m a self-taught senior staff engineer with 27 years of building things. I started because it was fun. I built my first website because I wanted to see something I made on a screen. I wrote my first script because I was bored and curious and the computer did what I told it to. That feeling — the loop of think, build, see — was the purest creative feedback loop I’d ever experienced.

Nobody had to motivate me. Nobody had to put it on a roadmap. Nobody had to schedule a sprint planning meeting to convince me to stay up until 3am making a thing work. I did it because it was fun.

Somewhere along the way, an entire industry decided that wasn’t enough.

The Joy Got Extracted

Here’s what happened. The thing that was fun became valuable. And the moment it became valuable, people who don’t build things started building systems to capture that value.

Management frameworks. Performance review cycles. Story point estimation. Velocity tracking. Stack ranking. On-call rotations with no additional compensation. “Unlimited PTO” that nobody takes because taking it tanks your performance review. Open offices designed for surveillance disguised as collaboration. Slack messages at 11pm that say “not urgent” but somehow still expect a response.

The creative act of building software got wrapped in so many layers of extraction that the person doing the actual building became the least important person in the room. You’re a resource. You’re a headcount. You’re a line item that gets cut when the stock price dips, rehired when it recovers, and expected to be grateful for both.

That’s not a career. That’s a hostage situation with a 401(k) match.

The Cruelty Is the Point

Let’s stop pretending corporate engineering culture is accidentally bad. It’s not. The cruelty is structural.

On-call without comp time. You’re expected to be available 24/7 for systems you didn’t architect, running on infrastructure you can’t modify, serving business decisions you weren’t consulted on. When the pager goes off at 3am, you lose sleep, focus, and health. When nothing goes wrong, nobody notices. The risk is yours. The upside is theirs.

Performance reviews that punish honesty. “Exceeds expectations” is the baseline. “Meets expectations” is a warning. The engineer who ships the most critical fix of the quarter gets the same rating as the one who wrote the most visible design doc, because visibility is the metric and impact is not.

Layoffs as strategy. Not as a last resort. As a quarterly earnings play. Hire 10,000 people you don’t need so the stock price goes up, then fire 10,000 people so the stock price goes up again. The people in the middle — who relocated, who turned down other offers, who believed the mission statement — are collateral damage in a financial instrument that has nothing to do with building software.

The open source bait-and-switch. Build your product on open source maintained by people working for free. Hire them if they get popular enough. Burn them out. Replace them. Change the license when the community gets too powerful. The entire modern tech stack runs on the mass exploitation of people who code for the love of it.

This isn’t dysfunction. This is the system working as designed. The system extracts joy and converts it to shareholder value.

Everything Is Changing. Good.

Right now the industry is terrified. AI is coming for the junior roles. Layoffs are constant. The FAANG career ladder that defined success for a generation is collapsing. The playbook — grind LeetCode, get into a Big Tech company, vest for four years, repeat — is falling apart in real time.

And I think that’s the best thing that’s happened to this industry in twenty years.

Not because people losing their jobs is good. It’s not. Every layoff is a person with rent and a family and a plan that just got shattered. That’s real and it’s brutal and anyone who minimizes it has never been on the wrong side of a Zoom call that ends with “your access has been revoked.”

But the system that’s collapsing? The one that convinced a generation of engineers that their worth was measured in total compensation and LeetCode scores and how close they could get to a Staff title at a company that would cut them the moment it was financially convenient?

That system deserves to collapse.

What comes after it is up to us.

The Shift That’s Already Happening

Look around. The engineers who are thriving right now aren’t the ones clinging to the old model. They’re the ones who went back to the thing that made them start coding in the first place.

Solo builders shipping real products. One person, one idea, one codebase. No sprint planning. No stakeholder alignment meetings. No ticket for the ticket. Just the loop: think, build, ship, learn.

Small teams that own the whole stack. Two or three people who can go from idea to production in a week because there’s no handoff tax, no environment hell, no six-layer approval chain. They’re not faster because they work more hours. They’re faster because they don’t have to spend 70% of their time performing work instead of doing it.

Self-hosted infrastructure that costs almost nothing. A $6/month VPS runs a production application. Gitea replaces GitHub. Woodpecker replaces GitHub Actions. PostgreSQL replaces the $40,000/month managed database. The cloud vendors spent a decade convincing us we couldn’t run our own servers. We can. We always could.

AI as a multiplier, not a replacement. The engineers who are scared of AI are the ones whose jobs were already mostly process compliance — attending meetings, writing status updates, translating business requirements into Jira tickets. The engineers who build things are using AI to build faster, not wondering if AI will replace them. When you know how to build, AI is a power tool. When your job is overhead, AI is your replacement.

This shift isn’t theoretical. It’s happening now. The tools are accessible, the infrastructure is cheap, and the gatekeepers are distracted trying to figure out their own layoff strategy.

What Fun Actually Looks Like

Fun doesn’t mean unserious. Fun doesn’t mean sloppy. Fun means the work itself is the reward, not the RSUs that vest in eighteen months if you don’t get PIP’d first.

Fun is choosing your own problem. Not being assigned a ticket from a backlog prioritized by someone who doesn’t understand the technical implications. Choosing a problem that interests you, scoping it yourself, and solving it the way you think is best.

Fun is learning because you want to. Not because your manager said you need a “growth area” for your performance review. I learned machine learning because I wanted to fine-tune a model for my own project. Nobody assigned it. Nobody approved it. Nobody scheduled a knowledge transfer meeting about it. I just did it because it was interesting, and now I can do something I couldn’t do before.

Fun is shipping and seeing it work. The moment your code does the thing you designed it to do, in production, for real users. That dopamine hit is real and it’s the reason most of us started this. Corporate engineering buries it under so many layers of process that by the time your code reaches production, you’ve moved on to three other tickets and you don’t even notice it shipped.

Fun is owning what you build. Not assigning the IP to a company that will shut down the project when the VP who championed it leaves. Building something that’s yours, that runs on your infrastructure, that serves your users, that exists because you decided it should exist.

Fun is sustainable. It doesn’t require 60-hour weeks. It doesn’t require being on-call. It doesn’t require sacrificing your health, your relationships, or your sleep for someone else’s quarterly earnings. If the work is fun, you don’t need to burn out to be productive. You just need to show up and build.

The FTC Stack Is a Philosophy

In the SDLC article, I introduced the FTC Stack — Fun Time Coding. It’s not a specific technology stack. It’s a decision framework.

Before you adopt a tool, a framework, a process, or a methodology, ask one question: does this make building more fun or less fun?

Kubernetes for a side project? Less fun. Skip it.

TypeScript for a project that needs type safety? More fun. Use it.

Self-hosted Gitea instead of paying GitHub per seat? More fun. Own your code.

A two-hour sprint planning meeting for a two-person team? Less fun. Kill it.

A 3B language model fine-tuned on your own domain instead of paying for API calls to a 70B model you don’t control? More fun. Build it.

This isn’t anti-rigor. Rigor is fun when it’s in service of building something real. Rigor is miserable when it’s in service of someone else’s audit trail.

The filter is simple. If the process serves the builder, keep it. If the builder serves the process, burn it.

The Paradigm Shift We Need

The old paradigm: coding is a job. You do it for a company. The company owns the output. You are compensated in salary, equity, and the privilege of not being laid off this quarter. Success is climbing the ladder. The ladder is defined by people who don’t build things.

The new paradigm: coding is a craft. You do it because it’s the most powerful creative medium that has ever existed. You can build something from nothing, deploy it to the world, and have it running while you sleep. The tools have never been cheaper. The distribution has never been more direct. The gatekeepers have never been weaker.

This doesn’t mean everyone quits their job tomorrow. That’s not realistic and it’s not the point. The point is that the mindset shifts. Even inside a company, you can reclaim the craft. You can push back on process that doesn’t serve the work. You can build side projects that remind you why you started. You can mentor junior engineers by showing them that the joy is the point, not the promotion.

The industry needs this shift because the current model is eating its own talent pipeline. Junior developers are entering a field that greets them with LeetCode hazing, imposter syndrome, and the constant threat of being automated away. The seniors are burned out. The staff engineers are in meetings all day. The principal engineers haven’t written code in years.

Nobody in that pipeline is having fun. And when nobody’s having fun, nobody’s building anything great.

What I’m Doing About It

I build things because I enjoy it. That’s the whole reason.

Loop Lock exists because I wanted to build a video loop editor for beatmakers and nobody had made the one I wanted. The system design grammar exists because I wanted to see if you could compress all of software architecture into a finite vocabulary that a machine could validate. I run my own servers because I enjoy understanding every layer of the stack. I write these articles because explaining things clearly is its own kind of building.

None of this requires permission. None of it requires a sprint. None of it is on anyone’s roadmap.

It’s just fun.

And the things I’m building — the ones that are fun — are the best things I’ve ever built. Not because I’m working harder. Because I’m not fighting the process to do the work. The work is the process.

The Bet

Here’s the bet I’m making: the engineers who rediscover fun will outbuild the engineers who are optimizing for compensation. Not because fun is magic. Because fun is sustainable, and sustainable builders compound.

The person grinding LeetCode to get into a company that might lay them off in eighteen months is on a treadmill. The person building something they care about, on infrastructure they own, with tools they understand, is planting a tree.

Treadmills burn calories. Trees bear fruit.

The industry is going to shake out. The big companies will keep laying off and rehiring. The AI discourse will keep oscillating between utopia and apocalypse. The venture money will keep chasing whatever the next hype cycle is.

And somewhere, in a room that isn’t an open-plan office, an engineer is going to stay up until 3am not because they have to, but because they want to. Because the thing they’re building works and they can see the next piece and they just want to get it in before they forget.

That’s the shift. That’s the future. Not a new framework. Not a new methodology. Just engineers remembering that the reason they started doing this was because it was the most fun they’d ever had.

Let’s get back to that.

Constraints win. But so does joy.

Jason Walker is a senior staff engineer and solo builder with 27 years of experience. He’s building Loop Lock, the perfect A/V loop creator, and designing the standard of system design grammar. He runs his own infrastructure, owns his own stack, and writes about building things without the weight. Interested in the grammar? Email stonecassette@gmail.com with the subject “Interested in your system design grammar.” Follow the work at jsonwalker.com.