Latest / Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering / How GitHub Copilot Changed Software Engineering
Transcript
- Lucas: The most significant shift in software engineering over the last year isn't about faster compilers or better cloud infrastructure. It is about how we validate code that was written by an algorithm we did not fully audit. We are looking at a fundamental change in the role of the tester. Luna: So you are saying the human element is moving from creation to verification? That feels like a massive leap for teams used to writing every line themselves. Lucas: Exactly. In September 2026, the default state for many senior engineers is no longer starting with a blank file. It is starting with a prompt. The immediate question is not how fast can we build this feature, but how do we trust the output before it touches production? Luna: I have seen some horror stories where the AI writes code that looks perfect but fails on edge cases. How do you catch those specific failures without slowing down the entire pipeline? Lucas: You catch them by changing what you measure. Traditional unit tests check if the function returns the expected value. But when the function is generated, you need to check if it behaves correctly under stress. We are seeing teams adopt property-based testing as a standard defense against ai generated logic errors. Luna: Property-based testing sounds like the right tool for chaos, but does it actually scale when your codebase grows exponentially because AI is generating so much of it? Lucas: It scales because it automates the search for counterexamples. Instead of writing one test case, you define the rules of behavior. If the AI violates even one rule across thousands of random inputs, the test fails. It forces the engineer to confront the gaps in their own prompting. Luna: That implies the engineer has to be very precise about defining those rules. Is that a skill most developers currently possess, or are we just shifting the bottleneck upstream? Lucas: It is a new bottleneck. The engineers who are thriving are the ones who understand system design deeply enough to articulate constraints clearly. Those who rely on vague prompts are shipping fragile code that breaks in staging. Luna: And what happens when the AI generates something that passes all the tests but is logically flawed in a way the tests didn't anticipate? That is the classic blind spot. Lucas: That brings us to the concept of semantic drift. The code works, but it does something slightly different than intended. This is where code review changes. It stops being a syntax check and becomes a intent verification. You are reading for meaning, not just mechanics. Luna: So the reviewer needs to know the domain expertise intimately to spot when the AI took a shortcut. That requires more senior oversight, doesn't it? Lucas: It requires more senior oversight, but it also allows seniors to move faster. They can delegate the boilerplate generation to the AI and focus entirely on the complex logic paths that matter. It is a leverage play, not a replacement. Luna: I wonder if junior developers are getting trapped in a loop where they never learn the fundamentals because they rely too heavily on the suggestions. Is that a risk? Lucas: It is a real risk. Some companies are now requiring juniors to write critical modules manually for their first six months. No AI assistance. It is a deliberate pedagogical choice to ensure foundational knowledge sticks. Luna: That is a bold policy. Do you think other firms will follow suit, or is it too costly to slow down the onboarding process? Lucas: Costly in time, perhaps, but cheap compared to the debt of hiring someone who cannot debug code they did not write. We are seeing a correction in how talent is evaluated. Reading comprehension of code is becoming as important as writing speed. Luna: Speaking of debt, how are teams handling the security implications? AI models are trained on public repositories, which means they might suggest known vulnerabilities or license-violating code. Lucas: Security scanners have become mandatory gatekeepers. You cannot merge code that triggers a vulnerability flag, regardless of whether it was written by a human or an AI. The pipeline does not care about the source, only the result. Luna: But what if the vulnerability is subtle? Like a logical flaw that opens a door to injection attacks but doesn't show up in static analysis? Lucas: Then you rely on dynamic testing and penetration testing. You simulate real-world attacks against the generated code. If the AI creates a weak input validator, the pen-test exposes it. It is part of the modern QA stack now. Luna: So the QA team is evolving into a mix of security analysts and logic auditors. That is a very different job description than it was three years ago. Lucas: It is. And it is creating tension within teams. Developers want to ship fast. Testers want to verify thoroughly. The AI accelerates the former but complicates the latter. Managing that friction is the new management challenge. Luna: Have you seen any successful frameworks for resolving that friction? Or is it mostly ad-hoc solutions per company? Lucas: Some organizations are adopting a dual-track approach. One track for rapid prototyping with AI, another for hardening and release with strict manual controls. It separates innovation from stability. Luna: That makes sense. But I worry about the handoff between those tracks. Information loss is inevitable when you split the workflow. Lucas: Information loss is the enemy here. That is why documentation is back in vogue. You cannot rely on self-explanatory code when the code is synthetic. Every module needs clear comments explaining the intent behind the generation. Luna: Comments from an AI are often useless though. They tend to repeat the code structure rather than explain the why. So who writes the meaningful documentation? Lucas: The humans. The engineers must write the high-level design docs and the rationale for key decisions. The AI fills in the implementation details. It is a partnership where the human holds the steering wheel. Luna: I find that reassuring. As long as there is accountability, the technology can be a powerful lever. But it requires discipline. Lucas: Discipline is the keyword. Without it, you get a swamp of untested, undocumented code that no one dares to touch. That is the dark future we are avoiding. Luna: Do you think this level of scrutiny will eventually become the norm for all coding, or will it remain a premium practice for high-stakes systems? Lucas: I think it will become the norm. As AI becomes ubiquitous, the baseline expectation for reliability will rise. You will not be able to ship buggy code easily when everyone else is doing it better. Luna: So competition drives quality. That is a hopeful way to look at it. Lucas: It is. The market rewards trust. And in software, trust is built through rigorous testing and transparent processes. Luna: Before we wrap up, we want to mention something important about how this show operates. Lucas: We deliberately run no ads on Fexingo. If you want to support that choice, the link is buy me a coffee dot com slash fexingo. Luna: Your contributions help us keep the content independent and focused on deep analysis rather than click-through rates. Lucas: Back to the topic: as we look ahead, the question is not whether AI will write code, but how well we can govern it. The engineers who master governance will lead the next decade. Luna: That is a sharp way to put it. Governance over generation. I think that will define the era. Lucas: Let us see how the industry adapts in the coming quarters. For now, focus on building systems that are verifiable, not just visible.