Creators Who Mock Their Own Craft: Examples and Patterns
Can engineers build AI systems so good that they replace engineers entirely? And if they can, why would they do it?
I mean, think about it. We're the ones writing the code. We understand exactly what these systems can and can't do. We know which parts of our jobs are getting automated first, and which parts might never be replaceable. So if we're building our own replacement, we're doing it with full awareness of what we're destroying.
I think we absolutely will. Not because we have to, but because we want to.
Comedians spend entire sets explaining why comedy is meaningless. Game designers create games where the goal is making the player unnecessary. Managers build systems specifically designed to eliminate their own importance.
Creating your own obsolescence has this strange appeal. The better you get at your craft, the more you're drawn to making that craft unnecessary.
Last week I was debugging some automation code I'd written — code that eliminates the need for manual data processing that used to take our team hours every day. While I was fixing it, I realized I was using AI to help me write better code that replaces human work more efficiently.
I'm using AI to build better automation that eliminates human work. The irony hit me: I'm making myself obsolete with tools designed to make me obsolete.
This self-destructive impulse shows up everywhere. Great creators seem drawn to undermining their own importance, and somehow that makes their work more valuable, not less.
When Comedians Dissect Comedy: The Art of Professional Self-Awareness
I remember watching Bo Burnham's "Make Happy" and feeling something click. Here was a comedian spending half his set explaining why comedy was pointless.
In his older work, he'd walk up to a spotlight mid-performance and tell the audience exactly how much that single light rental cost. Then he'd calculate how many children in Africa could be fed for the same amount. Just casually destroying the magic while standing in it.
But "Make Happy" hit different. Burnham spent the entire show talking about being a comedian who'd never done anything else. All his jokes about "real life" were completely made up. His only real experience was making jokes about not having real experiences.
The finale was brutal in its honesty. He talked about how comedians appear confident on stage, but actually know nothing and can do nothing. Then he made that confession itself into a joke. Even his vulnerability was performed.
His song "Art is Dead" captures this perfectly. The whole thing is about how artists are just attention-seeking people who learned to get what they want. He's singing about how meaningless his own art is, while creating art that's genuinely meaningful.
I loved it. But really, I was watching a comedian argue that comedians shouldn't exist. Burnham figured out how to use comedy to kill comedy.
This self-destruction becomes beautiful. He's not just analyzing comedy from the outside. He's using comedy to kill comedy from the inside, and somehow that creates something better than either analysis or comedy alone.
I recognize this impulse. My favorite code makes my job easier by doing the work for me. My most successful systems reduce the need for systems. Creating your own obsolescence feels right.
Building Systems That Fire Me (And Why I Love It)
I ended up managing people earlier than expected — mostly by accident when small projects I was working on needed more hands than I could provide.
The thing about having other people work with you is that you quickly realize coordination becomes its own problem. You can't just throw more hands at work and expect things to go smoothly.
So I started hiring help when projects got too big for me to manage. And no matter what I was working on, I kept asking myself the same question: if I got sick tomorrow and couldn't work for a week, would everything fall apart?
I became obsessed with building systems where I could disappear and nothing would break. Every process I documented, every workflow I set up, every decision framework I created — all designed so the company could run without me.
This backfired spectacularly a couple times. I got removed from situations where I really didn't want to be removed. Turns out when you make yourself replaceable, sometimes people actually replace you.
But most of the time, this approach worked out better than I expected. The better I got at making myself unnecessary, the more necessary I became.
Most managers hoard information and create dependencies because they're terrified of being replaced. They become bottlenecks. Doing the opposite works — actively working to eliminate your own bottleneck status makes you valuable in a completely different way.
Now when I manage teams, I follow the same "fire myself" logic. Everything I build is designed so I could vanish tomorrow and the team would keep running smoothly. Good management eventually makes the manager replaceable.
Game Designers Who Gamify Optimization: The Factorio Phenomenon
There's this whole category of games called automation simulators where the entire point is making yourself unnecessary.
Take "Factorio" computer game. You start by mining ore with your hands, crafting basic items one at a time. But the goal isn't to keep doing that forever. The goal is to build a factory that does all of this automatically while you sleep.
I've watched friends spend entire evenings after work setting up conveyor belts and robotic systems. What they did by hand yesterday, today gets handled by machines. What required their attention last week now runs without any input from them at all.
This feels incredibly satisfying. You're literally working toward your own obsolescence in the game world, and that progression — from essential to completely unnecessary — is the core reward loop.
In Factorio, success is measured by how little the game needs you. A perfectly optimized factory runs for hours without any player intervention. You've built something so efficient that your presence becomes optional.
The game designers created a system where the ultimate achievement is making the player redundant. They took the concept of automation and turned it into entertainment. People come home from jobs where they might feel replaceable, then voluntarily play a game about replacing themselves.
This isn't just a game mechanic. It's the same drive that pushes engineers to write code that writes code, managers to build self-running teams, and comedians to create jokes about the pointlessness of jokes.
The game designers understood something fundamental. We find deep satisfaction in creating systems that make us unnecessary. Smart code eliminates the need for more code. Effective automation removes the need for manual work. Well-designed systems reduce the need for systems. Factorio just made that engineering satisfaction into a game.
We're Programming Our Own Replacement (And It's Working)
For over a year now, I've been writing most of my code through AI voice commands in Cursor IDE. Yesterday I built a product page by talking to my computer for about twenty minutes instead of typing.
I've been working as VP of Engineering and building systems for a while now.
In the past 8 months, I've been working on a few automation systems:
- Something that generates basic CRUD APIs from database schemas — saves us from writing the same boilerplate over and over
- A scraper that reads API docs and writes integration code (works about 70% of the time without manual fixes)
- An experiment with generating simple mobile apps from requirements (still pretty rough, but surprisingly functional)
These aren't AI assistants that help programmers in chat. These are systems where LLMs write most of the codebase automatically, and programmers review and fix what needs fixing. We're still essential, but we've moved from writing code to orchestrating code generation.
I'm not just watching this happen to other programmers. I'm actively building these systems myself.
I recognize the same pattern I described with comedians and game designers. There's something satisfying about how cleanly these systems can replace manual work.
When people ask me whether programmers might accidentally build software that replaces them, I'm certain we will. Not accidentally. On purpose. Just for the elegance of it.
Engineers engineering their own obsolescence is perfectly recursive. We build the systems that make us unnecessary. We understand exactly what we're doing, and we keep doing it anyway because the automation is too elegant to resist.
The irony isn't lost on me. I'm using AI to write systems that replace human programmers, while finding genuine joy in how cleanly the whole process works. Every time I eliminate another manual step, every time I automate something that used to require human judgment, I feel the same satisfaction I get from a perfectly optimized algorithm.
Creating your own replacement is deeply satisfying, especially when you do it well.
I don't think this will happen overnight. There's a massive last-mile problem. Fine-tuning AI systems to handle edge cases will take longer than we think. Plus, improving these systems still falls on engineers — for now.
But the beauty in automation is compelling enough for engineers to eliminate themselves, even against their own interests.
We're building our own obsolescence because it's too elegant not to finish.
The Pattern Behind the Pattern
Bo Burnham uses comedy to destroy comedy. I build management systems that eliminate managers. Game designers create entertainment about making players unnecessary. Engineers write code that replaces engineers.
This isn't masochism or career suicide. It's something deeper.
Here's my theory about what's really going on: we're not building AI to replace engineers because we have to. We're doing it because it's the most interesting problem we've ever seen.
Every engineer I know got into this field because they love solving puzzles. And what's the ultimate puzzle? Building a system that can solve puzzles better than you can.
It's like Burnham using comedy to kill comedy. You see the problem and you want to solve it. Can you write code that writes better code than you do?
Some engineers say they're worried about AI taking their jobs. But watch what they actually build in their spare time. They're not building job protection - they're building automation.
We're going to automate engineering work because the challenge is too interesting to ignore. And when it works, we'll be proud of it.
