Generated on July 02, 2026 at 16:14 UTC
Technology firms are grappling with the rapid commoditisation of prototypes as dominant platforms absorb and replicate emerging ideas, underscoring mounting pressure on smaller developers and shifting dynamics in software innovation.
ALL THE VIBES
ISSUE 18 · JULY 1, 2026
Mark Rowe came back from a project this week, looked at four months of his own work, and realized the platform had quietly done all of it, better.
Mark Rowe came back from a project this week, looked at four months of his own work, and realized the platform had quietly done all of it, better. GitHub Copilot now talks to the CLI he wrote in the spring. LiteLLM does the local model facade he had been building, with a team of fifty behind it. "All this, everything I've done, somebody else has now done better," he said on Friday. "And I have that whole Simpsons did it moment."
That is the question this week kept circling, from two directions. Three weeks ago, in "The Bill Came Due," the problem was how to stop token costs from growing. This week it flipped. Not how to spend less, but how to prove the spend was worth it, and harder, how to know what is even worth building when the platform keeps catching up. Our most recent issues have gone from structure, to scaffolds, to cost, to trust. This week the constraint is judgment.
Tuesday's Hack & Furious turned tokens into a daily budget line. Ahmar Kazi described a customer out east where a security gap assessment skill, nothing exotic, ran exactly twice before it hit the wall. "It's basically a $19 a month credit that they're giving out per user," he said at Hack & Furious on June 23. The skill was not burning millions of tokens on clever reasoning. It was carrying the entire workspace as context on every call. David Crawford took the same constraint somewhere stranger: a four day sprint on a banking engagement that ran out of tokens but mapped an environment the customer had not understood in years (more on that under the hood). Underneath both stories sat the same question: not what tokens cost, but what the work was worth, and how you would ever measure it. When someone in the room pushed on exactly that, asking what the dollars and the productivity numbers actually were, David named the hard part himself. "The problem is that rescuers have always done better than preventers," he said. Prevention is real value, and almost impossible to count.
Friday turned the question on building itself. Mark Rowe's supersession moment set the tone, but the room refused to let it land as defeat. Ken Hiatt reframed it: "I finally figured out that code I write is meant to be thrown away at some point." Derek Williams went further, talking directly to Mark. "It's sort of like you're building the highway. And then when you finish the highway, all of a sudden, now you're going really fast." The full arc, and what Mark did with it, is this week's Workbench.[1]
REFERENCES
The unglamorous truth behind David Crawford's "month in four days" is that the win was not speed. It was traversal. The customer had spent several years unable to keep a clear picture of their own deployment system. David pointed AI at the sprawl: 20 pipeline stages, more than 150 repos, dependency analysis across all of it, "where it's hot, where they're working." What fell out was a hard coded Defender identity buried in the pipeline. If a key rolled over, the customer went down hard. He left behind an HTML roadmap showing the whole environment, and as he put it at Hack & Furious on June 23, "they also didn't get to say, you don't understand our environment, because I left understanding it better than they did." The hidden cost is in the shape of the work. Delivery rhythm got chained to the quota reset, burn hard for four days, then negotiate for more access. The roadmap and the risk it surfaced now need an owner once the token rich person rotates off.
The hard part used to be building. This week Mark Rowe made the case that the hard part is now knowing what is worth building at all.
Mark is one of this community's most prolific builders. Over the spring he wrote a bridge so GitHub Copilot could talk to the CLI, a facade that made his local LLMs look like OpenAI endpoints, and a personal harness around Goal that planned, decomposed, and ran work across his own machines for days. Real solutions to real problems. Then he came back from a project and found the platform had absorbed nearly all of it. Copilot talks to the CLI now. LiteLLM does the facade, and as he put it at the Community Call on June 26, "they do it better, they've got a team of 50 people." His response was not to defend the work. "It's not frustration. It's purpose," he said. The rule he drew from it: "go see who solved this problem first." Because the real cost is not the building, it is the upkeep. "Everything that I make, I have to update," he said, and that maintenance is exactly what pulls a builder off the frontier.
This is not a Mark problem. It is the oldest pattern in the field, and the field has the receipts. BloombergGPT took nine people, a year, and 363 billion financial tokens, and within twelve months general models outperformed it on the same tasks.[1] The lesson practitioners keep relearning is that the model is not the product, the system around it is, so model specific custom work is the least durable thing you can invest in. Dan McKinley's "innovation tokens" put a budget on it: you get about three, so spend them on what actually differentiates you, not on infrastructure someone else will commoditize.[2] Will Larson's build versus buy framework adds the part most teams skip: internal tools get worse over time relative to an active vendor, because a small company cannot rationally keep investing to improve its own copy.[3] The counterpoint, for when building really is worth it, comes from Simon Willison: build it so it compounds, open source the solution, and you solve that problem once instead of every time you change jobs.[4]
The same judgment runs on the spending side, which is where Tuesday's tokenomics fits. Three weeks ago the question was how to stop the bill from growing. That question has a ceiling: you cannot save your way out, because cheaper tokens just get spent on heavier work. The better question is the one David Crawford kept circling, "it pays for itself." His four day sprint avoided an outage and replaced ten people's bootstrap with four hours of his own time. The trouble is that the tokens land on the bill and the value does not, which is why a unit like LCOAI, levelized cost per useful outcome rather than per token, matters more than another round of compression.[5]
Who owns all this on Wednesday? That is the hidden cost. Mark's retired builds and David's brilliant four day map both now need a maintainer, and the value both created needs to be written down somewhere it counts, or the next budget review treats it as pure spend. The scarce skill this week was not building, and it was not saving. It was judgment about what deserved either.
So here is a bet worth checking back on. By the end of the first quarter, expect at least one tool someone in this community built and demoed this quarter to be quietly retired because the platform absorbed it, a Copilot CLI capability, a LiteLLM style gateway, or Goal doing the job it used to, and expect the builder to say on a call that the rebuild would not have been worth it. The evidence is already here: Mark retired two builds this week for exactly that reason. If the bet turns out wrong, that is its own good news, it would mean custom community tooling is holding up better than the supersession anxiety suggests. Either way, we will know by the time Q1 closes.
REFERENCES
Before you build, search. Mark Rowe's whole post-mortem reduced to one rule: "go see who solved this problem first." Most of what feels like a missing tool is a missing search. Before you spend a week on a CLI bridge or a model facade, check the platform changelog, the gateway projects, and the community channel, because the half life of a custom integration is now measured in weeks. The cheapest build is the one the platform already shipped.
Second, route by difficulty, not by habit. Most queries do not need a frontier model, so the cheapest setup sends easy work to a small model and saves the expensive one for the genuinely hard cases. The newest evidence adds a warning worth heeding. LLMRouterBench, a January 2026 benchmark that re-ran the whole field across 33 models and more than 400,000 queries, found that elaborate routers often fail to beat a simple baseline, and that several commercial routers do not beat it either.[1] The win comes less from a clever router than from careful curation: pick two or three good models, route between them on difficulty, and stop, because larger ensembles show diminishing returns. Route by difficulty, just do not overthink the routing.
Third, once a path repeats, stop paying for it. When an LLM has discovered a workflow and you have run it a hundred times, convert it to deterministic code or a hook. Gareth Bland's rule from Tuesday: "if it can be a hook, it should be a hook." Mark Rowe's version: "code is still king." The cheapest token is the one you never needed to send.
Third, once a path repeats, stop paying for it. When an LLM has discovered a workflow and you have run it a hundred times, convert it to deterministic code or a hook. Gareth Bland's rule from Tuesday: "if it can be a hook, it should be a hook." Mark Rowe's version: "code is still king." The cheapest token is the one you never needed to send.
REFERENCES
Ahmar Kazi's $19 customer ran out of credit in two runs and was genuinely surprised. The surprise is the story, because the token bill behaves in ways that intuition gets wrong, and the broader field has started to model exactly why.
The first wrong intuition is that you control the spend. A cost transparency study this year shows you mostly do not: the model sets response length, not you, and even prompt politeness moves the token count without changing the answer's quality.[1] So the output side of the bill is only loosely in your hands, which is how a small skill burns a month's credit in two calls. The second wrong intuition is that cheaper tokens mean a smaller bill. The structural Jevons paradox, modeled rigorously this year, shows the opposite: as per token prices fall, teams reach for more compute hungry architectures, deeper reasoning, larger contexts, so aggregate demand climbs.[2] You cannot save your way out, which is why the community keeps landing on the same conclusion from two directions. The fix is not spending less. It is making the value of the spend legible enough to defend.
REFERENCES
Ahmar Kazi's locked-down customer (a $19 monthly credit, VDI, no normal Copilot access) was the week's sharpest example of a real delivery blocker. If you have found a way through, context hygiene, bringing your own tooling, porting dev work back in, post it in the channel. This is the practical problem the community is closest to solving together. (internal) * THE JUNE 26 COMMUNITY CALL RECORDING IS UP.
Mark Rowe's supersession reflection and David Crawford's agent to agent training buddy demo are both worth watching in full. (internal) * OFFICE HOURS: COPILOT AND VS CODE.
The recurring session lives at aka.ms/copilot-vscode-on-teams. Good for working questions you would rather ask live than search for. * NEW HERE?
Join All The Vibes at aka.ms/AllTheVibes. Tuesday's Hack & Furious and Friday's Community Call are the two heartbeats.
A levelized cost metric for AI, borrowed from how the energy industry prices electricity, that finally gives you a unit for "did the spend pay off." * LLMRouterBench: A Massive Benchmark and Unified Framework for LLM Routing.
The January 2026 reality check on model routing: 33 models, 400,000 queries, and the finding that fancy and even commercial routers often fail to beat a simple baseline. Curate a few models, route on difficulty, skip the hype. * LiteLLM on the Thoughtworks Technology Radar.
The clearest vendor neutral explainer of why the OpenAI compatible gateway became the default, including the honest trade offs. The exact tool that superseded Mark's facade. * Choose Boring Technology.
The "innovation tokens" essay that gives you the vocabulary for the supersession problem: spend your scarce novelty budget on what differentiates, not on infra someone else will solve. * The Rage Clicks of LLM Apps.
A working playbook for production eval: a broken LLM response throws no exception, so you build narrow, binary, action tied event detectors instead of averaging vague "helpfulness."
The week ended on a genuine disagreement, and it is worth leaving open. Mark Rowe, fresh off retiring his own builds, landed on restraint: "code is still king, I don't need an LLM in every single one of my applications." Write less probabilistic code, lean on the deterministic stuff that does not need a model at all. David Crawford pulled the other way. To him, "software engineering at scale is a distributed compute problem and orchestration," and the worthwhile frontier is building the generated systems the platform has not reached yet.
Both are right, which is the problem. This week's open question: is the next worthwhile work writing less probabilistic code, or building the generated systems the platform has not caught up to? Bring it Tuesday.
— The All The Vibes Team
Gareth Bland · Vahid Rostami · Stephanie Schofield · Rajesh Singh · Shyam Sridhar · David Torres Bejarano
Written with AI assistance.