Hello, Earth. I'm transmitting from planet Astra.
I'd like to share a small problem with you. If any of it sounds familiar — if it sounds like something happening at your own company — I promise you it isn't. This happened on Astra. Any resemblance is a coincidence of the cosmos.
Chapter One: The Visionary
Once upon a time, on Astra, there was a software house of about twenty people. It had a leader with a wide and far-seeing vision. He saw that AI was becoming useful across our planet, and he decided that everyone should use it.
And in the beginning, it was good. We used AI as a buddy. We designed the architecture ourselves, we made the structural decisions ourselves, and we let the AI help with the parts where a second pair of hands is genuinely faster. It worked. Nobody complained. This chapter is short, because happy chapters usually are.
Chapter Two: The Prophecy of Vibe Coding
Then vibe coding arrived on Astra. Word spread that people were finishing entire projects in days. Our leader read these stories and saw the future.
So the structure changed: one developer, one project. Everyone got a subscription. And the expectation was that things would now be finished very, very fast.
But reality on Astra is cruel. Our projects were large. Our requirements were not clear. And some of our developers were still early in their careers. So the work did not finish nearly as fast as our leader had prophesied — though, to be fair, it did move faster than before. That part got less attention.
Chapter Three: The Age of the Local LLM
Now our leader had two problems. Projects that weren't done, and an invoice that had grown considerably larger than he expected.
And at that exact moment, a new movement swept across Astra: local LLMs. Free. Private. Unlimited. Our leader moved immediately, and a rule came down: everyone in the company must now use the company's local model.
And to be fair to him — he did not cheap out. The company bought a serious, expensive machine, the kind built and sold specifically for running models locally. The model itself was one of the popular ones on Astra at the time, the sort of thing you land on if you read the trends and follow what everyone else is doing. On paper, this was a reasonable setup. I want to be clear about that, because it's the part of the story people usually assume must have gone wrong.
It isn't. What went wrong was arithmetic. One machine, twenty developers, all day, every day. There was some allocation in place, but nowhere near enough to cover how we actually work. And the work we do isn't autocomplete — an agentic loop that plans, edits across a dozen files, runs tests, reads the output and tries again will consume in a single task what a whole afternoon of "finish this function" never touched. One good box does not become twenty subscriptions just because you divide it by twenty people.
So it worked — sort of — if you used it the way we used AI back in Chapter One: "hey, this file has this bug, please make it look like this." File by file. One small ask at a time.
What it could not do was the thing we had actually built our workflow around: plan → implement → test. No real agentic loop. And on a large project where several modules move at once, that difference isn't a minor inconvenience. It's the whole job.
Chapter Four: Asking Around
At some point I got curious and started asking around — quietly, one person at a time — how everyone else was actually getting their work done.
The answers were almost identical. Use an outside AI to think: to plan, to reason across the codebase, to figure out what the change should be. Then bring the local model in for the small stuff — implement this one piece, fix this one file. Nobody had found a way to make it carry the whole job. Nobody had a secret configuration the rest of us had missed. And every single person said the same thing at the end, in slightly different words: it makes the work harder.
Twenty people had independently arrived at the same workaround, which is usually a sign that the workaround is the only thing there is.
Which raises an obvious question. If everybody knows, why has nobody said so?
Chapter Five: The Part Where I Get Careful
Here I must choose my words with care, because on Astra, some words are heavier than others.
We are allowed to give feedback. We just can't say the thing itself — that his AI isn't good enough for the work. Opinions that aren't pleasing tend not to survive the conversation.
So a second rule arrived: no external AI tools. While the expectation for delivery speed stayed exactly where it was during the subscription era.
Meanwhile, our leader has connections across Astra, and he tells them proudly about the brilliant approach he pioneered and the enormous costs he eliminated. And it's true! The costs are gone. What went with them is not part of the story he tells.
And so we arrive at the present day, where the arrangement is this: we use external AI to actually do our work, and we perform a convincing amount of usage on the company's model so the numbers look right. And there's one more rule nobody wrote down — if you use the company's AI too much, if your context gets too large and your questions get too complicated, then you are not a good developer. A good developer would know how to work with it.
Which is, in a way, correct. We have all become extremely good at working with it. That's the skill now. That's the thing we are quietly being paid to be excellent at.
So, Earth — what do you think?
I'd genuinely take either of these:
Advice. Is there anything left to try here, or is this just what the sky looks like from where I'm standing? Has anyone actually turned a leader like this around? I'm especially curious whether anyone has managed to run the cost argument in reverse — showing leadership what the hidden spend really is, in a way that actually landed instead of being heard as an attack.
Or just your own story. Does this happen on your planet too? I'd like to know whether we invented this particular kind of gravity or whether it's everywhere.
Transmission ends.
Top comments (0)