Listen and watch now on ** YouTube, Apple, and Spotify**.
In this episode of Engineering Enablement, I sit down with Max Kanat-Alexander, Executive Distinguished Engineer at Capital One, to discuss how AI is changing software development and why strong engineering fundamentals matter more than ever.
We explore how the skills engineers need are expanding, why AI amplifies both the strengths and weaknesses of the development lifecycle, and how teams should think differently about code review, quality, and testing. Max also shares how leaders can assess whether their organizations are ready for more advanced AI workflows and why we need more research into how junior engineers become senior engineers.
**Some takeaways: **
AI amplifies the engineering system you already have
Strong engineering fundamentals matter even more with AI. AI amplifies everything that is good or bad about a software development lifecycle, so teams with strong tooling, CI, testing, and workflows are positioned to see the greatest gains.Faster coding doesn’t solve problems elsewhere in the development lifecycle. If engineers spend significant time navigating broken processes, waiting for reviews, or dealing with poor tooling, accelerating code generation only addresses a small part of their work.
The skills engineers need are changing
Clearly expressing requirements and providing feedback are becoming increasingly important engineering skills. These are capabilities senior engineers have traditionally developed through years of experience, but they become essential much earlier when working effectively with coding agents.Deep technical knowledge still helps engineers recognize when something is wrong. Experience with languages, systems, and software design develops the pattern recognition needed to spot a flawed approach without reviewing hundreds of lines of AI-generated code.Domain understanding and problem definition are becoming more valuable. As AI gets better at reproducing knowledge found in documentation, engineers can differentiate themselves through understanding what needs to be built and why.
Code review is fundamentally about maintainability
Human code review shouldn’t be the primary way teams catch bugs. Tests, static analysis, and other automation are more effective and scalable ways to detect defects.Human judgment remains important for evaluating maintainability and design. Reviewers can assess whether code is understandable, structured appropriately, and aligned with the longer-term intent of a system.The right quality bar depends on the codebase. A disposable script and enterprise software expected to operate for a decade shouldn’t be subjected to identical standards because the consequences and costs of getting them wrong are very different.
Not every change needs the same review process
Code review is an important tool for developing less experienced engineers. Max says reviewing someone’s code is the most effective way he has found to improve their core software engineering skills.Trusted engineers may not need every change reviewed on codebases they deeply understand. That trust should be specific to the combination of the person and the codebase, rather than becoming a blanket exemption from review.The risk of the individual change can also determine whether human review is necessary. Teams can evaluate confidence and potential consequences rather than requiring the same review process for every PR.
AI can create a vicious cycle of declining code quality
AI struggles when it has to build on poorly structured, poorly tested code. When weak review allows its bad output back into the codebase, the code becomes even harder for AI to work with, creating a cycle that can eventually leave teams with systems they can’t understand or maintain.AI can also help teams reverse that cycle. Agents can write tests, improve testability, and are particularly effective at refactoring when engineers deliberately direct them toward improving the codebase.Refactoring should support forward progress on product goals. Rather than attempting to clean up an entire codebase, teams should improve the parts they need to touch for upcoming work and make the necessary developer experience improvements along the way.
AI readiness depends on how far left rigor extends
Fixing an existing software development lifecycle is much harder than building a good one from the beginning. Organizations with weak engineering practices often have to start with production problems and work backward through incident management, observability, deployment, testing, and earlier stages of development.How far left rigor extends is a useful signal of AI readiness. Organizations without strong controls around production, code review, and testing may introduce significant risk by giving engineers tools that allow them to move much faster.Leaders should evaluate the organization they actually have rather than following the AI hype cycle. Max is bullish on AI adoption, but argues that organizations need the engineering foundations to support the additional velocity it creates.
The industry needs a better way to develop senior engineers
We still know surprisingly little about what reliably turns junior engineers into senior engineers. Mentorship and apprenticeship are widely considered important, but the practices that actually produce experienced engineers have not been deeply studied.AI makes understanding that development path more urgent. Senior engineers rely on experience to recognize failure patterns, which raises questions about how newer engineers will acquire that judgment as AI takes on more of the implementation work.AI may ultimately increase the need for engineering expertise rather than reduce it. As hundreds of millions more people gain the ability to build software and the rate of change accelerates, Max believes the world will need more experienced engineers to manage that complexity.
In this episode, we cover:
([00:00](https://www.youtube.com/watch?v=gEuD4bP17uc)) Intro
([01:54](https://www.youtube.com/watch?v=gEuD4bP17uc&t=114s)) Max’s role at Capital One
([02:52](https://www.youtube.com/watch?v=gEuD4bP17uc&t=172s)) Where to invest in engineering organizations
([06:36](https://www.youtube.com/watch?v=gEuD4bP17uc&t=396s)) The new entry-level engineering skills to pay attention to
([10:39](https://www.youtube.com/watch?v=gEuD4bP17uc&t=639s)) Why deepening your understanding still matters
([12:29](https://www.youtube.com/watch?v=gEuD4bP17uc&t=749s)) The bottlenecks around code review
([19:40](https://www.youtube.com/watch?v=gEuD4bP17uc&t=1180s)) Why human code reviews still have value
([25:20](https://www.youtube.com/watch?v=gEuD4bP17uc&t=1520s)) Why not all PRs need human review
([26:11](https://www.youtube.com/watch?v=gEuD4bP17uc&t=1571s)) The vicious cycle of AI-driven development
([30:13](https://www.youtube.com/watch?v=gEuD4bP17uc&t=1813s)) Using LLMs for refactoring
([33:58](https://www.youtube.com/watch?v=gEuD4bP17uc&t=2038s)) AI readiness and why fixing engineering systems is so hard
([38:42](https://www.youtube.com/watch?v=gEuD4bP17uc&t=2322s)) Why research is needed on creating good senior engineers
([41:00](https://www.youtube.com/watch?v=gEuD4bP17uc&t=2460s)) Why AI will increase the need for engineers
**Where to find Max Kanat-Alexander:**
• LinkedIn: [https://www.linkedin.com/in/mkanat](https://www.linkedin.com/in/mkanat)
• X: [https://x.com/mkanat](https://x.com/mkanat)
• Blog: [https://www.codesimplicity.com](https://www.codesimplicity.com)
Where to find Brian Houck:
• LinkedIn: https://www.linkedin.com/in/brianhouck Referenced:
• [DX Core 4 Productivity Framework](https://getdx.com/corefour)
• [Code Review Guidelines at Google](https://google.github.io/eng-practices/review/)
• [Code Simplicity by Max Kanat-Alexander](https://www.amazon.com/dp/1449313892?lv=shuf&channelId=500&plpRedirect=mhFallback)
• [How Microsoft sees engineering bottlenecks changing with AI](https://getdx.com/podcast/how-microsoft-sees-engineering-bottlenecks-changing-with-ai/)