In a world where apps launch overnight and updates roll out every few weeks, the pressure to ship fast often eclipses the desire to build something truly transformative. Yet the most enduring software breakthroughs—think the operating systems that power our phones, the databases that store global commerce, the compilers that turn code into reality—were never the product of incremental tweaks. They were born from engineers daring to ask, “What if we tried something radically different?” This article unpacks why the software community should rekindle that ambition, what recent discussions reveal about the current climate, and how a shift toward bold thinking can benefit developers, businesses, and end‑users alike.
Background / What Led to This
For decades, software development has oscillated between two poles: the romantic ideal of creating elegant, long‑lasting systems, and the pragmatic grind of delivering features on a sprint cadence. The rise of Agile, continuous integration, and DevOps promised a middle ground—speed without sacrificing quality. In practice, however, the relentless focus on velocity has produced a culture where “shipping” often means shipping the smallest viable change, not the most impactful one.
Dan Luu’s recent essay, “We should be more ambitious with the software we build,” spotlights this tension. Luu argues that the industry has become risk‑averse, opting for safe, incremental improvements rather than tackling the hard problems that could redefine entire domains. He points to historical examples—UNIX, the early web browsers, the first relational databases—as products of engineers who were allowed (or encouraged) to pursue lofty, even speculative goals. Today, the same appetite for risk is often stifled by short‑term metrics, investor pressure, and a talent market that rewards rapid delivery over deep craftsmanship.
What Exactly Happened
The conversation sparked by Luu’s essay didn’t arise in a vacuum. Over the past five years, several high‑profile incidents have illustrated the cost of complacency. A series of microservice outages at major cloud providers revealed how tightly coupled, poorly documented services can cascade failures across the internet. Meanwhile, the proliferation of “low‑code” platforms promises to democratize development but often results in brittle, hard‑to‑maintain applications that lock organizations into vendor ecosystems.
At the same time, we’ve seen a resurgence of ambitious open‑source projects that defy the incremental norm. Projects like Rust, which reimagines systems programming with safety guarantees, and the resurgence of functional languages like Elixir, show that when engineers are given the freedom—and the resources—to pursue bold ideas, the ecosystem benefits. These initiatives are not just technical curiosities; they are reshaping performance benchmarks, security postures, and developer ergonomics across industries.
Industry Impact
When the software community collectively leans toward modest, incremental releases, the ripple effects are profound:
- Stagnant Innovation: Companies that prioritize speed over substance may miss out on breakthrough features that could open new markets or create defensible moats.
- Technical Debt Accumulation: Short‑term fixes compound over time, inflating maintenance costs and making future refactoring more painful.
- Talent Drain: Engineers seeking challenging problems gravitate toward organizations that champion ambitious projects, leaving risk‑averse firms with a talent gap.
- User Dissatisfaction: End‑users eventually feel the pinch as products become a collection of patches rather than cohesive experiences.
Conversely, companies that embed ambition into their DNA often reap outsized rewards. Apple’s decision to design its own silicon, Google’s investment in quantum‑ready algorithms, and Microsoft’s ambitious push into mixed reality—all began as high‑risk bets. While not every gamble pays off, the ones that do can reshape entire sectors and set new industry standards.
What This Means for You
Whether you’re a senior engineer, a product manager, or a CTO, embracing ambition translates into concrete actions you can take today:
- Allocate Time for Exploration: Adopt a “20% time” model or dedicated hack weeks where teams can prototype ideas outside the regular roadmap.
- Measure Success Differently: Shift KPIs from pure velocity metrics to long‑term impact indicators—such as performance improvements, security hardening, or user delight scores.
- Invest in Deep Expertise: Encourage specialization in areas like compiler theory, distributed systems, or cryptography, even if they don’t immediately map to a product feature.
- Foster Psychological Safety: Build a culture where failure is treated as data, not a career‑ending event. This lowers the barrier to attempting bold experiments.
- Partner with Academia and Open Source: Leverage research collaborations and contribute to ambitious open‑source projects to stay at the cutting edge.
By integrating these practices, you not only boost your team’s morale but also position your organization to capture opportunities that competitors, locked into incremental thinking, will overlook.
What to Expect Next
The momentum toward ambitious software is already gaining traction. Expect to see:
- More “Moonshot” Funding Rounds: Venture capitalists are increasingly allocating capital to deep‑tech startups that aim to solve foundational problems rather than just iterate on existing services.
- Hybrid Development Models: Teams will blend rapid delivery pipelines with longer‑term research tracks, creating a dual‑track approach that balances speed and depth.
- Policy Shifts: Governments and standards bodies may start incentivizing robust, secure software through procurement requirements, nudging companies toward more thoughtful engineering.
In the coming years, the most successful firms will likely be those that can seamlessly toggle between sprint‑level execution and visionary, high‑risk projects. The ability to do both will become a competitive differentiator, not a luxury.
Frequently Asked Questions
Is aiming for ambitious projects realistic for small startups?
Absolutely. Ambition doesn’t always mean massive scale; it can mean tackling a problem that’s fundamentally unsolved in a niche market. Startups often have the agility to experiment without legacy constraints, making them ideal incubators for bold ideas.
How do I convince leadership to allocate resources for high‑risk initiatives?
Present a clear hypothesis, potential upside, and a bounded experiment plan. Use data from past successful moonshots—like the revenue lift from a new platform or cost savings from a performance breakthrough—to illustrate tangible benefits.
What if an ambitious project fails? Won’t that hurt the company?
Failure is an inherent part of innovation. The key is to fail fast, learn, and iterate. By documenting lessons and sharing them across the organization, you turn a setback into a knowledge asset that informs future efforts.
Conclusion
The software landscape is at a crossroads. We can continue down the path of relentless incrementalism—delivering more features, faster, but often at the expense of depth and differentiation—or we can rekindle the daring spirit that gave us UNIX, the web, and modern cloud computing. By deliberately fostering ambition, allocating space for exploration, and redefining success metrics, the industry can unlock the next generation of transformative technologies. The choice isn’t just strategic; it’s existential. The future of software will be shaped by those who dare to ask, “What if we built something bigger?”
Photo by ThisisEngineering on Unsplash
