This collection explores the practical aspects of code quality in modern software development. The articles examine what makes code maintainable, readable, and testable, while questioning common assumptions and dogmatic approaches that often dominate discussions about clean code and software craftsmanship.
The content covers real-world challenges developers face when balancing code quality with delivery pressures, team dynamics, and evolving requirements. Rather than prescribing universal rules, these articles investigate when quality practices genuinely add value and when they become performative gestures that hinder productivity.
Topics include testing strategies, refactoring techniques, technical debt management, and the social dimensions of code quality within development teams. The focus remains on pragmatic approaches that consider context, trade-offs, and the actual impact on software systems and the people who build them.
Buzzword-Driven Development vs. Fundamental Software Quality
Explore why fundamental software quality practices in .NET must never be overlooked for trendy buzzwords, including recommended analyzers and project settings for managing technical debt effectively.
Vibe Coding in .NET: Creative Catalyst or Maintenance Risk?
In the world of software development, there’s a recurring tension between discipline and improvisation. Somewhere along that spectrum lies a phenomenon increasingly referred to as Vibe Coding. The term evokes a style of development where engineers follow intuition and momentum rather than formal plans, processes, or design patterns.
It’s fast, fluid, and occasionally brilliant. But is it sustainable in a .NET-based enterprise context?
Managing Errors, Warnings, and Configurations in C# and .NET
When we activated static code analysis for the first time in one of my last projects, the overwhelming number of warnings exceeded expectations and highlighted gaps in the code. Without making any changes, the project already had a significant number of warnings. After activating additional analyzers and updating some configurations, this number temporarily increased dramatically.
The high number of warnings was initially daunting, but we saw it as an opportunity to significantly improve our code quality. At first glance, it seemed easier to suppress or ignore these warnings. But as I often remind my team, “The code you create is a valuable legacy, so it’s important to build it carefully.” Ignoring warnings today creates obstacles for future developers—and that could very well include you six months down the line.
This experience reinforced the importance of managing warnings and errors systematically. Let me share some of the lessons we learned, the strategies we used to tame those 60,000 warnings, and how you can apply these techniques to your own projects.
Gradually Introducing Nullability in Legacy Code: A Practical Guide for .NET and C#
As developers, we’re often tasked with maintaining and modernizing legacy codebases that were written long before some of the best practices of today—such as nullability annotations—were available. While modern C# now supports nullable reference types, enabling us to avoid the dreaded NullReferenceException, introducing this feature to existing, large codebases can be a challenge.
In this article, I’ll share my step-by-step approach for introducing nullability into a legacy .NET and C# project. You’ll learn how to apply nullability in a controlled, incremental manner using project-level settings, scoped annotations, and file/method-level directives, all while maintaining the integrity of your legacy codebase. After all, modernizing your code doesn’t have to be an all-or-nothing endeavor—gradual change is key to a successful transition. Let’s get started!
