As a contractor, I frequently encounter a recurring issue across many projects: a glaring lack of emphasis on code quality. While some projects uphold decent standards, the majority fall significantly short. What’s even more concerning is that much of this subpar code is written—or at least overseen—by senior software engineers.

Because I no longer hold a permanent position within a company, enforcing code quality as a top priority is often challenging. By the time I’m brought in, the codebase is usually too far along to implement meaningful improvements without major overhauls.

The Cost of Neglecting Code Quality

A recent contract perfectly illustrates this issue. I was brought in just six weeks before user acceptance testing began for the first release of three projects. By that time, the codebase had accumulated over 4,200 code violations—one issue for every four lines of code! Worse still, the architecture was riddled with inefficiencies, making it difficult to implement unit testing or reuse code, two key topics I emphasize in my conference talks. Unfortunately, much of the work I put into improving the code during those first six weeks may never be merged.

This is not an isolated incident. A few years ago, I worked on a codebase with over 50,000 issues. It took me an entire year just to clean up a fraction of them, without adding a single new feature. After my contract ended, I returned six months later only to find that the team had introduced another 10,000 issues! More recently, in 2023, I was on a project where the solution contained 125,000+ code violations—a staggering number that should never be allowed to accumulate.

As someone who has spent decades writing, speaking, and teaching about code quality, these experiences are disheartening. I stress the importance of clean, maintainable code to students and conference attendees alike, and I even wrote a book on .NET coding standards. Yet, despite my efforts, many companies continue to prioritize short-term feature delivery over long-term maintainability.

Code Quality: A Business Imperative

Let’s be honest—most companies care about two things:

1. Adding new features to drive sales.
2. Delivering those features at the lowest possible cost.

Unfortunately, this mindset often leads them to dismiss code quality and architecture as unnecessary overhead. They fail to realize that poor code quality has long-term costs, especially when it comes to fixing bugs—something many executives don’t even consider a “feature.”

I once confronted this issue head-on during a meeting with executives at a previous company. After years of pushing for better coding practices, I finally warned them: “If we continue down this path, implementing new features will either become impossible or excessively time-consuming. We’ll lose our competitive edge—and our customers.” They ignored my concerns until my boss pointed out that I had been saying this for four years. Their response? Lay off all the experienced engineers, including me. The result? They lost customers—exactly as I had predicted.

This experience underscores an important truth: if we, as developers, don’t champion code quality, no one else will.

Why should we care? Because we’re the ones who have to maintain the code, add new features, and fix bugs. A poorly written codebase turns every new feature into a nightmare, leading to endless patches—until one day, the system becomes so brittle that rewriting it from scratch becomes the only option. And if the database is just as poorly designed? Then the entire project is doomed from the start.

For me, writing high-quality code is also a matter of pride. I take satisfaction in committing the best possible code to source control. As a contractor, I don’t have the luxury of “fixing it later.” I ensure my code is clean from the start.

A Path to Code Quality Excellence

Improving code quality requires deliberate effort and a genuine interest in writing better code. As you gain experience, good coding practices become second nature, making it even more frustrating to work on projects where they’re neglected. Fortunately, there are many ways to build expertise in this area.

Books: Timeless Resources for Growth

Books are an excellent way to expand your knowledge. I highly recommend:

• Clean Code by Robert C. Martin
• Refactoring by Martin Fowler
• A solid book on object-oriented programming for your language of choice
• A book on design patterns

For .NET developers, I also suggest checking out my books, which are tailored to help developers write better code.

Conferences and Community Events

Attending conferences is a great way to learn best practices from industry experts. While large, paid conferences can be valuable, keep in mind that many are profit-driven. I’ve discussed this in my article, “Soft Skills: As Important If Not More Important Than Technical Skills at Conferences.”

For those looking for free and highly educational experiences, I recommend:

• Code Camps – Community-driven events focused on real-world developer topics.
• Local user groups & meetups – Free events run by passionate software engineers.

I founded and ran a user group in San Diego for 20 years, and I’ve seen firsthand how much these gatherings help developers grow.

Online Training and Videos

Online resources can also be incredibly helpful.

• Microsoft Learn provides free training on various coding topics.
• Pluralsight has excellent courses, including Defensive Coding in C# by Deborah Kurata.
• I have over 100 videos covering coding best practices, available here: dotNetDave VOD.

Tools to Improve Code Quality

There are many tools available to help identify and correct issues in your code before they become major problems. I highly recommend:

• Visual Studio Code Analysis – Built-in static analysis tools.
• CodeIt.Right (for .NET Framework) – Great for enforcing best practices.
• NDepend – Invaluable for code quality analysis.
• GhostDoc – Helps maintain clear documentation.
• CodeRush (DevExpress) or ReSharper (JetBrains) – Advanced refactoring tools.

These tools don’t just find issues—they teach you how to write better code. That’s why they’re worth every penny.

Code Quality: A Shared Responsibility

I hope this discussion has inspired you to prioritize code quality in your projects.

Here’s my challenge to you: speak up about code quality in every planning meeting. Advocate for best practices. Use the right tools. And most importantly—write clean, maintainable, and scalable code from day one.

How do you approach code quality in your work? Share your thoughts—I’d love to hear them!

Pick up any books by David McCarter by going to Amazon.com: http://bit.ly/RockYourCodeBooks

If you liked this article, please buy David a cup of Coffee by going here: https://www.buymeacoffee.com/dotnetdave

© The information in this article is copywritten and cannot be preproduced in any way without express permission from David McCarter.