Very interesting article. As a developer that has focused on writing more code than the infrastructure and tooling, I can definitely see the benefit to a product existing that allows everything to work together more seamlessly because on the surface everything we need to do it already exists. Something like glue code we could drop in or like you mentioned the whole integrated environment. I didn't realize how specific and difficult it was to do something like this, maybe it's not that we should have deployable option, but that technology could get to a point to where maybe implementing and deploying this could be worth it as you could get more value than effort it takes to implement on a per company basis so companies besides Google and other big tech companies can operate like this.

I like the points made in the article. I hate this overloading of the term.

I just could not disagree more.

This kind of rigid, singular view of operational workflows based on precomposed automations not only constantly break but also inevitably introduce huge inefficiences.

I posted a longer comment on lobste.rs: https://lobste.rs/s/azpsqe/vertical_integration_is_only_thin...

This article made me laugh and cry at the same time. I've spent so much time in my career trying to make things nice and seamless only to see my own team members throw out my careful work for something newer, shinier, and shittier. I was on a team that used Bazel. Like two devs took the time to figure out how it worked, everybody else just either worked around it or complained endlessly about it.

I am now thoroughly convinced that software engineers, if there is currently no snake whispering in their ear to throw away the paradise garden they're been handed on high, will find a way to do it anyway. Coders will, to the last, prefer self-inflicted misery over the heaven they've been gifted for free.

And if you don't believe me, let me tell you we already have a fully-vertically integrated tool stack, a whole family of them. It's called Smalltalk, it's been around since the 70s, and modern variants of course exist. You can build stuff in it today, and thoroughly enjoy your computing life as a result.

The second you turn your head though, your fellow teammates will conspire to replatform onto Go or Rust or NodeJS or GitHub Actions and make everything miserable again.

Don't buy the nonsense that vertical integration is hard. It's not. You just hire really sharp folks, get them excited about the idea, and they do all the hard integration work, then you release it to the community and let them build on it. Rails was like this back in the 2010s, there was this golden age where everything just worked. Then all of a sudden javascript took over the web world like cancer and the web stopped being fun.

It's not that it's hard, what it is is brittle. A vertically-integrated stack, by its very nature, cannot survive forces that jostle it in the horizontal direction. And coders are too afraid of falling behind that they end up fetishizing any new idea that comes along, no matter how daft. Javascript on the server?!?! Your solution to js's, let's call them problems, is gradual typing? That snake's never gonna run out of ears to whisper in, lemme tell ya.

Integrated toolsets can, have, and are still being done. You can use them now. But you don't want it. Even if you do, nobody you work with will trust it or keep it after you leave. And so companies have no motive anymore to sell them to you. Microsoft themselves stopped trying after 2019.

You can at least get (3) for low/no cost with pre-commit hooks running locally and in CI.

Unfortunately, I have to disagree.

On the one hand, the scenarios described by "vertical integration" sound like a paradise to use.

On the other hand, in real life it's going to far too complex, far too brittle, and ultimately unworkable.

Tool boundaries exist for a good reason -- so you can swap tools in and out easily, and the toolmakers can stay sane by focusing on doing one thing well. With vertical integration, nothing is swappable, because you can only use tools built for your specific architecture. You become isolated from the broader ecosystem, and locked into one.

And then, that architecture is going to be this bespoke thing that becomes so enormously complex and hard to work with that everybody just gives up. Because every time somebody wants to change a tool, it turns out to be 10x more work to figure out how to make the change work with this vertically-integrated architecture.

Vertical integration isn't the "only thing that matters". Flexibility and swappability matter too, as does saving time and money by following common industry technologies and not inventing a bunch of custom architecture if it's not your core product and not absolutely necessary.

Vertical integration matters when you are your own major customer on a process that isn’t already done at scale somewhere else with no reason to change.