“Craftsmanship is a quality that some lack, you gotta give the customer a reason for them to come back.”
–Buck 65 – Canadian rapper, poet, and storyteller

That line has followed me for more than twenty years. I’ve quoted it in interviews, in team offsites, even in design critiques. It’s a simple truth that has always felt like the backbone of good work, whether you’re making music, code, or products. Craftsmanship matters.

But lately, I’ve been wondering what that word even means anymore.

The Setup

Geek alert: I promise this comes back to something actionable, and hopefully relatable.

A few weeks ago, I built a new home lab server using Proxmox, an open-source virtualization platform. Basically, I wanted to tinker with Linux, learn the latest server tech, and play with modern development tools, which I haven’t done much of in recent years (thanks for draining all of my energy, loving family).

It started innocently enough: an old laptop I had repurposed as a home server was on the brink of death, so why not turn that into a weekend project? Pick up a cheap mini PC, then rebuild (and break) things for fun. What surprised me wasn’t the setup itself, but what I felt while doing it.

For the first time in years, I was installing dependencies, connecting to servers, configuring proxies, and editing configurations by hand. I used VS Code to SSH directly into the system, and ChatGPT helped when I got stuck. That combination—VS Code’s near-telepathic autocomplete and ChatGPT’s “I-know-everything” energy—was… eye-opening.

The Old Way

Twenty some odd years ago, I worked as a web designer and front-end developer. Back then, HTML and CSS weren’t just markup and styling—they were a survival game—and even before starting my professional career I was hand-coding in HTML. We didn’t have autocomplete or inline validation or Stack Overflow.

When I started working full-time, my prized possession was a $20 zip file of HTML and CSS references, which became my bible. It lived on every machine I touched. I knew those specs inside and out. I knew how to make layouts behave across Internet Explorer and Netscape. I learned the tricks, the weird float bugs, the clearfix hacks, the pixel rounding issues on nested tables.

I wasn’t special; that was just what being a front-end dev required. There was pride in that. You earned it through repetition, through pain, through the discipline of not having shortcuts.

When something didn’t work, you didn’t copy-paste a fix, you understood why. You opened “View Source,” you experimented, you internalized. It was slow, but it made you sharp. It built a sense of craftsmanship that stayed with you.

The New Way

Fast-forward to today. VS Code and other modern development tools don’t just autocomplete your syntax, they complete your intent. These tools now read the context of your project, the dependencies in your packages, the shape of your markup files. They know enough to suggest what “should” go there before you even know it yourself. And when it doesn’t know, ChatGPT does. Or at least, it tries to.

The mix is intoxicating: instant feedback, context-aware suggestions, explanations on demand. It’s like pairing with an infinitely patient senior developer (who’s maybe a little too confident and sometimes pretty darn wrong). I caught myself coasting. I’d paste an answer from ChatGPT into VS Code, hit save, and hope it worked. No debugging. No real understanding of why it worked.

That’s when it clicked: I suddenly understood why some modern dev teams—especially ones full of younger engineers—can feel like they’re moving fast but learning slowly.

The Concern: When Speed Replaces Understanding

In the last few years, as I’ve led design and product teams, I’ve noticed a pattern:

  • Delays across organizations don’t generally come from lack of effort, but from a lack of understanding.
  • Fixes that solve one issue often create… more issues.
  • Teams seem technically fluent but conceptually lost.

I’ve always chalked that up to the natural growing pains of complex systems. Modern stacks are so massive that nobody on the team can know everything. But now, after this little Proxmox experiment, I’m not so sure that’s the whole story.

Maybe what we’re seeing is a generation of developers raised by autocomplete. The tools that once helped experts move faster are now helping beginners skip the hard parts. And skipping the hard parts can make you productive, but not necessarily skilled. When your tools predict the next line of code, it’s not teaching you; it’s shielding you. When ChatGPT explains a configuration, it’s not giving you understanding; it’s giving you an answer that sounds right. Multiply that by deadlines, side projects, and never-ending sprints, and suddenly you have a team that ships a lot, but may know very little.

Everything looks fine. The code runs. The PR gets approved. From the outside, everything’s humming. But under the surface, the team’s collective understanding is shallow. The system becomes a black box, glued together by trust in tools they don’t fully grasp. And when things break—as they always do—the fixes take longer. Debugging turns into archaeology.

For what it’s worth, I’ve seen this happen across disciplines, not just in Engineering. Designers often rely entirely on Figma plugins and auto-layout logic without understanding CSS; Product Managers might generate AI-generated requirements that sound amazing, but collapse under scrutiny. In each case, the tool gives us speed and confidence but quietly erodes the craft beneath it.

The Shift: From Syntax to Systems

In AI-circles, the phrase “human in the loop” describes exactly this: a setup where people remain essential, guiding and refining rather than being replaced.

Twenty years ago, craftsmanship meant knowing every HTML tag by heart. Today, that kind of knowledge is commoditized. The new craft—whether you’re in development, design, or product—is shifting from syntax to systems. It’s no longer about how fast you can write code, mock up an interface, or produce a requirements document. The real skill now lies in understanding how things connect—how technology, decisions, and people intersect. The new craft might be in:

  • Understanding systems instead of syntax.
  • Knowing when to trust the AI and when to override it.
  • Building guardrails, not just outputs.

Developers may move from writing logic to curating intelligence. Designers may move from pushing pixels to composing behaviours. Product Managers may shift from writing specs to shaping ecosystems. It sounds poetic, but curation still requires taste, judgment, and experience, which only come from doing the hard work that modern tools increasingly let us skip.

Leaders have a new kind of responsibility here. We can’t just evaluate output anymore; we have to look at how that output was produced.

  • Did the person rely entirely on AI suggestions?
  • Do they understand the implications of what they shipped?
  • Can they explain their reasoning in their own words?

I’m already seeing a widening gap between those who understand the systems they use and those who simply operate them. The first group uses AI as leverage; the second uses it as a crutch. It’s not about gatekeeping or nostalgia for “the good old days.” It’s about protecting the link between curiosity and competence, and making sure people still learn through friction.

Ultimately, that leaves us with fast teams that truly get better. And maybe, just maybe, that’s what will give our customers a reason to come back. Which brings me back to Buck 65 and why that lyric still hits home…

The Hidden Differentiator: Craftsmanship

That’s what Buck 65’s quote was getting at: craftsmanship isn’t just about outcomes. It’s about the care and intention that goes into great work. It’s the difference between a layout that looks good today and one that’s maintainable a year from now, or a system that “just works” and one you can trust.

In a world of generative everything, craftsmanship might be the last true differentiator left. Because here’s the thing: anyone can now produce something that looks polished. AI can write, design, code, compose. The outputs are getting scarily good. But the feel of good work—the intentionality, the invisible polish, the understanding of trade-offs—that still takes a human who cares.

Craftsmanship is what keeps people coming back. Ironically, it’s the very thing most at risk right now.