Your company doesn’t sell handcrafted code. It sells pullovers.
And now there’s a knitting machine.
The Pullover Business
Imagine you work at a company that sells pullovers. You’re there because you know how to knit. You’re good at it. Maybe even excellent.
But here’s the thing: The business doesn’t care about knitting. It cares about pullovers—delivered on time, meeting customer expectations, at the right price point.
Now a knitting machine arrives. Faster. More consistent. Cheaper.
What happens to you?
Three Developer Types That Won’t Survive
1. The Translator
The developer who sits between Product Owner and codebase. PO speaks business, developer translates to code, code speaks back, developer translates to business.
The problem: LLMs are better translators.
They don’t say “I need more requirements.” They don’t say “please break this down into 50 small tickets.” They explore. They make assumptions. They come back with options.
“I looked at your codebase. Here are three approaches. Option 1 does X, Option 2 does Y. Which direction?”
Always. Every time. No “I don’t know” or “that’s not my job.”
Product owners—let’s be honest—would rather talk to the LLM. Because it actually engages with the problem instead of demanding perfect specifications upfront.
2. The 9-to-5 Knitter
“Tell me the pattern. Tell me the size. I’ll knit from 9 to 5 and go home.”
These developers do exactly what’s asked. No more, no less. They don’t question requirements. They don’t think about whether the pullover actually makes sense.
The problem: The knitting machine does this better.
It doesn’t get tired. It doesn’t need coffee breaks. It produces consistent output. And—here’s the uncomfortable truth—the machine’s output is often better than handcrafted code. More consistent. Fewer quirks.
3. The Artisan Knitter
The craftsperson. Loves the Handwerk—the craft itself. Uses fancy wool, complex patterns, innovative techniques. Takes pride in beautiful code architecture.
They have Herzblut—passion that bleeds through their work. You can see it in their commits, their architecture diagrams, their code reviews.
But they don’t care about the pullover.
Doesn’t care if customers actually want this style. Doesn’t care how many pullovers ship. Doesn’t care about deadlines. The craft is the point.
The problem: Companies don’t sell craft. They sell outcomes.
You relied on artisan knitters because they could handle complexity that 9-to-5 knitters couldn’t. But all that Herzblut flows into the wrong thing—beautiful code instead of useful products.
The Motivation Flip
Here’s what most people miss: LLMs don’t replace developers. They expose who was actually motivated.
The 9-to-5 knitter was never motivated. They showed up, did the pattern, went home. The knitting machine just makes that visible.
The artisan was motivated—but about the wrong thing. Beautiful code, not useful products.
And here’s the uncomfortable truth Theo nails in his video: If you learned to code 10 years ago, pushed through all that hard stuff when you were motivated, and now you’ve been coasting for 10 years—you’re fucked.
Motivation beats capability now.
A highly motivated person with Claude Code who will sit there asking endless questions, figuring out why things break, learning as they go? They’ll outperform the burnt-out senior engineer who’s “just not feeling it anymore.”
The knitting machine didn’t kill motivation. It just made it the only thing that matters.
What LLMs Do That Developers Won’t
Here’s the killer difference:
LLMs make assumptions.
They use their knowledge to fill gaps. They build something and see if it works. If not, they rebuild.
Most developers? “I need all requirements first.” “Please clarify this edge case.” “Can you break this into smaller tickets?”
That’s the death sentence.
Because making code is now cheap. Iterations are cheap. The LLM gives you five versions in minutes. Pick one. Combine two. Try something else.
Compare this to the sprint nightmare:
- You write a ticket
- Wait for sprint planning (2 weeks)
- Sprint starts, your feature is “planned”
- Sprint doesn’t finish (surprise!)
- Your feature moves to next sprint
- Six weeks later, you see a first version
- It’s not what you wanted
The LLM conversation takes 10 minutes. And you can iterate immediately.
The 20:1 Collapse
Here’s a number that should terrify you: 20:1.
That was the old ratio. For every one person who understood what needed to be built—the visionary, the product person, the founder—you needed 20 engineers to actually build it.
Why 20? Because translation happened at every level:
- Architect translated vision → system design
- Senior translated design → component structure
- Mid-level translated components → implementation
- Junior translated specs → tests and docs
Each layer was a translation layer. Human APIs between abstraction levels.
Now? One person with an LLM can do all translations themselves.
The ratio is collapsing toward 1:1.
Those 19 other engineers? They weren’t really “engineers” in the sense of building new things. They were translators at different abstraction levels. And translation just got automated.
If you’re one of the 19, you have two options:
- Become the 1 (understand the whole system, own outcomes)
- Find a different pullover factory
The Airplane Delusion
Theo tells a story that haunts me:
“Can you land a plane if the pilot is incapacitated?”
34% of men say yes.
The reality? You won’t even get the radio working.
This is the same delusion hitting our industry right now. People think: “If only coding was easier, I could build successful products.”
Coding was the first obstacle. There are hundreds more.
Theo met a developer who wanted to “pick up YouTube as a side income.” His reasoning? “I kind of like cameras and talking’s pretty easy.”
The question that broke him: “What YouTube channels do you watch?”
Answer: “Honestly, I don’t watch YouTube very much.”
He wanted to succeed at something he didn’t even consume.
The same thing is happening with vibe coding. People think: “Now that I can generate code, I can build a SaaS and make millions.”
But building code was never the hard part. The hard parts:
- Understanding what people actually need
- Communicating why your thing matters
- Getting distribution in a crowded market
- Maintaining software when reality hits
- Staying motivated through the boring middle
If learning to code was “too hard” for you, these things will be too. The knitting machine removed one obstacle. The mountain behind it is still there.
The Shift: Craft to Outcome
The developers who survive aren’t the best knitters.
They’re the ones who care about pullovers:
- Do customers want this?
- Does it ship on time?
- Does it actually solve the problem?
Not: “Is this the most elegant code?” Not: “Did I use the latest framework?” Not: “Is my architecture beautiful?”
Old mindset: I’m here to code. New mindset: I’m here to ship pullovers.
The irony? Handcrafted pullovers are often worse. Less consistent. More quirks. The automated ones are actually better for customers.
Which Developer Are You?
If you’re a translator: Learn to add value beyond translation. Understand the domain. Make decisions. The LLM can translate—what can you do that it can’t?
If you’re a 9-to-5 knitter: The machine replaced you already. You just haven’t noticed yet.
If you’re an artisan: Your craft skills still matter—but only if they serve outcomes. Channel that Herzblut into shipping better products, not into code nobody uses.
If you’re burnt out: This is the hardest truth. If you’ve lost the Biss—that hungry bite that won’t let go of a problem—no tool will save you. The motivated amateur with Claude Code will outship you. Find the fire again, or find a different career.
The business sells pullovers. Not knitting. Not craft. Not code.
Pullovers.
Adjust accordingly.
Inspired by Chris Gregori’s “Code Is Cheap Now. Software Isn’t.” and Theo’s video response exploring the motivation thesis.