You don't need to knit a scarf. You can buy one at H&M for twelve euros. It'll keep you warm. It'll look fine. Nobody will know the difference.
And yet, millions of people knit. They knit on trains, in living rooms, in dedicated knitting circles with friends. They obsess over yarn weight, needle gauge, stitch patterns. They spend forty hours making something they could have bought in five minutes. Not because the output demands it, but because the process itself is the point.
I think programming is heading there. Not tomorrow for everyone, but soon. For some of us, it's already arrived.
Coding is largely solved
This is going to sound like a bold claim, so let me be specific about what I mean.
If you have a clear product vision, understand the architecture you want, and can articulate the constraints precisely, AI agents can produce the code. Not a rough draft. Not a starting point. Production-ready, tested, deployable code. I've watched it happen in my own work. I've built entire products where my contribution was the thinking, the directing, the taste - and the agent handled the implementation.
I wrote about this dynamic in my piece on taste being everything when output is cheap. The core argument was that when producing something approaches zero cost, the bottleneck shifts to knowing what's worth producing. That argument was about AI-assisted work in general. What I'm saying now is more specific: the act of manually writing code, line by line, keystroke by keystroke, is becoming optional for getting software built.
That doesn't mean coding is dead. Read that again, because this distinction matters.
Coding versus producing code
Here's where people get confused, and where the conversation usually goes sideways.
Coding and producing code are not the same thing. Producing code is about the output - functions, modules, systems, shipped features. Coding is about the process - the act of thinking in syntax, reasoning through logic, feeling the structure of a program take shape under your fingers.
When I say coding is becoming like knitting, I mean the process is decoupling from the output. You will still need to produce code. Software doesn't build itself (yet). But the act of writing that code by hand, character by character, is no longer the only path - or even the most efficient path - to production software.
All the skills that make a great developer? Still essential. Systems thinking. Architectural judgment. The ability to debug something you've never seen before. Communication. Deep thinking. The soft skills that let you navigate a room full of stakeholders who all want different things. None of that goes away. If anything, as I argued in my piece about AI making developers more valuable, these skills become more important because the execution layer is handled.
The thinking is the same. The interface is changing.
The knitting parallel runs deeper than you'd expect
The history of knitting is actually a perfect template for what's happening to programming.
Before industrial textile manufacturing, knitting was labor. Families knitted because they needed clothes. It was skilled work, certainly, but it was fundamentally driven by necessity. When machines took over production, knitting didn't disappear. It transformed. It went from something you had to do into something you chose to do.
And here's the interesting part: the craft got better once it became optional.
When you remove the pressure of production, people start experimenting. They develop techniques that prioritize beauty over efficiency. They create patterns that would never make economic sense in a factory but are stunning as handmade pieces. Entire communities form around the craft itself - sharing techniques, celebrating skill, pushing the boundaries of what's possible with two needles and some yarn.
Programming is following the same arc. When you no longer need to write code by hand to ship software, the people who still choose to do it will do it differently. They'll write code that's elegant for the sake of elegance. They'll explore languages and paradigms purely for the intellectual satisfaction. They'll build things that would never survive a sprint planning meeting but are beautiful as expressions of computational thinking.
Think about it. Knitting communities obsess over yarn quality - the fiber content, the twist, the hand feel. They debate needle materials (bamboo versus metal versus wood) with the same intensity developers debate text editors. They share patterns and techniques not because they need to, but because the community is the craft.
Now imagine programming communities where people write Rust for the pure satisfaction of fighting the borrow checker and winning. Where someone spends a weekend implementing a ray tracer in a language they'll never use professionally, just to understand how light works in code. Where "artisanal code" isn't a joke but a genuine expression of craft - handwritten, intentional, beautiful in ways that AI-generated code never will be.
That's not a fantasy. That community already exists. It's just about to get a lot bigger.
Where I am right now
Personally, I'm in the production phase. The productivity gains from AI tooling have been so dramatic that I'm producing at a pace I've never experienced in twenty years of building software. I'm shipping real products, writing documentation, processing customer feedback, building skills and tools - all at a speed that would have required a small team two years ago.
Right now, I don't write much code by hand. I produce. I direct. I architect. And honestly? It's exhilarating.
But I can already feel the pull. Once this pace settles - once the immediate product demands calm down and the AI-assisted workflow becomes routine rather than novel - I know I'll come back to writing code for fun. Not because I need to. Because I want to. Because there's something about the act of manually crafting a solution that no amount of AI prompting can replicate.
It's the difference between asking someone to cook you dinner and cooking it yourself. The meal might taste the same. But the experience of making it, the smells, the timing, the small adjustments, the satisfaction of a dish that came together because you understood the ingredients - that's irreplaceable.
The generational split
For developers who learned to code in the last five years, this shift might feel natural. They grew up with AI tools. They don't have the same emotional attachment to the act of typing code that someone with twenty years of muscle memory does.
For developers like me, who spent decades where typing was the primary interface to building software, this is a bigger adjustment. The keyboard was how we thought. The syntax was how we expressed ideas. Letting go of that as the primary mode of production feels like something is being lost.
But here's what I keep coming back to: nothing is actually lost. The knowledge is still there. The intuition is still there. The craft is still there. What changes is that the craft becomes optional for production and intentional for pleasure.
For some of us, this is already happening. For most developers, I'd give it about two years before this becomes the default mode. The agents are getting good enough, and the workflows are maturing fast enough, that manual line-by-line coding for production work will start to feel like writing assembly when you have a high-level language available. You can do it. You just don't need to.
The uncomfortable parts
Let me be honest about the uncomfortable part of this analogy.
Knitting survived as a craft because the barrier to entry stayed low. Yarn is cheap. Needles cost almost nothing. Anyone can learn the basic stitches in an afternoon. The craft is accessible, and that accessibility is what sustains the community.
Programming as a craft might not have that luxury. If the act of writing code becomes disconnected from production value, there's a real risk that the ecosystem around it contracts. Fewer tutorials aimed at manual coding. Fewer jobs where hand-written code is expected. Fewer entry points for people who would have discovered the joy of programming through necessity.
There's also the question of whether "craft coding" becomes elitist - a hobby for people who already have deep knowledge and can afford to code for fun, while newcomers skip straight to AI-directed production. That would be a loss. Some of the best developers I've known discovered their talent because they had to write code, not because they chose to.
The community will need to be intentional about keeping the on-ramp accessible. Teaching people to code from scratch isn't just about workforce development anymore - it's about giving people the foundation they need to taste the craft and decide if it's for them.
You can't knit for pleasure if nobody ever taught you to hold the needles.
The craft is the point
Here's where I land on this.
The output of programming (working software, shipped features, production systems), will increasingly come from AI-directed workflows. The people who can articulate clear vision, understand architecture deeply, and communicate precisely will produce software without writing much code by hand. That's already happening.
But the act of programming - the meditative focus of solving a problem in code, the satisfaction of an elegant algorithm, the deep pleasure of making something work with your own hands and mind - that doesn't go away. It transforms. It becomes something you do because it feeds you, not because the deadline demands it.
Like knitting. Like woodworking. Like any craft that survived the industrial revolution by becoming more meaningful, not less.
The scarf keeps you just as warm either way. But the one you made yourself? That's the one you keep.
Concluding
Programming is not dying. It's graduating. Moving from a necessity to an art form, from labor to craft. The transition won't be instant, and it won't be painless. But the developers who recognize this shift early - who learn to direct AI for production while preserving their love of the craft itself - will have the best of both worlds.
Ship software at the speed of thought during the day. Write beautiful, unnecessary, deeply satisfying code on the weekend.
The question isn't whether you'll still need to code. It's whether you'll still choose to. And that choice is what makes it art.
Frequently asked questions
Is programming really becoming obsolete?
No, and that's exactly the point. Programming as a discipline is more relevant than ever. What's changing is the manual act of writing every line by hand. The skills that make great programmers - systems thinking, architecture, debugging intuition, communication - remain essential. The keyboard part is becoming optional. That's a meaningful difference.
What does the knitting analogy actually mean for developers?
Knitting went from necessity to craft when industrial manufacturing took over textile production. Nobody needs to knit a scarf anymore - you can buy one for a few euros. But millions of people still knit because the process itself is rewarding. Programming is heading the same direction. You won't need to write code by hand to ship software, but many people will choose to because the act of coding is satisfying, meditative, and deeply creative.
Do you still need traditional coding skills if AI agents can write code?
Absolutely. AI agents amplify what you already know. You still need to architect systems, reason about trade-offs, understand performance implications, debug subtle failures, and communicate technical decisions to stakeholders. The difference is that instead of expressing all of that through manual keystrokes, you express it through precise intent and AI translates that into implementation. The thinking is the same. The interface is changing.
When will this shift happen for most developers?
For some developers it's already happening. Those with strong product vision and deep domain knowledge are already producing software without writing much code by hand. For the broader industry, expect two years before this becomes the norm. The agents are getting good enough, and the workflows are maturing fast enough, that manual line-by-line coding will feel increasingly optional for production work.
Should junior developers still learn to code from scratch?
Yes, emphatically. You can't direct what you don't understand. Learning to code builds the mental models, debugging intuition, and architectural taste that make you effective with AI tools. Skipping that foundation is like trying to direct a film without understanding cinematography. The craft informs the vision, even when you're not the one holding the camera.
