The Software Quality and Productivity Crisis Executives Won’t Address
Reflections From the Long View – 50 Years in Software Consulting
Over my five decades in software consulting, I’ve witnessed remarkable transformations in our industry—from punch cards to cloud computing, from mainframes to microservices to AI coding. But in the past few years, I’ve observed something deeply troubling: a significant decline in interest in—and concern over—both software quality and productivity.
At first, I dismissed it as the bias of age. Perhaps I was simply romanticising the past. So I did what any good consultant does: I looked for data to either validate or refute my impression.
What I found was worse than I imagined. The decline is not only real and measurable—it’s being actively ignored by the very people with the power to address it. We don’t have a technology crisis. We have a leadership crisis—one that may require us to embrace #NoLeadership and take matters into our own hands.
But here’s something that troubles me even more: I suspect that without a long-term perspective, folks might never have noticed this decline at all. If you’ve only been in the industry for five or ten years, the current state might seem normal. You might assume that 75% project failure rates, $1.52 trillion in technical debt, and 69% of developers losing significant time to inefficiencies is simply “how software development works.” It isn’t. It’s how software development has deteriorated under leadership neglect.
The Crisis in Numbers
Let me establish a baseline. Recent industry surveys reveal:
- 75% of business and IT executives expect their software projects to fail (Beta Breakers, 2024)
- Only 39% of projects actually meet success criteria (Beta Breakers, 2024)
- Technical debt in the US reached $1.52 trillion in 2022 (Consortium for Information & Software Quality, 2022)
- 69% of developers report losing 8+ hours weekly to inefficiencies—20% of their time (Atlassian, 2024)
- 91% of CTOs identify technical debt as their biggest challenge (STX Next, 2023)
That last statistic is crucial. Hold onto it.
What Executives Know Privately
Internal surveys—the ones shared only amongst technology leadership—paint a clear picture of awareness:
According to the STX Next Global CTO Study, 91% of CTOs cite technical debt as their biggest challenge heading into 2024 (STX Next, 2023). Not second biggest. Not a concern. Their biggest challenge.
A 2024 survey by Morning Consult and Unqork found that 80% of business and technology leaders acknowledge that technical debt causes delays, cancelled projects, and higher costs (Oliver Wyman, 2024).
McKinsey research shows that CIOs estimate technical debt amounts to 20–40% of the value of their entire technology estate, and some 30% of CIOs surveyed believe that more than 20% of their technical budget ostensibly dedicated to new products is diverted to resolving issues related to tech debt (McKinsey & Company, 2023).
Protiviti’s Global Technology Executive Survey found nearly 70% of organisations view technical debt as having a high level of impact on their ability to innovate (Protiviti, 2024).
The message is unambiguous: executives know.
What Executives Do About It
Here’s where the story becomes damning.
Industry research consistently recommends that companies allocate 15–20% of their IT budgets to proactive technical debt management. According to Oliver Wyman’s 2024 analysis, only a small minority of companies actually earmark this recommended amount (Oliver Wyman, 2024).
Instead, most organisations don’t tackle technical debt until it causes an operational meltdown. At that point, they end up allocating 30–40% of their budget to massive emergency transformation programmes—double the recommended preventive investment (Oliver Wyman, 2024). It’s like Y2K again and again.
Let me put this plainly: executives know the problem, know the solution, know the cost of prevention, yet consistently choose to wait for the crisis.
But it gets worse.
The Priority Charade
I examined CIO priority surveys from 2022–2024 across multiple sources. Here’s what consistently makes executives’ top 5 priorities:
- Cybersecurity
- AI/GenAI adoption
- Digital transformation
- Cloud migration
- Cost optimisation
Here’s what’s conspicuously absent:
- Software quality
- Developer productivity
- Technical debt remediation
- Testing (QC) and QA investment
Despite 91% of CTOs citing technical debt as their biggest challenge, it doesn’t make the top five priorities in any major CIO survey from 2022–2024.
Think about that disconnect. The thing keeping CTOs awake at night doesn’t even warrant a place in their stated priorities.
The Public Deception
The gap between private knowledge and public communication is where this crosses from negligence into active deception.
I reviewed annual reports and earnings call transcripts from major technology companies for 2023–2024. Here’s what CEOs told shareholders:
Microsoft’s CEO claimed GitHub Copilot increases developer productivity by ‘up to 55%, whilst helping them stay in the flow and bringing the joy back to coding’ (Microsoft, 2023).
Google boasted that ‘more than a quarter of all new code at Google is generated by AI’ (Clouded Judgement, 2024).
Amazon, Meta, and other tech giants celebrated AI productivity gains and record revenues in their annual reports.
Now here’s what these same executives didn’t mention in their shareholder communications:
- The 75% project failure expectation that their own industry acknowledges
- The $1.52 trillion in technical debt
- The 69% of developers losing 8+ hours weekly to inefficiencies
- The fact that only 39% of projects meet success criteria
- The 91% of CTOs who cite technical debt as their top concern
I read through annual shareholder letters from JPMorgan Chase, Caterpillar, Chubb, Microsoft, and SoftwareOne. Not one CEO mentioned software quality concerns, technical debt, or developer productivity issues in their 2023–2024 letters to shareholders.
Not. One.
The Productivity Paradox
This creates a particularly egregious contradiction. Microsoft trumpets 55% productivity gains from AI tools in earnings calls (Microsoft, 2023). Meanwhile, independent research shows:
- 69% of developers lose 8+ hours weekly to inefficiencies (Atlassian, 2024)
- Only 20% of professional developers report being happy with their jobs (Stack Overflow, 2024)
- Tech worker burnout jumped from 49% to 68% in just three years (Techotlist, 2024)
- Developer productivity is neither well-understood nor enabled, according to Atlassian’s research (InfoWorld, 2024)
So which is it? Are developers 55% more productive, or are they losing 20% of their time to inefficiencies and burning out at record rates?
The answer: executives are measuring—and reporting—what makes their stock price rise, not what’s actually happening on the ground.
The Investment That Never Happens
Perhaps the most damning evidence is in the budgets. McKinsey’s research identifies the solution clearly: proactive technical debt management through consistent investment (McKinsey & Company, 2023). Deloitte’s 2024 Tech Trends report notes that leading companies target 15% of IT budgets for technical debt management (Deloitte, 2024).
Yet Oliver Wyman’s analysis found that only a small minority of companies actually allocate this recommended amount. The majority wait for crisis, then spend 30–40%—double the preventive cost (Oliver Wyman, 2024).
It’s the equivalent of knowing your building needs foundation repairs, having engineers tell you it will cost £100,000 now or £250,000 after collapse, and choosing to wait for the collapse.
Except we’re not talking about one building. We’re talking about the entire industry making this choice simultaneously.
The Trend Is Accelerating—And Why It Takes Decades to See It
The executive action gap isn’t static—it’s widening. Between 2020 and 2024:
2020–2021: The pandemic forced rapid digital transformation. Organisations rushed to cloud, creating massive technical debt. Software supply chain failures accelerated by 650% (Consortium for Information & Software Quality, 2022).
2021–2022: Rather than addressing the debt created, executives doubled down on speed. Cybercrime losses from software vulnerabilities rose 64% in 2020–2021, then another 42% in 2021–2022 (Consortium for Information & Software Quality, 2022).
2022–2023: 72% of organisations reported falling behind in digital transformation because of technical debt, with rushed cloud transitions cited as the primary cause (ReadyWorks, 2023).
2023–2024: Instead of addressing mounting technical debt, executives shifted focus to AI. For the first time, AI and Machine Learning vaulted to #2 in executive priorities, having not appeared in the top five the previous year (Evanta, 2024).
At each stage, executives had the data. At each stage, they chose the next shiny object over addressing fundamental problems.
Here’s what troubles me: if you started your career in 2019 or 2020, this accelerating decline is all you’ve ever known. You entered the industry during the pandemic rush, when corners were being cut at unprecedented rates. You’ve never experienced a development environment where quality was genuinely prioritised, where technical debt was proactively managed, where 75% project failure wasn’t expected.
You might think this is normal.
It’s not. In the 1990s and 2000s, whilst projects certainly failed and technical debt existed, there was a prevailing culture that quality mattered. Teams pushed back on unreasonable deadlines. Architects had authority to insist on sound technical decisions. “Technical debt” was something you reluctantly accumulated and felt obligated to address, not something you casually accepted as inevitable.
The shift has been gradual enough that it’s nearly invisible year-to-year. But viewed across decades, it’s stark. We’ve normalised dysfunction.
This is why long-term perspective matters. Trends that seem acceptable in isolation become alarming in context. A developer who’s experienced 15 different organisations over 30 years can see patterns that someone at their first or second company cannot. The boiling frog doesn’t notice the temperature rising. Those of us who remember when the water was cooler do.
The CrowdStrike Crystallisation
On 19 July 2024, a single CrowdStrike update crashed 8.5 million Windows machines globally, grounding flights, disabling emergency services, and causing an estimated $10 billion in damage. The root cause? A missing array bounds check—Computer Science 101 error handling that nobody implemented (Trendy Tech Tribe, 2025).
This wasn’t sophisticated. This was basic software craftsmanship that failed at every level of the deployment pipeline.
Three months later, in October 2024 earnings calls, did executives mention this as a wake-up call about software quality? Did they announce new quality initiatives?
No. They continued celebrating AI productivity gains whilst CTOs privately listed technical debt as their #1 concern.
What struck me most about the CrowdStrike incident wasn’t that it happened—any system can have bugs. What struck me was the industry’s reaction: brief panic, followed by… nothing. No industry-wide soul-searching. No renewed focus on basic software quality. Just a continuation of the same practices that led to it.
Twenty years ago, an incident of this magnitude would have triggered genuine introspection. Now? It’s Tuesday.
That normalisation of failure is what long-term perspective reveals. It’s not that we’ve stopped noticing problems—it’s that we’ve stopped being concerned about them.
What This Reveals About Executive Leadership
After 50 years in this industry, I can state with confidence: we are witnessing a systematic failure of executive integrity.
Executives aren’t ignorant. They have the data. They commission the surveys. They attend the conferences where CTOs present their concerns. They know that:
- 91% of CTOs cite technical debt as the biggest challenge
- 75% of projects are expected to fail
- 69% of developers lose significant time to inefficiencies
- Only 39% of projects meet success criteria
- The recommended 15–20% investment in technical debt management yields better long-term returns than crisis spending
Yet they choose:
- Not to allocate recommended budgets for technical debt management
- Not to make quality a strategic priority despite CTOs’ and developers’ concerns
- Not to mention these challenges in public communications to shareholders
- To celebrate AI productivity gains whilst developers report record inefficiency
- To focus on the next hype cycle (AI) rather than address fundamental problems
This isn’t a failure of knowledge. It looks to me like a failure of courage and integrity. A failure of the very concept of leadership.
Why Executives Choose Inaction
The calculus is simple and cynical:
Short-term wins are rewarded. Announcing AI adoption, digital transformation, and cost cutting drives stock prices up. Announcing a 15% budget allocation to technical debt management does not.
The crisis is slow. Technical debt doesn’t cause immediate, visible collapse. It degrades gradually. By the time it causes catastrophic failure, the executive who created it has often moved on. The average tenure of a Fortune 500 CEO is less than 8 years (and median in 2022 was 4.8 years). Why invest in quality improvements that won’t pay dividends until you’re long gone?
Metrics are gamed. Report AI productivity gains whilst ignoring developer efficiency losses. Celebrate revenue growth whilst hiding project failure rates. Show cost optimisation whilst deferring necessary maintenance.
Accountability is absent. No executive has faced consequences for the $1.52 trillion in technical debt. No CEO has been fired for the 75% project failure rate. No board has demanded answers for why only 39% of projects meet success criteria.
Historical memory has faded. Here’s where long-term perspective becomes crucial: many current executives have never worked in an environment where quality was genuinely prioritised. They entered leadership during the “move fast and break things” era. They’ve optimised their entire careers for velocity over sustainability. They literally don’t know what they’re missing. (See also: the Software Crisis – since 1968)
The system rewards those who optimise for optics over outcomes—and increasingly, it’s selecting for leaders who’ve never experienced anything different.
The Cost of This Failure
Whilst executives optimise for quarterly earnings, the real costs accumulate:
Financial: The US alone spends $2.41 trillion annually on poor software quality, with $1.52 trillion in technical debt (Consortium for Information & Software Quality, 2022). By waiting for crisis instead of investing preventively, companies spend double the recommended amount.
Human: 83% of developers experience burnout (Haystack Analytics, 2021). For the first time ever, senior developers report lower job satisfaction than juniors (Stack Overflow, 2024). The industry is haemorrhaging experienced talent—the very people who remember when things were different and might push for change.
Innovation: With 30% of IT budgets consumed by technical debt management and 20% of developer time lost to inefficiencies, there’s little capacity left for actual innovation.
Security: Software supply chain failures increased 650% between 2020 and 2021 (Consortium for Information & Software Quality, 2022). Cybercrime losses continue accelerating. Each shortcut creates new vulnerabilities.
Trust: When executives celebrate productivity gains whilst developers report record inefficiency, when they commission CTO surveys showing 91% cite technical debt as their top concern yet never mention it to shareholders, they erode trust throughout the organisation.
Institutional Knowledge: Perhaps most insidiously, as experienced developers get sick of the eternal indifference and leave, we’re losing the people who remember that it didn’t use to be this way. Each generation of new developers enters an environment slightly worse than the one before, with no reference point for what’s been lost.
The Case for #NoLeadership
Here’s what five decades in this industry has taught me: waiting for executive leadership to fix this crisis is futile. They know what needs to be done. They choose not to do it.
Perhaps it’s time we stop waiting for them.
#NoLeadership isn’t a complaint—it’s a philosophy. It’s the recognition that real change in software quality and productivity won’t come from boardrooms optimising for quarterly earnings. It will come from engineers, developers, and teams who decide to take ownership themselves.
But there’s a challenge here, especially for those without long-term perspective: if you’ve never experienced a development environment where quality was prioritised, how do you know what to fight for? If you entered the industry in the past 5-10 years, you might genuinely believe that constant firefighting, accumulating technical debt, and 75% project failure rates are just “how software works.”
They’re not. And #NoLeadership starts with understanding that the current state isn’t inevitable—it’s a choice we’re collectively making. A choice we can unmake.
Consider what happens when we embrace #NoLeadership:
Teams set their own quality standards. Don’t wait for executives to prioritise quality. Build it into your definition of done. Make technical debt visible on every sprint board. Refuse to call something “done” that you wouldn’t be proud to support.
Engineers allocate their own time. If leadership won’t dedicate 15% of budget to technical debt, developers can dedicate 15% of their sprint capacity. One day per sprint. Non-negotiable. Not asking permission—just doing it.
Quality becomes a team responsibility. Stop escalating quality decisions upward. If your team knows a codebase needs refactoring, refactor it. If tests are missing, write them. If documentation is lacking, create it. Own your craft.
Transparency replaces theatre. Track real metrics: hours lost to technical debt, actual bug rates, time spent on rework, developer satisfaction. Make them visible. Not to shame anyone, but to make the invisible visible.
Peers hold each other accountable. Code reviews become about long-term maintainability, not just immediate functionality. Pull requests that create obvious technical debt get challenged. Not by managers—by peers who know they’ll inherit the mess.
We share stories of how it used to be—and could be again. Those of us with long-term perspective have a responsibility to tell younger developers that the current dysfunction isn’t normal. To share what sustainable software development looks like. To paint a picture of what they’re entitled to demand.
This isn’t anarchism. It’s professionalism. It’s recognising that waiting for executives to prioritise what they’ve demonstrated they won’t prioritise is a losing strategy.
What #NoLeadership Looks Like in Practice
I’ve seen pockets of this emerging organically:
The team that implemented “Tech Debt Tuesdays”—dedicating every Tuesday to addressing technical debt, regardless of what management priorities were set. Their velocity appeared to drop 20%. Their actual productivity—measured in sustainable output and reduced rework—increased significantly.
The engineers who created a “Technical Debt Registry”—documenting every shortcut, every deferred refactoring, every known issue. Made it public within the organisation. No permission asked. Just transparency about what was really happening.
The developer who started tracking “Time to Real Done”—measuring not when a feature shipped, but when it was actually stable, tested, documented, and maintainable. Shared the data widely. Made it impossible to ignore the gap between “shipped” and “done.”
The teams adopting “Two-Track Development”—running parallel tracks for new features and quality improvement. Not asking whether they could dedicate time to quality. Just doing it as part of their professional responsibility.
The teams embracing the Antimatter Principle—attending to folks’ needs as a matter of course.
The senior developers who mentor juniors on what sustainable development looks like—not by lamenting “the old days,” but by teaching practices and standards that newer developers never learned because they entered an industry already in crisis.
These aren’t acts of rebellion. They’re acts of practitioners’ integrity. They’re what happens when craftspeople decide that waiting for permission to do good work is itself unprofessional.
And critically, they’re how we preserve and transmit knowledge of what sustainable software development looks like—creating reference points for those who’ve never experienced it.
The Limits and Risks
Let me be clear: #NoLeadership isn’t a panacea, and it comes with real constraints.
You can’t allocate budget you don’t control. Teams can manage their own time, but they can’t approve capital expenditure for infrastructure improvements or hire additional staff.
You may face consequences. Some organisations will punish teams who prioritise quality over velocity metrics, even when that quality improves long-term outcomes. Career risks are real.
Coordination remains necessary. #NoLeadership works for team-level quality decisions. System-wide architectural changes still require coordination that often needs executive sponsorship.
Not everyone will join you. Some teams will continue optimising for the metrics management rewards. You may end up maintaining higher quality in isolation whilst surrounded by deteriorating systems.
Without historical context, it’s hard to know what’s worth fighting for. If you’ve never seen sustainable development practices in action, how do you know which battles matter? This is where mentorship and knowledge sharing become crucial.
These limitations matter. #NoLeadership can’t replace executive action—it can only compensate for executive inaction within the sphere teams actually control.
But here’s what it can do: it can prevent your team’s work from contributing to the crisis. It can create islands of quality in seas of technical debt. It can demonstrate that another way is possible. And it can preserve your own professional integrity whilst the industry around you optimises for quarterly earnings.
Most importantly, it can create reference points. When a junior developer experiences your team’s practices—where quality matters, where technical debt is managed, where 75% failure isn’t expected—they learn what’s possible. They gain perspective that might take decades to acquire otherwise. They become carriers of institutional knowledge about what sustainable software development looks like.
That’s how cultures change: one team at a time, creating examples that others can point to and say, “That’s what we might be doing.”
A Challenge to the Industry
To executives reading this: the data is unambiguous. You know what needs to be done. The question is whether you’ll do it, or whether your teams will be forced to work around your inaction.
To CTOs and technology leaders: if 91% of you cite technical debt as your biggest challenge, why doesn’t it appear in executive priorities? Stop keeping your concerns private. Make them public. Make them impossible to ignore. Risk it.
To senior developers and engineers with long-term perspective: You have a special responsibility. Share your experience. Mentor those who’ve never known anything but crisis mode. Paint a picture of what sustainable development looks like. Your historical perspective is valuable—use it to help others understand that the current state isn’t inevitable.
To developers and engineers: you don’t need permission to do good work. You need the courage to prioritise it even when incentives push you toward shortcuts. #NoLeadership a.k.a. #Fellowship means taking ownership of quality within your sphere of control.
To those new to the industry: If you’ve entered software development in the past 5-10 years, I invite you to consider something crucial: the environment you’re in—the constant firefighting, the technical debt, the 75% failure rates—this isn’t “just how software development works.” It’s how software development has deteriorated. Seek out the older developers, the ones who’ve been doing this for decades. Ask them how things used to be. Learn what you’re entitled to demand.
To teams: you can start today. Dedicate 15% of your sprint to quality. Make technical debt visible. Track real metrics. Hold each other accountable. Don’t wait for executive prioritisation that isn’t coming.
The Path Forward
After 50 years, I’ve learned this: sustainable software quality requires both executive commitment AND professional autonomy. Ideally, we’d have both.
But if we must choose between waiting for executive action that isn’t coming and taking professional responsibility for the work we control, I choose the latter.
#NoLeadership is about recognising when waiting for executive direction means accepting executive dysfunction. It’s about developer communities deciding that their craft matters more than their executives’ quarterly earnings optimisation.
The data shows executives know what needs to be done. They choose not to do it. Perhaps it’s time we stop waiting for them to change their minds and start changing what we can control.
Every sprint in which you dedicate time to quality is a choice. Every pull request you review for maintainability is a choice. Every piece of technical debt you document is a choice. Every standard you refuse to compromise is a choice. Every story you share about how development used to be—and could be again—is a choice.
Make better choices. Don’t wait for permission.
The industry won’t be fixed by executive leadership that’s demonstrated it won’t lead on quality. It will be fixed by teams who decide that professional integrity matters more than executive approval. By experienced developers who share their perspective with those who’ve never known anything different. By practitioners who refuse to accept that the current dysfunction is inevitable.
That’s #NoLeadership. Not a lament—a commitment to integrity.
And for those of us with long-term perspective, it’s also a responsibility: to notice the trends others can’t see, to remember what’s been lost, and to fight to restore what made this profession worth pursuing in the first place.
Are you practising #NoLeadership in your work? What quality standards have you set for yourself regardless of executive priorities? And if you’ve been in the industry long enough to see the trends—what changes have you noticed? Share your experiences in the comments.
Further Reading
Ali, J. (2024, June 4). 268% higher failure rates for Agile software projects, study finds. Engprax. https://www.engprax.com/post/268-higher-failure-rates-for-agile-software-projects-study-finds/
Atlassian. (2024, July 15). New Atlassian research on developer experience highlights a major disconnect between developers and leaders. Work Life by Atlassian. https://www.atlassian.com/blog/developer/developer-experience-report-2024
Beta Breakers. (2024). Software survival in 2024: 2023 statistics and quality assurance. https://www.betabreakers.com/blog/software-survival-in-2024-understanding-2023-project-failure-statistics-and-the-role-of-quality-assurance/
Clouded Judgement. (2024, November 1). Amazon, Google, Microsoft & Meta on AI and CapEx. https://cloudedjudgement.substack.com/p/clouded-judgement-11124-amazon-google
Consortium for Information & Software Quality. (2022, December 6). Software quality issues in the U.S. cost an estimated $2.41 trillion in 2022. Synopsys News. https://news.synopsys.com/2022-12-06-Software-Quality-Issues-in-the-U-S-Cost-an-Estimated-2-41-Trillion-in-2022
Cortex. (2024). The 2024 state of developer productivity. https://www.cortex.io/report/the-2024-state-of-developer-productivity
Deloitte. (2024). Tech trends 2024: Core workout—From technical debt to technical wellness. Deloitte Insights. https://www.deloitte.com/us/en/insights/topics/technology-management/tech-trends/2024/tech-trends-core-it-modernization-needed-for-tech-wellness.html
Evanta. (2024). Top 3 priorities for CIOs in 2024: 2024 Leadership Perspective Survey. https://www.evanta.com/resources/cio/survey-report/top-3-priorities-for-cios-in-2024
Haystack Analytics. (2021, July 12). 83% of developers suffer from burnout, Haystack Analytics study finds. https://www.usehaystack.io/blog/83-of-developers-suffer-from-burnout-haystack-analytics-study-finds
InfoWorld. (2024, July 15). Developer productivity poorly understood, report says. https://www.infoworld.com/article/2520803/developer-productivity-poorly-understood-report-says.html
McKinsey & Company. (2023, April 25). Breaking technical debt’s vicious cycle to modernize your business. McKinsey Digital. https://www.mckinsey.com/capabilities/mckinsey-digital/our-insights/breaking-technical-debts-vicious-cycle-to-modernize-your-business
Microsoft. (2023, October 25). Microsoft fiscal year 2024 first quarter earnings conference call. Microsoft Investor Relations. https://www.microsoft.com/en-us/investor/events/fy-2024/earnings-fy-2024-q1
Oliver Wyman. (2024, July). 5 actions to reduce technical debt in businesses. https://www.oliverwyman.com/our-expertise/insights/2024/jul/reducing-technical-debt.html
Protiviti. (2024). Technical debt remains a major burden. https://www.protiviti.com/us-en/global-technology-executive-survey-tech-debt-major-burden
ReadyWorks. (2023). 2023 CIO priorities: Overcoming challenges and making progress. https://www.readyworks.com/blog/2023-cio-priorities-overcoming-challenges-and-making-progress
Stack Overflow. (2024). Professional developers: 2024 Stack Overflow Developer Survey. https://survey.stackoverflow.co/2024/professional-developers
STX Next. (2023, November 14). STX Next report highlights the challenge of technical debt. Technology Magazine. https://technologymagazine.com/articles/stx-next-report-highlights-the-challenge-of-technical-debt
Techotlist. (2024). Tech burnout 2025: Digital overload. https://techotlist.com/blogs/programming-languages-and-development-trends/tech-burnout-2025-digital-overload
Trendy Tech Tribe. (2025, December 15). Why software is getting worse: The 2025 quality crisis. https://trendytechtribe.com/tech/software-quality-crisis-2025