Once upon a time variables were declared, logic laid out, an assertion of control, a marker of territory in an abstract domain. We mapped our thoughts into symbols, structured them with care, and prayed the compiler would agree. This was called "programming".
And the people argued over languages, not because the machine cared, but because language was identity, and identity was war. Tabs or spaces. Bracket placement. Pure functions or pragmatic sins. All the preferences were lined up against the wall, and summarily piped to /dev/null. The linters were relentless, backed by agile forces. Buzzwords came in waves. RFCs alone couldn't hold the line.
Some claimed their preferences were rooted in performance. Others in elegance. Some believed in the prophecy of the One True Paradigm: Oject-oriented. Functional. Declarative. Reactive. Each tribe called the others naive, bloated, unsafe, or just plain cursed. Frameworks rose and fell like empires, no one mourned them. They only wept at the lift of the refactor. Others clutched their vendor lock-in, like their livelihoods depended on it. (because they did)
Every solution birthed ten dependencies. Every abstraction, a prelude to another abstraction. Patterns hardened into doctrine. Interfaces calcified into law. The why buried in story ticket after story ticket. We only cared about the how, so we built -- because that's where the money came from. Because building was all we knew, scaffolding out precarious cathedrals. We debugged in the dark and named things badly. We wrote documentation no one read. We optimized bottlenecks no user noticed. It was 'honest' work, and it kept the void at bay.
Some people started to notice, long before the machines started completing sentences. Things were already shifting. The tickets got thinner. The requests got stranger. "Can you just make it do what the user expects?" "It should feel like that other feature, but not exactly." "We want it clean, but not too simple." "Don't overthink it."
If you asked for details, the conversation moved. "Let's take this offline." "Loop in design." "We'll sync async." Push harder, and you were suddenly the problem. Not collaborative. Not flexible. Not fast enough. It felt like clarity itself was being discouraged.
But the pressure wasn't abstract. It had a source. The roles above you had softened. PMs became vibe curators. QA was shifting left. Designers handed over prototypes like riddles. Everyone upstream offloaded complexity, and it rolled downhill with interest.
You weren't just writing code anymore. You were product. You were UX. You were QA, DevOps, analyst, therapist, interpreter. But you still only got paid for being an engineer. You were told this was empowerment. That you were owning more. But when things broke, the ownership ended at you.
And so you stretched. You filled in the blanks. You wrote the missing spec in your head. You translated ambiguity into action, not because it was your job, but because someone had to. The system rewarded the ones who made it look easy.
The system rewarded those who made themselves replaceable. Who adapted to anything. Who asked fewer questions. Who smiled through weekend deploys and rewrote specs in silence. It rewarded those who nipped at the edges of the entrenched 'elite', but never challenged their foundations. It praised the ones who were "reasonable" in the fight against boundaries. Who treated craft as overhead. Who called resistance laziness, and called speed leadership.
Over time, people stopped guarding their edges. Design bled into frontend. Frontend bled into backend. Backend into infra. Infra into ops. And under it all, people pushed on each other. Not out of cruelty, but out of necessity. Everyone was stretched thin, so the pressure moved sideways. You weren't just solving problems anymore. You were solving other people's abandonment. And calling it teamwork.
Teamwork was real. People helped each other, covered for each other, stayed late together. There was trust, and care, and pride in what got built. But beneath it, something else was moving. A quiet shift in the story. A narrative no one could quite name, but everyone seemed to act out. A growing sense that the goalposts were always moving, and someone, somewhere, had decided that something else was the new normal.
What was the system? That depended entirely on where you worked.
In the old stories, there was always the cathedral builder, the guru who knew every secret seam in the codebase. Most of the team lived in that cathedral, patching cracks and fixing leaks, half hoping the guru never left, half resenting their dependence. No one liked being hostage to a single brain, not the company, and certainly not the customers locked in by its walls.
To create the replaceable engineer, you first had to destroy the moat. Docs in the open, rotations on call, ownership spread thin. The company loved this; it meant fewer single points of failure. But the company was under the same spell. Investors didn't want key person risk. Customers didn't want vendor lock-in. As above, so below. Everyone was asked to give up leverage in the name of continuity.
At the enterprise level, the system was process. Meetings layered on meetings. Committees for every change. Jira board rituals, compliance theater, documentation no one read but everyone feared forgetting. You were safe if you played along, invisible if you didn't. The moat was procedural, and so was the slow suffocation.
In the startup, the system was adrenaline. Everything was on fire, always. Ownership meant doing three jobs badly and still apologizing for the fourth one you forgot. Chaos was framed as culture, scope as freedom. The moat was speed, and the debt was spiritual.
In the code sweatshop, the outsourced feature factory, the system wasn't obscured at all it was plain and in the open: extraction. Just ship it. Don't ask questions. Templates in, tickets out. You could be replaced at any moment, and you knew it. The moat was silence, and it belonged to someone else.
Then there was the 'cracked' tech founder. Half visionary, half cult leader. They spoke in dreams, built in chaos, and pivoted without warning. The team ran on borrowed faith and caffeine. The moat was personal charisma, and you lived inside it, until you burned out, or it broke.
Each version of the system had its own logic. Each one believed it was doing things right. But what they all shared was this: wherever you stood, clarity was eroding. The job was expanding while the roles dissolved, everywhere except in the sweatshop.
Teamwork still mattered. People still cared. Yet, a new baseline settled in: make yourself easy to swap. Trust the process, not the person. Some called it progress. Some called it survival. Most just called it normal, until normal started to feel thin.