I completed six production projects that now require ongoing maintenance, worked on one long-running project that’s been active since March, and experimented with half a dozen smaller prototypes. Compared to previous years, where I intentionally focused on fewer projects, the sheer volume and variety in 2025 exposed me to failure modes I hadn’t seen as clearly before.

In 2023–2024, work was slower due to a mix of personal and professional circumstances. With stability returning in 2025, I was able to take on more clients and more projects of varying sizes, and that accelerated my learning dramatically.

This article summarizes seven recurring problems I’ve seen either nearly destroy projects or directly cause their cancellation. I call them the 7 Deadly Sins of Software Engineering.

1. Pride

Pride is arrogance disguised as confidence. It’s the belief that assumptions matter more than evidence, and that “we know better” than users, data, or even teammates.

This sin usually appears in one (or both) of two places: management and development. In both cases, the result is the same: a technically solid product that solves the wrong problem.

A. Management Pride (The Ivory Tower)

Leadership assumes they understand the user better than the users themselves. Research is ignored, feedback is dismissed, and decisions are driven by an unvalidated “vision.”

Examples: – Adding AI to a product that’s still unstable. – Ignoring user complaints because they conflict with leadership’s beliefs. – Treating refactoring as “zero-value” work.

B. Developer Pride

Developers prioritize technical purity or intellectual challenge over business outcomes. With little direct user interaction, they end up building software for themselves, not for customers.

Examples: – Reinventing components instead of using proven libraries. – Over-engineering simple problems to showcase technical superiority.

2. Greed

Greed is demanding massive results without providing the necessary investment.

Projects are starved of budget, people, and tools, yet expectations keep rising. When this sin is present, failure is almost guaranteed, and the damage is felt immediately across the organization.

Examples: – Firing an entire team and replacing them with a single “vibe-coder.” – Expecting a small team to deliver in six months what a larger team couldn’t ship in years.

3. Lust

Lust is the uncontrolled desire for more: more features, more tweaks, more “quick wins.”

It’s the seduction of the next cool idea. The roadmap becomes a graveyard of half-finished features, and the original goal slowly disappears.

While related to greed, lust operates at a technical and product level, feature after feature, added without restraint.

Examples: – Shipping a feature to satisfy a single user without considering system-wide impact. – Chasing AI integration simply because it’s trendy.

4. Sloth

Sloth is avoiding the hard, boring, or uncomfortable work that keeps projects healthy.

It shows up as procrastination, corner-cutting, and a culture of “we’ll fix it later.”

Common causes include weak leadership, lack of accountability, and organizations that don’t value quality.

Examples: – Managers committing experimental code directly to main. – Skipping tests to “move faster.” – Endless TODOs and undocumented systems.

5. Gluttony

Gluttony is the relentless consumption of development resources to churn out features, while quietly creating an unmaintainable mess underneath.

It feels productive at first. Velocity looks great. But eventually the codebase becomes bloated, fragile, and immobile.

Unlike lust or sloth, gluttony is systematic: features are always prioritized, while maintenance is perpetually deferred.

Examples: – No time allocated for refactoring. – Treating automated tests as optional.

6. Wrath

Wrath is the anger and resentment born from toxic communication.

Ambiguity, blame culture, and information silos turn collaboration into open conflict. Teams stop working together, and sometimes actively work against each other.

This sin slows projects more than almost anything else.

Examples: – Managers who reward blame instead of problem-solving. – Teams that never communicate but still blame each other for failures.

7. Envy

Envy is abandoning your strategy because someone else looks more successful.

Competitors ship something shiny. Another department gets attention. Leadership panics, and direction changes overnight.

This is one of the most destructive sins, and it often feeds directly into wrath.

Examples: – Replacing a high-performing team for political reasons. – Constantly pivoting to chase trends instead of executing a long-term vision.

Conclusion

These are just seven of many ways a software project can fail, but they’re the ones I see most often.

Avoiding all of them is extremely difficult. However, when there’s real alignment between users, developers, and leadership, the path forward becomes clear.

And when that alignment exists, projects tend to succeed, not by accident, but by design.