Techsplainers by IBM

This episode of Techsplainers explores AI debugging and how artificial intelligence can assist developers in finding, understanding and fixing software problems. Building on earlier episodes about shift-left security, static code analysis and AI unit testing, understanding and fixing software problems. Building on earlier episodes about shift-left security, static code analysis and AI unit testing, it explains how debugging fits into the broader effort to catch and resolve issues earlier in the development lifecycle. The episode walks through how AI tools can analyze code, stack traces, logs and test failures to suggest likely causes, summarize complex information and propose draft fixes. It also distinguishes between using AI to debug traditional software and debugging AI-powered systems themselves, where problems may involve prompts, retrieval quality, inconsistent outputs or model behavior rather than a single broken line of code. Along the way, it highlights the benefits of faster triage, clearer context and guided fix suggestions, while also addressing the limits of pattern-based recommendations, missing business context and overreliance on generated answers. The episode closes by connecting AI debugging to the upcoming discussion of vibe coding security risks.

Find more information at https://www.ibm.com/think/topics/ai-debugging
Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

Narrated by Ian Smalley

This episode of Techsplainers explores AI unit testing and how artificial intelligence can support one of software development’s most common quality practices. Building on the earlier episodes about shift-left security and static code analysis, it explains how unit tests check small pieces of code in isolation and how AI can help generate test cases, identify edge conditions, improve coverage and maintain tests as code changes. The episode also clarifies an important distinction between using AI to help test traditional software and testing software components that themselves rely on AI models or probabilistic outputs. Along the way, it examines the practical benefits of faster test creation, broader scenario coverage and stronger support for continuous development workflows. It also addresses the limits of AI-generated tests, including shallow assertions, duplicated assumptions, brittle test suites and the continued need for human review. Finally, the episode places AI unit testing within a larger development strategy that includes code analysis, debugging and secure review practices.

Find more information at https://www.ibm.com/think/topics/ai-unit-testing
Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

Narrated by Ian Smalley

This episode of Techsplainers explores static code analysis, a development practice that inspects source code without running the application. Building on the series opener about shift-left security, it explains how static analysis helps teams identify potential bugs, security flaws and code quality issues earlier in the software development lifecycle, when fixes are typically simpler and less costly. The episode walks through how these tools work by scanning code and less costly. The episode walks through how these tools work by scanning code against rules and models, and it clarifies the difference between simple rule checks and deeper data flow analysis. It also explains how static code analysis can reveal issues such as insecure input handling, hardcoded secrets, dead code and possible SQL injection risks. Along the way, the episode examines the benefits of consistent automated scanning, faster feedback for developers and better support for code review, while also addressing practical limitations like false positives and the fact that static analysis cannot detect every runtime problem. Finally, it places static code analysis within a broader strategy that also includes testing, debugging and secure review practices.

Find more information at https://www.ibm.com/think/topics/static-code-analysis
Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

Narrated by Ian Smalley

This episode of Techsplainers introduces shift-left security, the practice of moving security earlier in the software development lifecycle instead of treating it as a final review step. It explains how teams can build security into planning, coding, testing and delivery workflows so vulnerabilities are found when they are easier and less costly to fix. The episode walks through the logic behind the approach, clarifies how shift-left security fits modern development methods like CI/CD, and defines related concepts such as static application security testing and software composition analysis in plain language. It also explores the benefits of earlier detection, reduced remediation effort and stronger collaboration between development and security teams, while addressing common challenges like alert overload, false positives and skills gaps. Finally, it sets up the rest of the series by showing how topics like static code analysis, AI unit testing, AI debugging and AI-generated code risks connect back to this broader security approach.

Find more information at https://www.ibm.com/think/topics/shift-left-security
Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast

Narrated by Ian Smalley

Quantum memory is designed to record, preserve and retrieve quantum states without destroying the properties that make quantum computing possible. Matt Finio explains how quantum memory differs from classical memory and explores concepts including qubits, superposition, decoherence, the no-cloning theorem and quantum error correction. The episode also examines solid-state systems, cold atoms, trapped ions and the role of memory in quantum networks, repeaters and a future quantum internet.

Find more information at: https://www.ibm.com/think/topics/quantum-memory
Find all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast
Narrated by Matt Finio