razoorka

Five US AI labs held every advantage and spent it on distraction, fear pricing and internal purges, while China closed most of the gap under chip sanctions.

Spotify told investors that 99% of engineers use AI weekly. Their own engineering blog tells a different story about what that means.

This isn’t about innovation — it’s about metrics.

Sora 2 is the perfect example: a dopamine machine disguised as progress. It doesn’t solve real problems; it just creates endless engagement loops to inflate “usage” numbers for investors.

The identical logic drives AI erotica — maximize attention, claim it’s “user engagement,” and call it growth. When the core product stops evolving, they start monetizing loneliness.

It’s not about what people need, it’s about what still moves the charts.

Exactly! software is the only engineering discipline where failure has no liability and degradation has no visibility.

Bridges collapse once. Software collapses silently, one abstraction at a time. The incentives are inverted: short-term growth gets rewarded, long-term stability gets deprecated.

When there’s no physical consequence for failure, “good enough” becomes the design philosophy.

Completely agree, software’s “materials” haven’t improved, only the scaffolding around them.

We’ve industrialized the process without industrializing the discipline. The result is mass-produced code built on shaky abstractions, fast to assemble, and faster to decay.

Linux and curl weren’t built on sprints or OKRs. They were built on ownership, long time horizons, and the idea that stability is innovation when everyone else is optimizing for speed.

That’s spot on - and it’s amplified by how the market rewards velocity signaling over craftsmanship.

Teams are optimized for output volume, not outcome quality. Hiring pipelines favor those who can “ship fast,” while the systems they ship into grow exponentially more complex. The result: shallow competence at scale.

AI just poured fuel on it - it lets everyone look 30% more productive while compounding the same underlying brittleness.

Exactly! abstraction is the new bureaucracy.

Each layer promises efficiency but adds hidden coordination cost. Ten years ago, a web app meant a framework and a database. Now it’s React → Electron → Chromium → Docker → Kubernetes → managed DB → API gateway - six layers deep to print “Hello, world.”

Every abstraction hides just enough detail to make debugging impossible. We’ve traded control for convenience, and now no one owns the full stack - just their slice of the slowdown.

Exactly. “Tests pass” has replaced “software works.”

We measure coverage instead of correctness, and AI-generated tests just made it worse, they validate syntax, not behavior. The illusion of safety lets teams ship faster while silently compounding technical debt.

The real regression isn’t missing tests, it’s that we stopped thinking during them.

Good question. The difference is in scale and tolerance.

Crashes used to be localized, one app, one machine. Now a missing field in a config file can take down 8.5 million Windows systems globally. Spotify leaking 79GB of RAM isn’t a “bug,” it’s normalized waste.

The signal isn’t that bugs exist, it’s that catastrophic ones no longer trigger process change. We’ve accepted systemic failure as normal because hardware and cloud budgets hide the cost.

That’s fair, but the difference isn’t about whether we have linters or not. It’s about outcomes.

In the ’90s, inefficiency meant slower code. Today it means 32GB RAM leaks in calculator apps, billion-dollar outages from a missing array field, and 300% more vulnerabilities in AI-generated code.

We’ve automated guardrails, but we’ve also automated incompetence. The tooling got better, the results didn’t.

Yeah, the irony is that this is the only thing still propping up the U.S. economy. Real growth drivers are gone — manufacturing is flat, tech productivity has stalled, and GDP is now inflated by the promise of future AI miracles.

Companies aren’t creating new value; they’re monetizing hope — issuing debt against models that don’t yet work and counting that as “growth.” It’s not innovation anymore. It’s financial theater dressed as progress.

I did a several-month experiment using Claude as the only engineer on a real SaaS side project (Node.js/React, prod-quality, full feature ownership). My observations:

The quality of Claude’s output strongly correlates with how explicit and detailed the specs are. Markdown checklists, acceptance criteria, and clear task structure led to far fewer corrections and surprises.

Most mistakes were never “creative hallucinations” — just missed context or ambiguity in my own instructions.

The whole process felt less like delegation and more like tight collaboration. There’s less of a “flow state” and more context-switching to review/test, but review fatigue is manageable if you iterate on your instructions after each lesson.

No real learning from prior sessions, but persistent design docs and corrected example snippets in the prompts made a big difference.

Overall, a lot of the “vibe” factor gets smoothed out by rigorous process — not unlike mentoring a junior dev on a new domain.

For me, the speedup was very visible on well-scoped backend tasks and trivial CRUD/UI, and less so on broader, ambiguous work (designing APIs, coordinating many moving parts). The biggest upside: a clear process made both me and the tool better; the biggest “cost”: I spent a lot more time up front thinking through specs.

Not sure it fully scales (and I’m skeptical on agent “fleets”), but for a solo dev, given patience and a bit of PM discipline, it’s a net positive.

Pretty much. Strip away the AI narrative and there’s not much else driving growth right now - manufacturing’s flat, consumer spending’s slowing, and traditional tech margins are shrinking.

This artificial boom in “AI infrastructure” is basically the last engine keeping the charts pointing up. When that music stops, there’s nothing underneath it but leverage and power bills.

This whole thing looks like a bubble in slow motion.

A “non-profit” that somehow buys stakes, signs multi-billion supply deals, and moves markets based on promises of future models — all while technically owning nothing tangible. They’re leveraging their own paper value to buy more paper value.

It’s circular finance at scale: every deal increases the perceived valuation, which then becomes collateral for the next one. No audited revenue stream, no proven business model - just a loop of hype, compute contracts, and self-referenced worth.

At some point, someone’s going to ask what exactly is being sold here besides narrative.

Because growth always adds entropy.

Every new product, integration, or business line introduces new edge cases, dependencies, and coordination paths. What starts as a clean architecture turns into a network of overlapping constraints - legacy data formats, different latency expectations, regulatory quirks, “temporary” patches that become permanent.

You can manage complexity for a while, but you can’t eliminate it. Every layer that simplifies work for one team usually adds hidden coupling for another. Over time, the system stops being a single design and becomes an ecosystem of compromises.

It is. What you're describing is what used to be called financial velocity without value creation.

We're watching a cycle where companies raise, reinvest, and report "growth" that's mostly internal money circulation — cloud credits, infra leases, or pre-paid AI capacity deals that move cash between subsidiaries or friendly vendors. None of it produces new productivity; it just inflates asset books.

Big Tech's current AI spending is a perfect example. Microsoft, Google, Amazon, and Meta will spend around $364 billion on infrastructure this year — roughly double their historical capex ratios. Yet revenue growth in their core businesses is slowing. They're scaling faster than they can monetize, essentially subsidizing the appearance of progress.

The real red flag is cultural: when companies optimize for spend instead of outcomes, engineering starts following the same pattern — more abstraction, more compute, less efficiency. Eventually, both finance and technology hit physical limits.

If you're interested, I broke down the numbers and engineering side of this dynamic here: https://techtrenches.substack.com/p/big-techs-364-billion-be...

The gap between "AI is a 90% solution" and "100% required for production" is enormous. In my bubble, AI-generated code is maybe 70% useful, often less. The remaining 30% isn't minor polish—it's:

Understanding system architecture constraints Handling edge cases AI doesn't know exist Debugging when AI-generated code breaks in production Knowing when AI's "solution" creates more problems than it solves

That last 30% is what separates engineers from prompt writers. And it's not getting smaller—if anything, it's growing as systems get more complex.

I find it strange when programmers push the narrative that "we won't need to code anymore, just write in English."

If that's true, what's your value? You don't understand client needs better than a product manager. You don't have an exceptional product vision. You're essentially making yourself obsolete.

Your expertise currently lies in building systems, handling edge cases, optimizing performance, and avoiding technical debt. If that can be expressed in English prompts, anyone can do your job—PMs, analysts, business people.

A programmer who can't write code is just someone with ideas. There are millions of those, and they're worth $0. Programmers who cheerlead the idea that "90% of code will be AI-written" are digging their own graves. In 5 years, they won't be replaced by AI—they'll be replaced by people who can both code AND use AI effectively.

Exactly. It's an industry shift, and one person can't reverse it alone. But I disagree with "better something than nothing" when it comes to quality. That's how we normalized catastrophes in the first place. The lemon market problem you described is real—users can't evaluate quality, so price becomes the only signal. But engineers can evaluate quality. We're the ones who should refuse to ship garbage, even if management pushes back. Being grumpy works locally. It won't fix the industry, but it fixes your team. And when enough teams refuse to normalize this, the pattern shifts.

Thank you , I appreciate your advice

Look at Intel—an absolute monopoly for decades, everyone said they'd never fall. But they did. The government bailed them out with billions because they're "too important to fail." Apple is even bigger. When they start truly failing, governments won't let them collapse—too much infrastructure depends on them. But "not allowed to fail" doesn't mean "allowed to thrive." Intel is a zombie now—alive but not really competing. Apple will eventually become the same: massive, declining, propped up by governments, but no longer innovating. You're right—nobody falls anymore. They simply become permanently mediocre monopolies that extract rent while quality continues to degrade.

This is the core philosophical divide in modern software development.

The "vibe coding MVP" crowd treats code as disposable—ship fast, validate the idea, and discard it if it doesn't work.

The problem: most MVPs never get thrown away. They get customers, then funding, then "we'll refactor later" becomes "we can't afford downtime to refactor."

That's how you end up with production systems built on prototypes that were never meant to handle real load.

I'm with you: if you're not willing to build it properly, don't build it at all. Technical debt compounds faster than most founders realize.

The Twitter mob defends vibe coding because it worked once for someone. However, for every success story, there are thousands of companies struggling with unfixable codebases.

Do it right or don't do it. There's no "we'll fix it later" in production.

Exactly. That's why I wrote this—to confirm we're not crazy for noticing the pattern.

I wouldn't work at a place that doesn't value my perspective either. The problem is that most engineers realize this 6-12 months in, after they're already invested, and leaving means starting over. This is why "keep your head down to pay rent" becomes the default. The system is designed to make speaking up too expensive.

It began way more earlier then llm era, but yes , with llm it became even worse

I would prefer to pay 20% more for product which works perfectly, than for product which almost works. But no one asked me.

Oh, I see your point, I didn’t think from this angle