I stopped caring which language someone uses. Somewhere in the last eighteen months, that happened without me deciding it.
Not because I became a better person. Because the argument stopped mattering.
In August 2025, TypeScript surpassed both Python and JavaScript as the most-used language on GitHub for the first time ever. Not because developers sat down and decided TypeScript won. Because AI tools handle it better, so it spread. The debate didn't resolve. The ground shifted underneath it and most people are still fighting on the old map.
The War That Already Ended
The Python vs JavaScript argument ran for a decade. Rust evangelism became a personality type. C++ veterans looked down on everyone. The fight was never really about syntax — it was about belonging. Who gets to call themselves a real developer. Who gets filtered out at the interview. Who gets taken seriously in the architecture meeting.
That argument is over.
Not because anyone won. Because something else became the constraint.
What Replaced It
The new constraints aren't linguistic. Tokens — how much context a session can hold before the model starts forgetting what it's building. Context windows — how much of your codebase an agent can actually see at once. Prompt discipline — whether your instructions are tight enough that the agent doesn't guess. Three things. None of them are in any job description yet.
Nobody voted on this shift. There was no announcement. It just became true while we were arguing about whether Rust was worth learning.
The developer who ships consistently now isn't the one who knows the most syntax. It's the one who can structure a spec tightly enough that the agent doesn't hallucinate the requirements, manage a context window without losing architectural coherence across sessions, and catch what the model got confidently wrong before it reaches production.
I’ve been experimenting heavily with this in my own production AI agents and real-browser automation workflows.
That's a different skill. No bootcamp teaches it yet. Most job descriptions don't list it.
The Gate Didn't Disappear. It Moved.
Language gatekeeping excluded people by syntax preference. You didn't know pointers? Not a real programmer. You used PHP? Embarrassing. You learned with a framework instead of from scratch? Shortcuts.
The new gatekeeping is quieter. You're not excluded for your language anymore.
You're excluded for your context budget.
Token limits are a billing problem dressed as a technical one. But knowing how to structure prompts, manage agent memory, and stay coherent across a long multi-step workflow — these compound. The developer who can do this produces dramatically better output than the one who can't. The gap is real and it grows with complexity.
Same exclusion mechanism. Different surface. Less visible, which makes it harder to name and harder to argue against.
The old gatekeeping was at least honest about what it was filtering for. The new one looks like a productivity difference.
What Doesn't Change
Not everything shifted.
That person is still you.
The things that actually matter — judgment, accountability, knowing when the confident answer is wrong — those don't change with the terrain. They get more important as generation gets cheaper.
Uncle Bob Martin, who spent months coding with Claude and wrote about it publicly, noticed something: Claude codes faster, holds more details, but can't hold the big picture. It doesn't foresee the disaster it's creating. Someone still has to see that. Someone still has to slow down and ask whether this is right, not just whether it compiles.
But the marker of competence shifted. The proxy changed. The new proxy is harder to fake than the old one.
You can memorize syntax. You can pass a whiteboard interview on language trivia. You can't fake knowing how to structure a ten-step agent workflow without the context collapsing at step seven, or how to write a spec that gives an agent something real to work with instead of something it'll interpret five different ways.
This is exactly why I built my own SEO automation agent that runs unsupervised on Cloudflare.
The old gate was about what you'd memorized. The new one is about how you think.
The Part That's Still Unresolved
I don't know if the new gate is better than the old one.
The old gatekeeping protected a social hierarchy more than it protected code quality. CS degrees, whiteboard interviews, years-of-experience requirements — they controlled access. They decided who got to call themselves real engineers. That architecture was never really about quality.
The new constraints are at least about something real. Context discipline, prompt structure, verification habits — these produce actual output differences. The filter is less arbitrary.
But "less arbitrary" isn't the same as "fair." Token budgets cost money. The developer in Lagos with a $20 API limit and the developer in San Francisco with a $200 plan are not operating in the same environment. The new constraint is technical and financial simultaneously. That's not a coincidence — it's just the old hierarchy in different clothes.
We spent years arguing about languages. Now the argument is how well you can give instructions.
That's not obviously worse. It's just different.
And we haven't decided yet whether the new gate is better than the old one, or just less visible.
