We Thought Python Was a Shortcut Too

A strange thing happens every time technology removes friction. The people who suffered through the old friction begin to treat that suffering like virtue.

You can see it happening right now with AI coding tools. Engineers who once celebrated automation are suddenly suspicious of it. “If you didn't write every line yourself, did you really build it?” The question sounds modern, but it isn't. We've asked the same thing for decades, just with different tools, different syntax, different anxieties hiding underneath.

A few nights ago, I watched an older systems engineer laugh at a teenager building a working app with AI assistance in under an hour. “They don't even understand memory management,” he said, half amused, half offended. Then something hit me. I had heard almost the exact same tone years earlier when C programmers talked about Python developers.

Before that, assembly programmers said it about C.

And somewhere before that, someone probably stared at a compiler itself and thought, This is cheating. Real programmers write machine code.

What we call craftsmanship is often just familiarity wrapped in nostalgia.

If you learned programming in the C and C++ era, you remember the texture of it. Not just the logic, the texture. Header files breaking your build for reasons that felt spiritual. Segmentation faults arriving like random acts of violence. The strange pride of manually managing memory because doing it correctly separated adults from children. You earned every successful compile. Even your failures felt earned.

Then Python arrived wearing sneakers to a black-tie event.

Suddenly, people were building useful software without touching pointers. Students could automate workflows in a weekend. Startups could prototype products before raising money. Entire categories of friction disappeared, and with them, a certain identity disappeared too. For many engineers, the discomfort wasn't technical. It was psychological.

Because if something becomes easier, what happens to the status of the people who mastered the hard version?

That question quietly shapes almost every technological backlash.

You see it in creative industries too. Photographers once mocked digital cameras because film required discipline. Designers dismissed templates because “real” design involved painstaking manual work. Even writers resisted spellcheck in the early days. Human beings build emotional meaning around difficulty. We associate effort with worth because effort is visible. Ease feels suspicious.

But history keeps moving in one direction. Abstractions win.

Not because they make people lazy, but because they free humans to work at a higher layer of the stack.

Most developers using Python were not weaker than C programmers. They were focused on different bottlenecks. The abstraction allowed them to spend less energy fighting the machine and more energy solving problems. Entire industries exploded because of that shift. Web applications scaled faster. Data science became accessible. Startups moved at speeds that would have been impossible if every founder had to manually manage memory allocation before validating an idea.

Now we are watching the same emotional cycle unfold again with AI-assisted coding.

The arguments sound eerily familiar.

“They don't really know what the code is doing.”

“They're becoming dependent.”

“They skipped the fundamentals.”

And sometimes those criticisms are fair. But fairness is not the whole story. Fear rarely announces itself honestly. It disguises itself as standards.

Let me tell you something uncomfortable. The market does not reward suffering. It rewards leverage.

A founder who ships a functioning prototype in three days using AI will beat the purist who spends six months handcrafting elegance nobody sees. That doesn't mean fundamentals are useless. It means fundamentals alone are no longer enough. The world increasingly values people who can orchestrate systems, not just manually execute every layer inside them.

This is why the current transition feels emotionally intense. AI coding is not just changing workflows. It is changing identity.

For years, many engineers unconsciously tied self-worth to possessing rare technical difficulty. You survived complex setups, obscure bugs, impossible deployments. Your pain became proof that you belonged. Then suddenly a teenager with Cursor and Claude can build something impressive before lunch.

That creates cognitive dissonance.

Not because the teenager is necessarily better, but because scarcity is collapsing.

And when scarcity collapses, identity panics.

You can already see the split happening inside the industry. Some people are using AI like a calculator, cautiously, defensively, trying to preserve the old shape of work. Others are treating it like an exoskeleton. They are generating prototypes instantly, testing ideas at absurd speed, learning by building instead of preparing endlessly before action.

The second group is going to reshape entire markets.

Not because AI makes them geniuses overnight. Most AI-generated code today is imperfect, sometimes hilariously so. But speed changes psychology. When the cost of experimentation drops close to zero, human ambition behaves differently. People attempt ideas they would have abandoned before they even started.

That matters more than most people realize.

A teenager in Bangalore can now build software that once required a funded engineering team. A solo founder in São Paulo can launch internal tools without waiting for technical cofounders. A marketer with product instincts can prototype interfaces directly instead of translating vision through five layers of meetings and specifications.

The distance between “I have an idea” and “I made the thing” is collapsing.

That may be the most important shift of all.

Of course, there will still be elite engineers. Just as C and C++ never disappeared, deep technical expertise will remain incredibly valuable. Someone still has to build infrastructure, optimize systems, secure architectures, understand complexity beneath the abstraction layer. But the center of gravity is changing. More value is moving toward taste, judgment, systems thinking, and speed of iteration.

The same thing happened when Python rose. Suddenly, programming was no longer reserved for people willing to endure maximal pain. Purists complained. Then the world moved on without asking permission.

And here's the irony nobody talks about enough.

The people criticizing AI coding today are often beneficiaries of earlier abstractions themselves.

Most of them are not writing assembly. Most are not managing servers manually. Most rely on frameworks, cloud platforms, package managers, open-source libraries, autocomplete, high-level languages, APIs.

Every generation draws an imaginary line one step below its own tools and declares, “That was real engineering.”

Everything after that supposedly became cheating.

But abstraction is the entire story of technology. A computer itself is an abstraction machine. We build layers so humans can think bigger thoughts.

Maybe the real skill is not resisting abstraction. Maybe it is learning when to trust it, when to inspect beneath it, and when to use it to move faster than fear.

Years from now, today's AI-native developers will probably become nostalgic too. They'll tell younger builders, “Back then, we still had to prompt manually.” And some new generation will laugh while building products with tools that make today's workflows look primitive.

The cycle will repeat because humans confuse familiarity with legitimacy.

But progress has never cared much about that confusion.

The real question is not whether AI coding is cheating. The real question is whether we are brave enough to adapt before nostalgia turns into irrelevance.

I'm curious where you stand on this. Did AI coding change how you think about programming, creativity, or expertise? Or does part of you still feel the emotional pull of the old way? Tell me what you've noticed because this transition feels bigger than most people are willing to admit.