I am a front-end developer. That is my main thing. JavaScript, TypeScript, component frameworks, state management, the DOM and all its quirks. I have spent years in this world and it is where I am most comfortable. If you need someone to build a reactive UI or argue about whether signals are better than virtual DOM diffing, I am your guy.
I am also a PHP developer. Have been for a long time. Back-end work, WordPress, Laravel, the lot. That is another core part of my toolkit that has served me well for years.
But here is the thing. If you asked me to ship something in Go or Rust tomorrow, I could do it. Confidently. Not because I have spent years mastering those languages, but because knowledge is more accessible now than it has ever been. AI tools, better documentation, instant answers to specific questions. The gap between knowing a language deeply and being productive in a new one has shrunk dramatically.
Ten years ago, ramping up on a new language took months. You had to learn the syntax, the idioms, the toolchain, the ecosystem, the deployment story, the debugging approach. Each language was its own universe with its own rules. You were on your own with a book and Stack Overflow if you were lucky.
Something has changed. The gap is closing. We are entering the era of the every developer.
The fundamentals transfer
Programming languages have converged more than people realise. The syntax differs, but the underlying concepts are increasingly shared. Functions, variables, loops, conditionals, error handling, async patterns, package management, testing frameworks. If you understand these deeply in one language, you understand them shallowly in most others. That shallow understanding is often enough to ship something.
Go has goroutines, JavaScript has async/await, Rust has async with tokio. Different implementations, same mental model. Once you grok concurrency in one language, the others click faster. Same with type systems. TypeScript taught me to think in types. That knowledge transfers directly to Rust, Go, even back to PHP now that it has proper type hints.
The patterns rhyme. A REST API in Express looks structurally similar to one in Go’s Gin or Rust’s Actix or PHP’s Laravel. Routes, handlers, middleware, request/response objects. The specifics change but the shape is familiar. You are not learning from scratch. You are translating.
Tooling has flattened everything
Modern tooling deserves most of the credit. Package managers that actually work. Build systems that handle the complexity. Language servers that tell you what is wrong before you run anything. Formatters that enforce style so you do not have to memorise it. Documentation that is searchable and usually accurate.
AI has accelerated this dramatically. I can ask Claude to scaffold a Rust project and get something that compiles. I can paste a Go error message and get an explanation of what went wrong. I can describe what I want in plain English and get working code in a language I barely know. The AI does not replace understanding, but it shortens the feedback loop from hours to minutes.
Deployment has flattened too. Docker means I do not need to know how to configure a production server for every runtime. I write a Dockerfile, push to a registry, and let the orchestrator handle it. The app could be written in anything. The deployment story is the same.
PHP counted for something all along
I have been writing PHP since the early 2000s. It is one of my strongest languages. For most of that time it was fashionable to mock PHP, and honestly some of the criticism was fair. The language had warts. The ecosystem could be inconsistent. Admitting you wrote PHP at a tech meetup was like admitting you still used Internet Explorer.
I kept writing it anyway because it worked. And all those years of PHP taught me server-side fundamentals that transfer everywhere. Request lifecycles. Database access patterns. Session management. Form handling. Authentication flows. Templating. Caching. All the boring stuff that every web application needs regardless of what language it is written in.
Modern PHP is genuinely good now. Type hints, attributes, enums, readonly properties, proper package management with Composer. It is not the PHP of 2005. The people still mocking it have not looked at it in a decade. But even the old PHP skills matter because they were never really about PHP. They were about building web applications. The language was just the vehicle.
Specialism still has value
I am not saying expertise is dead. Deep knowledge matters. Someone who has spent a decade writing Rust will write better Rust than I will. They will know the edge cases, the performance characteristics, the idiomatic patterns. When you need that depth, you need a specialist.
But most software does not need that depth. Most software needs to work, be maintainable, and ship before the heat death of the universe. For that, a competent developer who understands fundamentals and can pick up new tools quickly is often more valuable than a deep specialist in a single technology.
The era of the every developer is not about being the best at everything. It is about being good enough at most things. Good enough to ship. Good enough to iterate. Good enough to solve the problem in front of you with whatever tool makes sense, not just the tool you happen to know.
What this means
If you are early in your career, learn the fundamentals deeply. Do not just memorise syntax. Understand why things work the way they do. That understanding is portable. It will follow you from language to language, framework to framework, decade to decade.
If you are mid-career and feel locked into a single technology, you probably are not as locked in as you think. The skills transfer more than you expect. Pick a side project in a language you have never used and see how far your existing knowledge carries you. You might be surprised.
The walls between front-end and back-end, between web and systems, between scripting and compiled languages, they are all getting shorter. You can climb over them now. Some of us are just walking through the gaps.
I am a front-end developer. But I am also a developer who ships things in whatever language solves the problem. That distinction matters less every year.