blog main page

The biggest impact of AI on software engineering may not be that it replaces experienced engineers, but that it changes how much of their time each product actually needs. As AI makes implementation, debugging, and maintenance cheaper, companies may increasingly rely on senior engineers for the highest-leverage decisions while AI-assisted developers handle more of the day-to-day work. That shift could reshape how software teams are structured, how technical risk is managed, and how engineering talent is valued. The full version at the end explores this argument in detail, including where it works, where it breaks down, and why senior expertise can become more valuable even as the number of senior-engineer hours required per project declines.

Coding agents are getting remarkably good at making software work, but making a correct change is not always the same as making the right architectural change. When new requirements arrive, agents often extend the structures that already exist, adding behavior to familiar classes, services, and modules rather than asking whether those structures still reflect the domain. Over time, that tendency can leave a codebase technically correct but conceptually outdated. This article explores why coding agents are often structurally conservative, how that can quietly degrade architecture, and why the next generation of agents will need to do more than generate successful patches. They will need to recognize when the software model itself should change.

AI agents are quickly becoming part of everyday software development, but the biggest challenge may not be how well they write code. It is how teams decide what good agent-assisted engineering actually looks like. As engineers develop different habits around delegation, review, validation, model choice, cost, and risk, those individual workflow decisions begin to affect performance expectations, accountability, onboarding, and engineering culture. This article explores why agentic development needs to become a shared team practice, not just a collection of personal experiments, and what organizations can do to establish clearer expectations without slowing down the benefits AI can provide.

As coding agents make software faster to produce, a new challenge is emerging: if developers no longer read every generated line, how do we make failures easy to find, understand, and fix? Robert C. Martin’s recent comments about relying on automated constraints rather than continuous code inspection point toward an important architectural consequence. In this article, I explore why fault containment becomes increasingly important in agentic development, how vertical-slice architecture can create clear boundaries for generated code, and what teams need to enforce so that when the code is wrong, engineers still know exactly where to look.