AI-assisted coding is trading craft for speed. Let's not repeat history.
- Jonathan Gordon
- 2 days ago
- 5 min read
Takeaways
Speed without alignment creates drift.
Replacing skill with speed leads to degraded quality.
The real threat isn't AI speed — it's accepting mediocrity.
Unlike power looms, AI can fix what it breaks — if we build the right infrastructure.
Two centuries ago, factory owners replaced skilled weavers with power looms because machines were faster. Profits went up. And the accumulated knowledge of generations of craft vanished overnight, leaving behind machines that broke and fabric with severe quality issues. Though faster, machines couldn’t produce product at the standard that human weavers routinely achieved. Today, software teams are being handed AI code generators that move faster than human speed and told to ship faster with fewer people. We’ve seen this story before, and we don’t have to make the same mistakes.
The Industrial Revolution: Speed replaced skill
In the early 19th century, a wave of mechanization swept through Britain’s workshops, replacing thousands of craftspeople—who had spent years mastering their trades—with machines that could produce goods faster and cheaper.
Coopers who could create watertight barrels without glue or nails, shoemakers who understood the relationship between leather and human anatomy, watchmakers who built tiny precision mechanisms — all of them watched factories churn out inferior versions of their work.
The pattern was consistent: machines delivered speed but lacked access to the contextual knowledge that made things work—why certain approaches held up, which trade-offs mattered, and how materials behaved. That knowledge lived in people. And when machines were problematic or subpar, the human expertise needed to improve them was gone. The chance to combine machine speed with human expertise never materialized.
The AI Revolution: Will history repeat itself?
We're watching the same pattern unfold in software — just compressed from decades into months. AI code generators produce in seconds what once took hours. And just like factory owners in 1810, today's leaders are asking: why pay for slow when fast is available?
And many in the software industry are currently panicking over their own future. We’ve been here in the software industry before. In the ’90s, CASE tools were going to eliminate programmers. In the 2000s, low-code platforms were going to replace developers. In the 2010s, design tools with auto-layout were going to make designers obsolete.
The current AI panic among skilled software creators is already loud: UIs generated in seconds, sweeping predictions of obsolescence, early-career engineers wondering if there’s a future for them. If machines can do the work faster and cheaper, human skill may very well become obsolete.
Here’s the thing: We’re focused on the wrong threat. The rise of AI-assisted coding isn't the threat — what we choose to do with it is.
Speed didn’t destroy craft two centuries ago — accepting mediocrity did.
The speed of AI assisted coding isn’t the issue — It’s drift
“Does AI work?” Yes. It can instantly generate impressive output and functional code. But functional doesn’t mean aligned. When code diverges from standards — using outdated patterns, hard-coded values, or deprecated conventions — that’s drift. And drift compounds.
Here’s how this plays out in codebases everywhere:
Month 1: New design system ships. AI generates components that look close enough. Everything feels aligned.
Month 6: The codebase now contains three incompatible streams — legacy pre-system code, AI output from outdated patterns, and new AI code unaware of your evolved standards.
Month 12: Full fragmentation. Thousands of components using different conventions, token names, and structures. No single source of truth.
This isn’t a hypothetical problem. It’s already happening.
The question isn’t whether AI can generate code. It's whether we can maintain alignment across an ever-increasing mountain of code — legacy and AI-generated — as standards inevitably evolve.
The fundamental problem of drift has plagued software for decades. AI’s speed and volume have now made it impossible to ignore.
So we face a choice. We can follow the Industrial Revolution playbook: accept the poorly aligned code that AI churns out, watch quality degrade through drift, and let it eliminate human insight and skill. Or we can write a different story.
AI changes everything
Here’s the difference between then and now: when a power loom produced bad fabric, that was final. A poorly woven section stayed poorly woven. But code can be analyzed, refactored, and improved. A poorly written component can be systematically refined—and with AI, we can do it at scale.
We can scan entire codebases to identify every instance where code drifts from current specifications. Not sample checking, not spot audits, but comprehensive analysis across millions of lines.
We can understand patterns across complexity that would take human reviewers months to identify manually . Which components use hard-coded values? Where do accessibility patterns fall short? Which architectural decisions create technical debt? AI can surface all of it.
We can suggest concrete refinements with context. Not just “This is wrong,” but “Here’s how to align it with your current standards, and here’s the refactored code.” Make the path to quality actionable, not theoretical.
We can validate changes before applying them. Simulate refinements. Check for breaking changes. Ensure improvements don’t introduce new problems. Quality maintenance becomes systematic rather than risky.
We can maintain alignment continuously as standards evolve. When your design system updates, immediately identify everywhere old patterns exist. When architectural principles change, find every violation. Quality doesn’t decay — it improves over time.
Most importantly, we have the expertise right now to address these issues. We have designers who understand design systems and accessibility, engineers who know architecture and maintainable patterns, and product leaders who understand user needs and quality standards.
If we build infrastructure as a natural augmentation of expert skills, rather than a replacement for them — what quality looks like, which trade-offs matter, and how context affects decisions — and apply augmented skills systematically across entire codebases at scale, we can empower software builders in unimaginable ways.
This is the moment where human expertise and machine capability can finally work together—not in opposition.
The big question now: Will we build the right infrastructure to make it happen?
Check out my proposed solution to this problem, HERE.
>Grab our AI Coding Survival Kit with guidelines and downloadable rules that you can use now to help you steer AI to get the output you want.
-----------
Jonathan Gordon is the founder/CEO of ReWeaver AI. He has worked as a user-focused software designer leading design and engineering teams at Google, Microsoft, Oracle, Facebook, SAP, and others.
Comments