01 December, 2025
Stop Writing Code (For Real This Time)
The Thanksgiving Break That Changed Everything I Thought I Knew About Software Engineering
Before Thanksgiving, I wrote a blog post telling engineers to stop writing code. I meant it then—but I had no idea how much I would mean it just four days later.
Over the holiday break, I discovered the power of running multiple asynchronous AI agents—parallel workflows, parallel reasoning, parallel execution. Instead of a single assistant waiting for instructions, I suddenly had a small fleet operating simultaneously, synthesizing requirements, generating code, validating designs, and iterating on their own output while I slept.
When I came back after that four-day weekend, I looked at what we had produced—production-ready, deployable code—and every metric I could find pointed to the same shocking conclusion:
My productivity jumped by a factor of 25×.
Not 20%.
Not 2×.
Twenty-five times.
No human engineer can compete with that—not with raw typing speed, not with pattern recall, not with efficiency or discipline or focus. And the craziest part? This wasn’t some exotic hardware or enterprise framework. This was Claude and a handful of orchestrated agents on commodity hardware.
And here’s the part that matters:
My domain isn’t life-support software, real-time avionics, critical infrastructure, or high-frequency trading.
But 80% of developers don’t work in those domains either.
For the vast majority of us, this level of acceleration isn’t just possible—
it’s here. Now. Today.
The Post-Thanksgiving Realization: Everything Is About to Change
When I said engineers should stop writing code, I was being provocative but directionally serious. Now? I’m not being provocative at all.
I am telling you plainly: everything about software engineering is about to change.
The structures we built—bootcamps, universities, job ladders, software teams, agile rituals, entire SDLC frameworks—were all designed around an assumption that humans would be typing code for the foreseeable future.
That assumption is already obsolete.
The moment AI can generate production-grade systems faster than we can articulate them, the bottleneck shifts entirely to human understanding:
- What are we building?
- Why are we building it?
- How should it behave?
- What constraints and tradeoffs matter?
The typing is gone.
The syntax is gone.
The need to “remember how to do X in framework Y” is gone.
Engineering becomes architecture and intent.
AI becomes implementation.
And once you internalize that, another thought naturally follows…
Eventually, We Won’t Need Code at All
Anyone know how to use a sliderule? Abacus? Yea, me either.
But, there was a time.
Code is an abstraction.
A convenience layer.
A human-readable facade over assembly, which itself is a facade over machine instructions.
We invented code because humans needed a way to tell a machine what to do.
But if humans no longer need to tell machines how to do anything—if we are only specifying what and why—then the idea of “code” becomes an artifact of a transitional era.
Eventually, we will express intent in a form that AI translates directly to assembly.
Eventually, assembly itself becomes another abstraction AI optimizes away.
Eventually, the entire notion of “programming languages” dissolves.
And when people ask me:
“But how are you going to debug assembly?”
My answer is simple:
I won’t. The AI will.
That’s the point.
The machine will diagnose the machine.
We will describe outcomes, constraints, rules, safety boundaries, and performance characteristics.
The AI will write, rewrite, optimize, and debug everything beneath that.
Humans won’t debug machine code.
Machines will debug machine code.
The New Role of the Engineer
So where does that leave us?
Exactly where our value has always been—
in the problem space, not the code space.
Human engineers will become:
- Architects
- Domain experts
- Systems thinkers
- Constraint designers
- Quality governors
- Stewards of business logic
- Modelers of intent
We move up the stack.
AI consumes everything below it.
The job of engineering is about to become more strategic, more conceptual, and—ironically—more human.
Stop Writing Code. Start Defining Systems.
The “stop writing code” line began as a joke with a manager.
Then it became an observation.
Now it’s a prediction.
If your engineers are still typing code manually, you are operating at a disadvantage that grows larger every week. A year from now, it may be impossible to compete.
The shift is happening.
The tools are here.
The acceleration is real.
And after a Thanksgiving weekend that multiplied my output by 25×, I am convinced:
We are witnessing the last era in which human beings will write code.
The future belongs to those who learn to think, design, and communicate at the level where code is no longer required.
Everything is about to change.
And honestly?
It’s going to be incredible.