Something subtle—but seismic—is happening in programming circles.

Words like taste, aesthetics, and even soul are starting to show up in technical discussions. Not as side notes. As core criteria.

At first glance, this might feel strange. But once you trace the pattern, it makes perfect sense. AI is reshaping what it means to be a "good" programmer—and the best developers aren’t doubling down on syntax or speed. They’re leaning into curation, collaboration, and cultural intelligence.

The tools have changed. And so has the game.

From Proficiency to Performance: How the Old Guard Measured Skill

Traditionally, programming was about precision:

• Write efficient, correct code.

• Master systems thinking and language quirks.

• Optimize for runtime, memory, or scale.

You’d read The Art of Computer Programming, memorize Big-O notations, and flex your chops on LeetCode. A good programmer was one who could solve things fast and solve them right.

And even today, some of that still matters. Santiago’s viral X thread about building a working command-line tool in an hour using Cursor and Sonnet 3.5 still fits that frame: fast, functional, and technically competent.

But that metric is starting to flatten. Because now?

AI can do all of that, too.

AI Changed the Playing Field—Now We're Grading on Feel

Tools like GitHub Copilot, Claude, Cursor, and o1 Pro are shifting the terrain. They:

• Autocomplete boilerplate.

• Solve algorithmic challenges.

• Generate usable code—fast.

In many cases, they outperform junior devs on specific benchmarks. As Santiago noted, Sonnet 3.5 got the job done.

But then came the real work:

Two full days spent cleaning up the AI’s output—making it readable, DRY, and presentable for human teammates.

The code ran fine. But it was ugly. Disorganized. Bloated.

That’s where AI still falls short. And that’s where human value re-enters the room: not in writing the code, but in refining it.

Real Signals from the Field

This shift isn’t hypothetical. It’s happening in real time:

• In Zebird’s post, he compares Claude and GPT-4. Claude’s code is “technically correct,” but boring and dry. GPT-4? “Flows better... has soul.” He’s evaluating LLMs the same way we critique jazz or poetry. He’s not looking for just working code—he’s looking for code with vibe.

• Brian Roemmele echoes this sentiment. He describes AI’s role as collaborative, requiring the human to step in as curator, conductor, composer. He explicitly calls for “aesthetic judgment.” His tone is clear: the winners won’t be the ones who use AI to finish tasks, but those who direct AI output into something resonant.

We’re watching a redefinition of skill in real time. Programming is turning cultural.

Why “Taste” Is the New Differentiator

Once AI levels the technical playing field, what remains is distinctly human.

Here are the new frontiers of differentiation:

1. Taste as Judgment

Santiago’s desire for “beautiful code” points to a deeper truth: not all code that works is worth shipping.

Great developers now need:

• A sense of elegance.

• The intuition to know when code is readable, not just runnable.

• The eye to refine AI’s messy drafts into something aligned with community or project standards.

Taste, in this context, is professional literacy. And not everyone has it.

2. Aesthetics as Quality Control

Aesthetics might feel like a soft skill—but in a team setting, it’s survival.

Readable code is maintainable code. Elegant code is scalable code. “Ugly code,” as Santiago called it, creates technical debt and slows teams down.

Aesthetic standards (e.g., DRY principles, modularity, naming conventions) are the new form of code hygiene. And yes—your team feels your code before they read it.

3. Collaboration as Core Competency

When Santiago says, “Others will read this code,” he’s speaking to a new north star.

AI doesn’t care about your team’s standards. It doesn’t understand nuance in variable naming, or why that one method might confuse the new intern.

You do. And in this new era, your ability to make AI output human-compatible is the edge.

This Is a Cultural Shift, Not Just a Technical One

We’re not just changing tools. We’re changing values.

• Objectivity → Subjectivity

• Execution → Curation

• Solo → Social

This is why cultural language is seeping into the field: because human values are now central to the dev workflow. AI does the legwork. Humans define the standard.

The Emerging Archetype: The Programmer as Curator

This next wave of programmers will look different.

They won’t just:

• Write algorithms,

• Fix bugs, or

• Work solo on deep systems.

They’ll:

• Shape code with intentionality.

• Direct AI with taste and precision.

• Translate technical output into collaborative momentum.

They are the curators, conductors, code poets—with the power to make AI useful because they know how to humanize its output.

Final Thought: Code Is Becoming Cultural Capital

We’re at the edge of a paradigm shift.

Technical proficiency will always matter—but it’s becoming baseline. The new signal is human judgment. Taste. Aesthetic sense. Team fluency.

Programming isn’t losing its edge. It’s just evolving. And the ones who will thrive are the ones who can move between worlds: technical and cultural, fast and thoughtful, AI-native and deeply human.

The future belongs to programmers who know that code isn’t just syntax.

It’s signal.

It’s story.

It’s style.