A few years ago, "writing code" meant sitting down and writing code with your own hands, kicking in a concentrated thinking process, being in a "flow". Today, more and more of it is generated, scaffolded, auto-completed, or delegated wholesale to AI. The act of typing out a function by hand has shifted pretty drastically from the default way of building software to delegating most of the code writing to AI.
And that shift makes me wonder: if coding by hand is no longer the norm, does it start to look less like labor and actually more like craft?
The car manufacturing analogy
Consider the automotive industry. Most mass-market cars roll off highly automated production lines. Robots handle welding, painting, and assembly with precision and speed that no human can match. Humans are still in the loop, but mostly as reviewers, inspectors, and exception-handlers - finding defects and making judgment calls the machines can't.
Then there's the other end of the spectrum. Bugatti, Pagani, Morgan, Rolls-Royce - manufacturers where people still shape body panels by hand, stitch leather in-house, and assemble engines one at a time. These cars cost a fortune, take months to build, and are objectively less "efficient" than their mass-produced counterparts.
Nobody buys them for efficiency. They're bought because they're considered art.
But here's the nuance worth keeping in mind: even these manufacturers don't do everything by hand. Machine-stamped steel, off-the-shelf electronics, supplier-made fasteners - all of it shows up in a Bugatti too. The craft is concentrated where it matters: the engine, the interior, the body lines.
The interesting thing is that hand manufacturing didn't become art because the craft itself changed. It became art because the context around it changed. Once automation became the default, building by hand took on a different meaning.
Software is going through the same shift
For decades, all code was hand-written - so we never thought of it as artisanal. It was just how the job got done. But as AI-assisted development becomes the norm, the way code gets produced is splitting in two:
- Generated code - fast, cheap, good enough for MVPs, but without proper supervision it tends to turn into slop - plausible-looking code that quietly rots a codebase over time.
- Hand-written code - slower, more expensive in human hours, but shaped by intent, taste, and experience at every line.
Real codebases won't be purely one or the other. Most will be a mix - boilerplate, glue, CRUD endpoints, and test scaffolding generated by AI, while the parts that really matter - the core domain logic, the critical algorithms, the architectural seams - stay hand-written. Same as the Bugatti. The craft gets concentrated where it counts.
And if the analogy holds, those hand-written parts might eventually carry the same kind of prestige a hand-built engine does.
What would make code "art"?
Art in craft isn't just about doing things the hard way. A handmade engine isn't art because it's slow to build - it's art because every decision was made deliberately by someone who understood the whole. The same could be true for code:
- Intentionality - every abstraction, every name, every structural choice made for a reason.
- Coherence - the handcrafted parts read like they were written by one mind, with a consistent aesthetic.
- Restraint - knowing what not to add, which is something unsupervised AI-generated code famously struggles with.
- Taste - the hard-to-articulate sense of what makes a solution elegant rather than merely correct.
And here's where it gets interesting. There's growing evidence that heavy AI use doesn't just change what we produce - it changes how we think. A recent paper from USC researchers argues that when people's writing and reasoning are mediated by the same handful of LLMs, their distinct linguistic styles, perspectives, and reasoning strategies get homogenized into standardized expressions and thoughts. An MIT Media Lab study observed the same effect at the neural level: participants who wrote essays with ChatGPT showed measurably lower brain activity, and their outputs converged stylistically.
If most code starts flowing through the same few models, codebases will start to look alike - same patterns, same abstractions, same "safe" choices. Which means the qualities above - intentionality, coherence, restraint, taste - were always valued, but they weren't distinguishing. When everyone writes code by hand, having taste is an advantage. When most code is generated, and generated code trends toward the average, the hand-crafted parts are what give a codebase its character.
The counter-argument
It's worth noting the other side. Software's value has always been measured by what it does, not by how it was made. A throwaway script that saves a team ten hours a week is more valuable than an elegantly crafted library nobody uses. If AI can produce working code faster and cheaper, the "art" framing risks romanticizing a slower, more expensive process for its own sake.
So, is it art?
I don't think all hand-written code is art, just as not every handmade object is. But I do think the category is emerging. Sometimes it'll show up as entire codebases built from scratch by human hands - small libraries, focused tools, passion projects where every line was deliberate. More often, though, it'll show up as the deliberate pieces inside otherwise ordinary projects: the core engine, the key abstractions, the parts someone cared enough to shape themselves.
Ten years from now, I suspect we'll talk about those pieces the way we talk about a Bugatti engine or a Patek Philippe movement: not because they're the most efficient way to solve the problem, but because someone chose to solve it with care, line by line, on purpose.
And maybe that's enough to call it art.
What do you think?
Top comments (18)
Having "taste" in coding has long been considered an antipattern. It shouldn't matter if you prefer tabs or spaces, just make sure that your
.editorconfigand linters are set up correctly so that the commited code complies with the project's / framework's / language's coding standards.With the current quality I'd rather see an IKEA analogy: vibe coding is like cheep chipboard furniture good enough for many, but it breaks after moving for a second time, and you surely wouldn't build pub tables out of it.
Hah, I didn't think about tabs vs. spaces when meaning "taste", I rather meant neat solutions that strive for perfection, not just "quick and dirty" :)
Good call, IKEA analogy also holds great here, this is how generated code feels if to think.
I really resonate with the Bugatti analogy. I’m currently building Commerza, an e-commerce engine, and I made the deliberate choice to write it in raw PHP without any frameworks.
I actually hit a 'Code Red' recently when an AI refactor butchered my logic and deleted half my work. It forced me to spend 9 hours manually reconstructing the system line-by-line. What I realized is that while the AI could generate the 'mass-market' boilerplate, it couldn't replicate the 'intentionality' of the security architecture I’d designed (like the specific SQL row-locking). Building by hand isn't efficient, but it’s the only way I've found to truly own the integrity of the system.
True, after these years with AI we finally see its limits, it's not a silver bullet, just another clever tool. Yes, it helps building faster, but without a proper control, reviewing every its move it produces mostly slop, entangled code with unfinished functionality and workarounds just to make the thing work and please the master.
I think about it similarly to how writing very low level code has been in the last few years. A lot of the time if you did it, it was essentially an art. It has been a long time since there has been a necessity to write ultra close to the metal (leaving that vague as it depends on the situation what that means).
And .... Occasionally hand-coding machine code etc did have a purpose. And it was still sort of art, but it was for purpose beyond that.
I think that's what it will ultimately be like to "program" a computer. We're moving up the stack, and diving in to the metal will either be art or occasionally actually needed.
Btw I wouldn't say we're there yet at all. Still tons of scenarios where writing your own code is appropriate. However, I think we're trending in that direction.
Yeah, I see this similarity, we're indeed moving up the stack, first writing assembly, then shifting to higher and higher level abstractions (with occasional fallbacks to lower levels when needed), and now AI-delegated coding is another level of abstraction on top. And art-definition window is probably moving or stretching with it, like an Overton window.
The car analogy is great but not for the art of the craft. The analogy I see is selling an image and inflating operating costs.
The image is a product without AI is doomed to fail, like you don't have status if you don't have a luxury car.
You don't want to know what it costs to maintain a super car, the same goes with showing the AI usage bill to someone that just wants a marketing website.
While I read the post because of the title, code for me was and is never about art. Code is the tool that runs the product.
For this analogy I go to bikes, to stay in the mobility sector.
You can buy a bike for around 1000 but over the years you add better quality parts, and you can end up with a bike that when sold will get you 5000.
It is better to buy the right frame than spending a lot for a bike upfront that is obsolete in a few years.
Yeah, I agree that most software is a tool, chosen well, upgraded over time. The piece I'm pointing at is a bit narrower - the neat architectural decisions, a problem solved in an elegant way, so you can just sit and look at the code, admiring it. Those already existed, I'm just suggesting they'll read differently once generated code is the default backdrop. Your bike analogy actually captures the mechanical side of code really well, mine is about the narrower cases where craft can be seen through.
I'm not the person that sits to look at code. At some point it is going to change, that is what I was trying to explain with the bike parts that wear off. Even the best solution can become a bottleneck.
I see this point, yeah, in software things change, often quite fast, though some things can stay for years, decades. Even the stuff that gets replaced can be worth admiring while it's there, a handmade engine eventually gets scrapped too. Looking at some code sometimes you think "that's insanely clever design!" or "that thing is really O(1)?", these are state-of-art solutions existed long before AI. I'm just suggesting that now, with so much generated code around, the manual-writing process starts to feel more like a hobby, or in some cases art - depends on the code, of course :)
If you ask an LLM to write your tests, they will always pass, because LLMs are tuned to make you happy. If you must use a bullsh*t generator to write your code, at least hand-craft your tests so you can count on truthful results.
Yep, those are the "yes" machines to whatever you throw into them, the goal is indeed to make you happy even if it takes a bunch of workarounds :)
I don't know if it's "art", for me "artisanal" is more the word that comes to mind - a craft, rather than an industrial process ...
Yeah, maybe this is the right word after all...
Thanks for such a thought-provoking post! The car analogy is spot on, but I think art also depends on the driver’s perspective.
A Bugatti is a masterpiece, but a reliable old pickup that gets the job done every day is a work of art too. It’s about that personal connection—when a machine becomes an extension of yourself.
As a newcomer to the industry, I see beauty in any simple script that solves a real-world problem. To me, that’s already art. I actually think 'garage masters' are sometimes more impressive than automated assembly lines. Give them a set of wrenches and a camshaft locking tool, and they’ll strip and rebuild an engine in a few hours. It’s not a Bugatti, but it’s definitely a craft.
Maybe I’m not experienced enough yet to appreciate high-level abstractions, but I believe we perceive craft through our own internal assembly. The real art is in the purpose it serves.
I cannot disagree, sometimes even ad-hoc solutions could be a piece of art if they're spot on! Even from this comment section with just a few people we can see that art definition is rather personal. Though I hope we'll appreciate manually written code now even more when AI is here to automate most of the code writing for us :)
Given that us coders will now have the cultural cachet of being artists, it seems inevitable that we'll be paid like artists as well. Which is to say, very poorly.
I love this perspective!