⚡ Quick Summary
- A widely-shared blog post argues that software engineering promotion systems structurally reward complexity creation over simplification, generating over 200 upvotes and 84 comments on Hacker News.
- AI-assisted coding tools like GitHub Copilot (used by 1.3 million paid subscribers) risk accelerating technical debt by enabling faster code generation without improving architectural judgement.
- Poor software quality cost US organisations an estimated $2.41 trillion in 2022, with a significant portion attributable to accumulated complexity and technical debt.
- Major platforms including Microsoft Azure (200+ services), AWS (31% cloud market share), and Salesforce exhibit the same complexity accumulation patterns seen in individual engineering teams.
- Organisations that want to address this must revise performance frameworks to explicitly measure and reward complexity reduction, not just feature delivery velocity.
What Happened
A blog post published on March 3, 2026, at terriblesoftware.org under the provocative title "Nobody gets promoted for simplicity" has ignited a fierce debate across the software development community, accumulating over 200 upvotes and 84 substantive comments on Hacker News within days of publication. The piece strikes at one of the most uncomfortable structural truths in professional software engineering: that organisational incentive systems consistently reward complexity over clarity, feature volume over architectural elegance, and visible output over invisible quality.
The article's central argument is deceptively simple. Engineers who ship sprawling, intricate systems with dozens of moving parts leave an obvious footprint — they can point to pull requests, architecture diagrams, and feature flags as evidence of impact. Engineers who spend weeks refactoring a 3,000-line module into 400 clean, well-tested lines of code often have very little to show in a performance review. The reduction of complexity is, by its nature, an act of subtraction — and subtraction rarely photographs well on a promotion packet.
The Hacker News thread that followed became a confessional of sorts, with senior engineers at companies ranging from mid-stage startups to FAANG-tier corporations sharing nearly identical stories: a meticulously simplified codebase dismissed as "not impactful enough," a performance review that praised a colleague for shipping a new microservices layer nobody asked for, or a staff engineer who spent a quarter eliminating an entire class of production incidents only to be told their work "lacked strategic visibility."
The timing of this conversation is not accidental. As AI-assisted development tools like GitHub Copilot, Cursor, and Amazon Q Developer dramatically accelerate the raw speed of code generation, the industry is confronting a new and urgent variant of this old problem: AI tools make it easier than ever to generate complex code quickly, but they do not inherently make it easier to know when to stop building.
Background and Context
The tension between simplicity and complexity in software engineering is as old as the discipline itself. Tony Hoare's 1980 Turing Award lecture warned that there are two ways to construct software: make it so simple there are obviously no deficiencies, or make it so complicated there are no obvious deficiencies. The second approach, he noted dryly, is far more common.
The organisational incentives problem has been documented across decades. Fred Brooks identified related dynamics in The Mythical Man-Month back in 1975, noting how adding engineers to a late project makes it later — a counterintuitive result that emerges from complexity accumulation. In the 2000s, the rise of Agile methodology was, in part, a response to bloated waterfall projects where complexity had been mistaken for thoroughness. The Agile Manifesto's emphasis on working software over comprehensive documentation was a direct pushback against the bureaucratic complexity tax.
The microservices revolution of the 2010s introduced an entirely new dimension to this problem. What began as a sensible architectural pattern for organisations like Netflix and Amazon — companies with genuine scale requirements that justified distributed systems overhead — was rapidly cargo-culted across the industry. By 2018, it was common to find five-person startups running 40-service Kubernetes clusters to serve a few thousand users, generating operational complexity that dwarfed the actual product complexity. Consultancy firms and cloud vendors had every commercial incentive to encourage this pattern: complexity sells contracts, training courses, and cloud compute hours.
The promotion incentive problem crystallised further as Big Tech companies formalised their engineering ladders during the 2015–2022 hypergrowth era. At Google, Meta, Amazon, and Microsoft, promotion to senior and staff levels increasingly required demonstrating "cross-functional impact" and "scope expansion" — language that, in practice, often translated to building new systems rather than improving existing ones. Internal studies at several of these companies, some of which leaked into industry discourse, suggested that engineers who owned greenfield projects were promoted at measurably higher rates than those who maintained or simplified existing systems, even when the maintenance work was objectively more valuable to the business.
Why This Matters
This is not merely an abstract philosophical debate about software craftsmanship. The systemic preference for complexity over simplicity has direct, measurable consequences for businesses, IT departments, and the professionals who manage enterprise technology stacks.
Consider the maintenance cost trajectory of a typical enterprise software system. Research from the Consortium for IT Software Quality (CISQ) estimated that poor software quality cost US organisations approximately $2.41 trillion in 2022 alone, with a significant portion attributable to technical debt — the accumulated cost of complexity decisions made for short-term convenience or visibility. Every unnecessary abstraction layer, every redundant service, every over-engineered configuration system represents a future support burden that falls disproportionately on IT operations teams rather than the engineers who built it.
For IT professionals managing Microsoft-centric environments, this dynamic plays out in particularly visible ways. Microsoft's own product portfolio is a fascinating case study in complexity accumulation. The evolution from Exchange Server to Exchange Online, from SharePoint on-premises to SharePoint Online, from Skype for Business to Teams — each transition carried forward years of accumulated feature complexity, often preserving legacy behaviours that few users needed but that removal would have broken existing workflows. The result is that Microsoft Teams, as of its 2024 and 2025 releases, supports a staggering array of configuration options, governance policies, and integration hooks that most organisations use a fraction of.
Organisations investing in affordable Microsoft Office licences for their workforce should be asking hard questions about which features they actually need, rather than defaulting to the most comprehensive tier because complexity signals thoroughness. The gap between what enterprises license and what they actively use represents a significant and largely invisible cost centre.
From a cybersecurity standpoint, the complexity problem is even more acute. The 2024 Verizon Data Breach Investigations Report found that a substantial proportion of successful breaches exploited misconfigurations — a category of vulnerability that grows exponentially with system complexity. Every additional integration point, every undocumented API endpoint, every legacy authentication pathway retained for backward compatibility is an attack surface. Security teams at organisations running highly complex software stacks spend disproportionate time mapping what they have rather than protecting it.
Industry Impact and Competitive Landscape
The implications of this debate extend well beyond individual engineering careers and into the strategic positioning of major technology platforms.
Microsoft finds itself in a particularly interesting position. Under Satya Nadella's leadership since 2014, the company has made genuine strides in developer experience — the acquisition of GitHub in 2018 for $7.5 billion, the development of Visual Studio Code into the world's most popular code editor (used by over 73% of developers according to the 2024 Stack Overflow Developer Survey), and the aggressive investment in GitHub Copilot all signal an awareness that developer productivity matters. Yet Microsoft's enterprise product surface area has expanded dramatically over the same period, with Azure now offering over 200 distinct services, many of which overlap in function and create decision paralysis for architects.
Google faces a similar paradox. Google Cloud Platform has historically been criticised for product discontinuation unpredictability — the graveyard of deprecated Google services is a long-running industry joke — but the company has also been more willing than competitors to sunset products that failed to achieve sufficient adoption, a form of enforced simplification that the market has not always appreciated.
Amazon Web Services, the cloud market leader with approximately 31% market share as of late 2025, has leaned hardest into complexity as a competitive moat. The sheer breadth of AWS services creates significant switching costs and generates a thriving ecosystem of consultants, certification programmes, and managed service providers whose livelihoods depend on that complexity persisting.
Salesforce, which has spent the better part of a decade acquiring companies (MuleSoft for $6.5 billion in 2018, Tableau for $15.7 billion in 2019, Slack for $27.7 billion in 2021) and integrating them into an increasingly sprawling Customer 360 platform, exemplifies the enterprise software complexity trap at scale. Organisations running full Salesforce stacks routinely report that configuration and customisation complexity consumes more ongoing resource than the core CRM functionality that justified the initial investment.
The emergence of "boring technology" advocates — a movement that gained significant traction following Dan McKinley's influential 2015 essay and has continued to resonate — represents a grassroots counter-current. Companies like Basecamp (now 37signals) have built entire product philosophies and market positions around deliberate simplicity, attracting customers who are fatigued by the operational overhead of more feature-rich competitors.
Expert Perspective
From an industry analyst standpoint, the terriblesoftware.org post and the conversation it generated represent a maturation signal in the software industry's self-awareness. The fact that a relatively short blog post can generate this level of resonance suggests the problem is widely felt and insufficiently addressed by existing organisational structures.
The AI-assisted development angle deserves particular attention. Tools like GitHub Copilot (which Microsoft reports is now used by over 1.3 million paid subscribers and integrated into workflows at more than 50,000 organisations) are genuinely transformative for code generation speed. But speed of generation without corresponding investment in simplicity discipline creates a dangerous asymmetry: teams can now accumulate technical debt faster than ever before.
The risk is that AI coding tools become complexity accelerants. A junior engineer using Copilot can generate a working but architecturally questionable solution in minutes that might previously have taken hours — hours during which a more experienced colleague might have intervened with a simpler approach. The tooling is outpacing the organisational wisdom needed to use it well.
Forward-looking engineering organisations are beginning to experiment with "simplicity metrics" — tracking lines of code deleted, dependency counts reduced, and incident rates attributable to complexity — as explicit inputs to performance evaluation. Whether this practice achieves mainstream adoption will depend heavily on whether engineering leadership at major technology companies signals that it matters. So far, the signals remain mixed.
For teams managing productivity environments on genuine Windows 11 deployments, the practical takeaway is to audit your software stack with the same critical eye: how many tools are genuinely used versus merely installed, and how much of your IT overhead exists to manage complexity that nobody consciously chose?
What This Means for Businesses
For business decision-makers and IT leaders, the conversation sparked by this article should prompt a concrete internal audit. The question is not whether your engineering team values simplicity in the abstract — almost everyone will say they do — but whether your promotion criteria, sprint velocity metrics, and project approval processes actually reward it.
Practically speaking, organisations should consider three immediate actions. First, review your engineering performance framework to determine whether it includes any explicit recognition for complexity reduction, technical debt elimination, or system simplification. If it does not, you are structurally incentivising the wrong behaviours regardless of what your engineering principles document says.
Second, conduct a software portfolio rationalisation exercise. Many enterprises are running redundant tools across overlapping categories — multiple project management platforms, several internal communication tools, duplicate analytics solutions — often because each was adopted by a different team without central coordination. The operational cost of this fragmentation is real and recurring.
Third, consider your licensing strategy carefully. Businesses managing large Microsoft deployments can reduce both cost and complexity by working with legitimate resellers of enterprise productivity software to right-size their licence tiers rather than defaulting to maximum coverage. The savings can be reinvested in the engineering time needed to actually simplify systems rather than merely maintain them.
The organisations that will compound the most value from AI-assisted development tools over the next five years will not be those that generate the most code — they will be those with the discipline and incentive structures to know when to stop.
Key Takeaways
- Incentive misalignment is structural: Most engineering promotion frameworks explicitly or implicitly reward complexity creation over complexity elimination, creating a persistent drag on software quality across the industry.
- AI tools amplify the problem: Code generation tools like GitHub Copilot accelerate development speed without inherently improving architectural judgement, potentially accelerating technical debt accumulation at organisations without strong simplicity discipline.
- The security cost is real: System complexity is directly correlated with attack surface area and misconfiguration risk — a connection that cybersecurity teams understand but engineering incentive systems rarely account for.
- Major platforms are not immune: Microsoft, AWS, Google Cloud, and Salesforce all exhibit complexity accumulation patterns driven by competitive feature pressure and commercial incentives that parallel those seen in individual engineering teams.
- Measurement is the missing link: Organisations that want to change this dynamic need to make simplicity measurable — tracking deleted code, reduced dependencies, and eliminated incident categories as explicit performance inputs.
- Licensing and tooling overhead matters: Enterprises routinely over-licence and under-rationalise their software stacks, paying a recurring cost for complexity that was never consciously chosen.
- Cultural change requires leadership signals: No amount of engineering principle documentation will shift behaviour unless senior technical leaders visibly champion and reward simplification work in promotion and recognition decisions.
Looking Ahead
The conversation this article has sparked is unlikely to fade quickly. Several converging trends will keep it relevant throughout 2026 and beyond. The continued rapid adoption of AI coding assistants will force organisations to confront the quality-versus-quantity tradeoff more explicitly as the gap between code generation speed and architectural review capacity widens.
Watch for whether major technology companies begin revising their engineering ladders to explicitly incorporate simplification metrics — any such announcement from Google, Microsoft, or Meta would represent a significant cultural signal with industry-wide ripple effects.
The growing "platform engineering" movement, which focuses on reducing cognitive load for development teams through curated internal developer platforms, represents one institutional response to the complexity problem. Gartner predicted that by 2026, 80% of large software engineering organisations would establish platform engineering teams — we are now at the point where that prediction can be evaluated against reality.
Finally, as enterprise software procurement cycles come up for renewal across 2026, expect complexity fatigue to become an increasingly explicit factor in vendor selection decisions. Simpler, more focused tools with lower operational overhead are gaining ground against sprawling suites — a market dynamic that the industry's most established players will need to take seriously.
Frequently Asked Questions
Why don't companies just reward simplicity if it's clearly better?
The core problem is that simplicity is difficult to make visible in performance reviews. An engineer who deletes 2,600 lines of code and eliminates a category of production incidents has very little tangible output to point to. In contrast, an engineer who builds a new service — even an unnecessary one — can demonstrate pull requests, architecture documents, and feature flags. Until organisations develop explicit metrics for complexity reduction (deleted dependencies, reduced incident rates, lower mean time to resolution), the incentive asymmetry will persist regardless of stated engineering values.
How does AI-assisted coding change this dynamic?
Tools like GitHub Copilot, Cursor, and Amazon Q Developer dramatically accelerate the speed at which code can be generated, but they do not inherently improve architectural decision-making or simplicity discipline. The risk is that teams can now accumulate technical debt faster than ever before — generating working but architecturally questionable solutions in minutes that might previously have prompted more careful design consideration. Organisations need to pair AI tool adoption with stronger code review practices and explicit simplicity standards to avoid this trap.
What practical steps can IT leaders take to address complexity in their software stacks?
Three immediate actions are most impactful: first, audit your engineering performance framework to check whether it includes any recognition for simplification work — if not, revise it explicitly. Second, conduct a software portfolio rationalisation to identify redundant tools across overlapping categories, which is common in enterprises that have grown through acquisition or decentralised procurement. Third, right-size your software licensing by working with legitimate resellers rather than defaulting to maximum-coverage tiers — the savings can fund the engineering time needed to actually reduce complexity rather than merely manage it.
Is this problem unique to software engineering, or does it appear in other technology disciplines?
The incentive misalignment between visible complexity and invisible quality appears across technology disciplines, but it is most acute in software engineering because the outputs are intangible and the costs of poor decisions are often deferred. In hardware engineering, physical constraints impose natural limits on complexity. In software, the only limits are organisational — which is precisely why deliberate cultural and structural interventions are required. The cybersecurity field faces a related variant: security teams are rarely celebrated for breaches that didn't happen, only blamed for those that did, creating a parallel invisibility problem for preventive work.