Emily Bich explains that integrating AI into software development only improves outcomes when built upon strong engineering practices like test-driven development (TDD); without such a foundation, AI can accelerate poor processes, leading to lower-quality code and tests. She emphasizes that teams should focus on solid development methodologies before leveraging AI to ensure faster, more reliable, and maintainable software delivery.
In the video, Emily Bich discusses the impact of introducing AI tools into software development processes, emphasizing that AI alone does not guarantee improvements if the underlying development practices are weak. She uses an analogy of a trombone player with poor posture who benefits from posture lessons before handling the heavy instrument, likening this to developers needing a solid foundation before effectively leveraging AI. Teams with strong existing processes, particularly those practicing test-driven development (TDD), tend to benefit more from AI, while those with less disciplined workflows may see their problems worsen.
Emily outlines the common pre-AI development approach she calls “coding driven development,” where developers read tickets, find a place in the codebase to start coding, write code, test it manually or with some automation, and then add unit tests and refactor at the end. This process often leads to rushed testing, degraded design over time, and slower feature additions due to increasing codebase complexity. Adding AI tools to this process may speed up coding but does not address these fundamental issues, often resulting in faster delivery of lower-quality code and tests.
When AI is integrated into this traditional process, developers tend to rely on the AI to generate code based on tickets or prompts, but without proper problem slicing, planning, or test-first thinking, the AI’s effectiveness is limited. The AI may write unit tests after the fact, which do not serve the same purpose as tests written upfront in TDD, and design improvements are constrained by the tests tied to the initial implementation. This leads to a faster but still flawed development cycle, described as attaching a “code generation fire hose” to an inefficient process, which can overwhelm downstream testing and review stages.
In contrast, Emily highlights how AI tools can be much more effective when used within a TDD framework. Skilled developers start by deeply understanding the problem, collaborating with stakeholders, and breaking down features into small, testable examples. AI can assist in generating tests and code simultaneously in small increments, enabling rapid feedback and safe refactoring. This approach results in frequent commits with high-quality code and tests, maintaining design integrity and allowing the AI to support a more disciplined, iterative development cycle that is faster and more reliable.
Ultimately, the video stresses that the key to successfully leveraging AI in software development lies in having a strong engineering foundation, particularly a TDD mindset. Simply adding AI to a poor process will not yield the desired improvements and may exacerbate existing issues. Developers and teams should focus on improving their fundamental practices to fully benefit from AI tools, ensuring better code quality, maintainability, and faster delivery of valuable software.