Handcrafted Software in the Age of Automation

About this post: This essay was brainstormed and iterated with GPT 5.1, then developed and written collaboratively with Claude Code Web — a fitting example of handcrafted software in the age of automation.

There’s something almost funny about the term handcrafted software. It sounds like a contradiction — software isn’t carved, hammered, or woven. And yet, as someone who has been building systems long enough to feel both young and old in this industry, I can’t help but feel the term is becoming relevant again.

People look at me and assume I’m too young to have dealt with “legacy systems.” But here’s the truth: I’m older than most people writing software today. I’ve lived through enough cycles to know that nothing in technology ever really disappears — it just becomes the foundation for something new. And foundations deserve respect.

My career started in the Israeli Defense Force, in a unit once known for its information systems. I worked with mainframes in 2009–2012 — a sentence that sounds like it should belong to a history book. A mainframe in the 21st century? A relic, right?

Except relics are rarely useless. Often, they’re sacred. They survive because they were crafted so well that they earned the right to stay.

And now, as we sprint into an era of automated code generation and agentic programming, I’m realizing we’re looping back into another cycle — one that makes “handcrafted software” feel newly important.

From XML to JSON and Beyond

Anyone who lived through the golden age of XML knows how heavy it was. When JSON first appeared, it felt like seeing color for the first time. It was human. It was simple. It felt like software was finally evolving in a direction that matched the way people think.

But every generation has its tools, its aesthetics, its “right way to do things.” XML wasn’t wrong. JSON isn’t perfect. They are simply artifacts of eras — eras defined by what developers valued, what machines needed, and what problems were urgent at the time.

Software is cultural. It reflects the people who write it and the constraints they navigate.

And today, the culture is shifting again — rapidly — toward automated code creation, orchestrated by large language models and agents. This isn’t just a new tool. It’s mechanization. It’s industrialization. It’s the assembly line coming for code.

Handcrafted furniture didn’t disappear when factories emerged. But we learned to appreciate craftsmanship more, not less.

Software is entering the same moment.

Relics, Fundamentals, and the Invisible Craft

There’s a tension in the word “relic.” For some, it means obsolete. For others, it means precious. I fall into the latter group.

When I talk about relics, I’m referring to the fundamentals that underpin everything we run today:

Operating systems
Networking stacks
UNIX tools
Shell utilities
Compilers
Git
Libraries that have survived decades
Distribution-level components that quietly keep the world running

Our modern applications — and soon, our agentic systems — sit atop thousands of programs hand-crafted over decades. These are not artifacts of inefficiency. They are monuments to mastery.

And no matter how automated software creation becomes, we ignore these foundations at our own peril.

Agents today generate code at breakneck speed — often too quickly for their own good. They reinvent instead of reuse. They duplicate instead of integrate. They ignore the distribution they run on, even though that distribution contains thousands of optimized tools designed to do exactly what the agent is trying to reimplement from scratch.

The future of software automation isn’t about replacing these fundamentals. It’s about teaching agents to respect them.

A Concrete Example

Let me illustrate with a real scenario. Suppose you need to process a large CSV file and extract unique values from a column.

Automated approach (agent reinventing the wheel):

# Agent generates custom CSV parser from scratch
def parse_csv(file_path):
    unique_values = set()
    with open(file_path, 'r') as f:
        lines = f.readlines()
        for i, line in enumerate(lines):
            if i == 0:  # Skip header
                continue
            parts = line.strip().split(',')
            if len(parts) > 2:
                unique_values.add(parts[2])
    return unique_values

Handcrafted approach (using proven tools):

# One line using battle-tested UNIX tools
cut -d',' -f3 data.csv | tail -n +2 | sort -u

Or, if you need it in Python:

# Using standard library and pandas
import pandas as pd
df = pd.read_csv('data.csv')
unique_values = df.iloc[:, 2].unique()

The handcrafted approach:

Uses tools that have been refined over decades
Handles edge cases (quoted fields, different encodings, malformed data)
Is tested by millions of users
Is faster and more memory-efficient
Requires less code to maintain

This isn’t about being anti-AI. It’s about guiding AI to use the right tools rather than letting it generate bespoke solutions for solved problems.

Less Code Is Still Better Code

Even in an era where machines write the code, the principle remains:

Less code is better.

Years ago, I wrote about the importance of reading more and writing less code as a path to becoming a better developer. That advice has only become more relevant in the age of AI-assisted development.

Why does less code still matter?

Smaller context → fewer model drifts
Less maintenance
Better performance
More security (fewer attack surfaces)
Better readability for humans and automated systems

Automated software creation doesn’t excuse careless engineering. If anything, it demands more discipline from us. The agents will generate code endlessly if we let them — but that doesn’t mean they should.

We still have to be the stewards of good design.

Vibe Engineering With Responsibility

We’re entering a new era where “vibe engineering” — guiding agents through intent more than explicit instructions — replaces typing every line ourselves.

But while the agents vibe, we have time. Time to think. Time to architect. Time to choose better tools. Time to ensure that what gets generated stands on the shoulders of the giants who built the foundations — not in isolation from them.

If there’s one message I want to convey, it’s this:

Don’t let automation erase craftsmanship. The fundamentals matter. Handcrafted software matters. And the future will belong to those who can combine both — the wisdom of the old world with the capabilities of the new.

Conclusion

As we stand at the intersection of artisanal craft and industrial automation, we have a choice: we can let the machines run wild, generating mountains of mediocre code, or we can guide them with the wisdom earned through decades of careful engineering.

The mainframes I worked with in 2009 are still running somewhere, powering critical systems. They earned their longevity through quality. The UNIX tools we use daily have survived not because they’re old, but because they’re good.

In this new age of AI-assisted development, let’s not forget what made software great in the first place. Let’s build on foundations, not around them. Let’s write less, but write it well. And let’s remember that automation is a tool for amplifying craftsmanship — not replacing it.

The future needs both the efficiency of automation and the wisdom of experience. It needs handcrafted software in the age of automation.