Software Engineering Principles and Practices

Software engineering is the practice that turns code into systems people can rely on. The distinction matters because typing code has never been easier — AI assistants produce syntactically valid output in seconds — yet the rate at which production systems fail, leak data, or quietly accumulate maintenance debt has not improved. The discipline lives in the gap between code that compiles and code that survives contact with reality.

The articles in this collection treat software engineering as a profession, not a productivity exercise. The recurring theme is the feedback loop: write code, watch it fail, understand why, refine thinking. That loop cannot be automated because closing it requires learning from production failures and applying that knowledge to prevent the next one. Prompt engineering optimizes for speed; engineering optimizes for survival under conditions the original author did not anticipate.

Topics range from defensive programming with ArgumentNullException.ThrowIfNull and guard-clause patterns, through structured logging that does not lie about what happened, to multi-framework targeting decisions that look harmless and quietly break the build on the third project that consumes the library. Clean Code is treated as a starting point rather than a creed — most teams that quote SOLID rarely apply it consistently, and the articles examine what actually works in production versus what looks defensible in code review.

A second cluster of articles addresses the economic reality. Technical debt compounds like financial debt, and small shortcuts become the dominant cost driver three years in. Retiring legacy projects, illuminating debt with analyzers, and recognizing when a refactor is cheaper than another feature release are covered with the trade-offs named explicitly.

The voice across these articles is opinionated and grounded in specific failures. Generic advice rarely changes behavior. Specific failure modes, named clearly, do.

Purpose Limitation in API Design: Leaking Data You Shouldn't

Most APIs expose personal data based on database entities, not caller needs. When a password reset endpoint returns a user’s full profile, purchase history, and marketing preferences, that’s purpose drift. This article shows how to restructure ASP.NET Core APIs around caller purposes using resource-based authorization, consent validation, and field-level access control.

Real Professional Software Engineering in the AI Era

Throughout this series, we’ve established that AI-generated code without understanding creates productivity illusions that collapse in production (Part 1), and that the feedback loop between code and reality—compilation, testing, profiling, production—sharpens thinking in ways AI can’t replicate (Part 2). Now we confront the practical question: What defines professional software engineering when code generation becomes trivial? This final part examines the irreplaceable skillset: understanding execution characteristics (recognizing allocation patterns that cause GC pressure before deployment), asking questions AI can’t formulate (What’s the failure mode when this service is unavailable?), recognizing when plausible AI solutions diverge from correct ones, debugging production failures AI has no execution model to reason about, and evaluating maintainability for code that becomes tomorrow’s burden. We explore why prompt engineering optimizes for speed while architecture optimizes for survival, why “AI productivity” often means faster technical debt accumulation, and why the economic reality favors organizations that measure system reliability over lines of code generated. The feedback loop can’t be automated because closing it requires learning from production failures and applying that knowledge to prevent future ones—the irreplaceable discipline that defines real professionals in 2026 and beyond.

The Feedback Loop That AI Can't Replace

In the first part of this series, we established that AI-generated code without understanding creates an illusion of productivity that collapses under production load. The differentiator isn’t typing speed—it’s the feedback loop where code meets reality and exposes incomplete thinking. But what exactly is this feedback loop, and why can’t AI replicate it? Modern compilers validate logical consistency, catching gaps pure thought leaves unresolved. Profilers expose the 75x performance difference between “seems reasonable” and “actually performs.” Production environments reveal every assumption abstract thinking deferred—scale, concurrency, failure modes. This article explores the mechanisms that transform vague reasoning into concrete understanding: compilation validates logic instantly, testing catches behavioral mismatches, profiling measures what abstract analysis guesses, and production exposes the cost of every deferred decision. Real professionals don’t just write code—they master the iterative discipline of watching it fail, understanding why, and refining their thinking. AI participates in parts of this loop, but it can’t close it. That’s where professionals remain irreplaceable.

Kehrwoche: What Swabian Cleaning Teaches About Technical Debt

Kehrwoche—a Swabian cleaning tradition—is scarier than breaking the build on Friday afternoon. At least the build doesn’t remember next Tuesday. Mrs. Schmid from the second floor does, and she remembers well. What does a weekly cleaning schedule in southern Germany have to do with technical debt? More than most software teams want to admit.

Format Buffet Nobody Ordered

Developers wanted one format. We got twenty. CSV mangles data, XML drowns in tags, JSON forbids comments, YAML punishes spaces. TOML tried fixing it. TAML went minimal. TOON optimized for AI. CCL brought category theory. Result? Five formats per project, three parsers, and debugging why NO became false. AI can’t save us either. Welcome to format hell.