I have a small workshop in my backyard. It was a COVID project, and is pretty well appointed, if not large. In my spare time (which, let’s be honest, barely exists), I make things with my hands. Cutting boards. Turned bowls. The occasional small piece of furniture. There’s something deeply satisfying about taking raw material and shaping it into something functional and beautiful.

Here’s what I’ve learned from woodworking: good craft isn’t about making art for art’s sake. It’s about creating clean, functional, useful items that serve a purpose and maybe, just maybe, bring the user a little joy while doing it. A cutting board should be solid, ergonomic, and safe for food prep. A bowl should balance in your hands. A side table should support your coffee cup without wobbling.

Software development, I’ve come to believe, is the same kind of craftwork.

From Wood to Code

When I’m debugging a complex problem, I’m doing the same thing I do when I’m planing a board flat: I’m removing imperfections, checking for grain (in code, we call it logic flow), and ensuring the final product will serve its purpose reliably. When I’m architecting a system, I’m thinking about load-bearing joints and how the pieces fit together — just like mortise and tenon.

The best software, like the best furniture, doesn’t draw attention to itself. It just works. It feels right. Users don’t think about it; they just use it and get on with their lives. But here’s where the metaphor gets really interesting.

The Revolution We’ve Seen Before

The Industrial Revolution fundamentally changed woodworking. Before the 1800s, every table, every chair, every bowl was hand-crafted by individual artisans. This meant furniture was expensive, time-consuming to produce, and available only to those who could afford it. The masses made do with crude, sometimes unsafe pieces, or simply went without.

Then came mechanization. Water-powered sawmills. Steam-driven lathes. Assembly lines. And the purists absolutely hated it. “It’s not real craftsmanship,” they said. “Machines can’t replicate the soul of handmade work.” And you know what? They were partially right. A mass-produced Victorian chair doesn’t have the same individual character as one made by a master craftsman spending weeks on a single piece.

But here’s what actually happened: for the first time in human history, ordinary families could afford sturdy, safe, well-designed furniture. Children slept in beds that didn’t collapse. Families ate at tables that didn’t wobble constantly. The quality of life for millions improved of people improved as a result.

The craftsmen didn’t disappear. They adapted. The good ones used the new tools to work at a higher level, focusing on design, innovation, and the complex pieces that still required human judgment. The Industrial Revolution didn’t kill craftsmanship — it democratized quality.

Our Turn

We’re living through the software industry’s Industrial Revolution right now, and AI coding agents are our steam engines. I’ve been watching and using these tools with the same mix of fascination and unease that a 19th-century woodworker must have felt watching the first steam-powered lathe.

Gemini CLI, Claude Code, GitHub Copilot, Cursor, and a dozen other AI coding assistants are fundamentally changing how we build software. Can they write a perfectly optimized algorithm? Sometimes. Can they architect a complex distributed system? Not yet, not entirely. Do they make mistakes? Absolutely. Are there shortcomings? Of course there are.

But dismissing them because they’re not perfect is missing the point entirely.

What’s Really Happening

Here’s what I see when I use AI coding agents in my daily work:

The tedious work, the repetitive patterns, the “I’ve written this exact function 47 times before”: it gets handled in seconds instead of hours. This frees me to think about the hard problems: the architectural decisions, the edge cases, the user experience, the security implications. Just like a modern woodworker doesn’t hand-saw every board anymore, I don’t hand-type every getter and setter. The machine handles the repetitive cuts; I focus on the joinery.

But more importantly, these tools are lowering the barrier to entry. Someone with a great idea but limited coding experience can now build functional prototypes that would have been impossible a few years ago. Just as the Industrial Revolution meant more people could afford good furniture, the AI Revolution means more people can create good software.

The Shortcomings Are Features, Not Bugs

Yes, AI coding agents make mistakes. They suggest insecure code. They misunderstand context. They generate solutions that work but aren’t elegant. Sometimes they just go nuts. You know what also had those problems? Early industrial machinery. Early steam engines exploded. Early assembly lines produced inconsistent quality. Early woodworking machinery cut off fingers.

We didn’t abandon the technology. We improved it. We added safety guards. We refined the processes. We learned how to use the tools properly.

The developers who will thrive in this new era aren’t the ones who reject AI tools out of principle. They’re the ones who learn to work alongside them effectively, who understand both the power and the limitations, who know when to trust the AI and when to step in with human judgment.

Just like the best modern woodworkers use CNC routers for precision cuts but still hand-finish the surfaces where it matters.

The Real Revolution

In the next few years, we’re going to see better software serving more users than ever before in our industry’s history. Software that’s more reliable, more accessible, more thoughtfully designed because the humans building it are freed from the tedious grind and can focus on what actually matters.

Startups will ship faster. Solo developers (like me) will build what previously required teams. Teams will tackle problems that were previously too complex or time-consuming to attempt.

The democratization of software development will mirror the democratization of manufacturing. And yes, the role of the software craftsman will change. We’ll spend less time cutting code and more time designing systems. Less time debugging syntax and more time optimizing user experiences. Less time on the mechanical and more time on the meaningful.

Just like industrial woodworking didn’t eliminate the master craftsman. It elevated them.

The Joy Remains

I still love turning bowls on my lathe, even though I could order a perfectly functional bowl from Amazon for less than the cost of the wood I use. The joy isn’t in the mechanical act of removing wood. The joy is in the creative decisions, the problem-solving, the satisfaction of making something with intention.

The same will be true for software development. The joy won’t disappear because AI handles the boilerplate. If anything, it will increase, because we’ll spend more time on the parts that actually require creativity, judgment, and craft.

The Industrial Revolution didn’t kill woodworking. It transformed it. And in doing so, it brought better furniture to billions of people who never could have afforded it otherwise.

AI coding agents won’t kill software development. They’ll transform it. And in doing so, they’ll bring better software to billions of users who desperately need it.

That’s not a threat to craftsmanship. That’s the fulfillment of its purpose: creating useful, functional things that bring people a little joy while serving their needs.

The tools change. The craft endures. And more people benefit than ever before.