This started off innocently enough, with Agile methodologies that sought to make individual developers easily replaceable. We're not talking about "easily replaceable" in the preventing-evil-sysadmins sense, where a single employee can hold the company hostage because they keep the details of their work a secret. With Agile methodologies, "easily replaceable" means not only automating the development process so that it can easily be taken over by a trainee, but even keeping two people performing the same development task ("pair programming") so that losing a developer to insult or injury is of no consequence. I don't intend for this to be read as a slam on Agile methodologies, just adding a bit of perspective for the labor side of the equation, for whom the benefits of Agile methodologies are less clear-cut (than they are for, say, management).
All well and good. But then something odd happened: the impatience of programmers to release code to the world -- which is a rather irresponsible urge, to be sure -- has resulted in programmers taking on more and more of the work that was previously assigned to specialists.
First came test-driven development. Tired of waiting for QA to clear your code? You can be your own QA department! Just write your own tests, prove to your own satisfaction that code works the way you think it should, and it's read for release!
Now, every programmer worth their salt tests their code regardless, and TDD has resulted in better testing tools (programmers, forced to use them, have now started to pay attention when writing them). But testing is not QA. For that matter, TDD is not testing. The rule is quite simple: the person who tests the code must not be the same person who wrote it. In other words, the person who signs off on some code as being product-ready or release-ready should be anybody but the person who wrote that code.
Next came NoSQL databases. Tired of waiting for that DBA to make your changes to the database? You can be your own DBA! Just ditch the RDBMS and use a key-value datastore! No waiting!
OK, so you lose referential integrity and ACID compliance, but for the kind of stuff you're storing (let me guess: user clicks) it doesn't really matter. You have also lost that domain expert whose entire job is to make sure you, the developer, didn't screw up the data or the database with some short-sighted decision intended to just make the damn code work.
So, you are now writing your own tests and maintaining your own database, as well as, you know, writing code. Well, so far it's only a 60-hour work week, and that's normal for start-ups, right?
Now we have devops. Tired of waiting for the sysadmin to push your code out to production? Impatient with the "official" versions of webservers or frameworks being half-a year behind cutting-edge? You can be your own sysadmin! Just set up everything you need as a container, then push that container to virtual hosting (er, sorry, the cloud) and you're good to go!
Alright, now you've lost the person whose job it is to make sure that everything works together, that all the security patches are in place, and that there hasn't been some gaping security hole introduced to the system because, hey, the developer can't be bothered to modify the default configuration of the software they're using -- after all, they're not a specialist in this sort of thing!
Starting to see a pattern here? Developer gets impatient when having to work with others. Developer comes up with a way around working with others. Developer brings more work upon themselves, introduces more bugs into the system, and ships lower-quality product. The developer loses, the customer/userbase loses, the formerly-employed specialist loses. The only person who gains from this is the employer: they get to pay fewer salaries, and they have somehow managed to convince some of the most highly-paid non-executive employees to work longer hours, which translates to lowering their effective wage.
There's a lesson buried in here somewhere. Learn to work with others. Accept that your timeline is not their timeline. And while you're waiting for them to get around to the work you need done, do what your father and your grandfather did in your position: knock off early for a beer.
