Get all your news in one place.
100's of premium titles.
One app.
Start reading
inkl
inkl
Olga Glasson

EXPLAINED: Gleb khmyznikov on the growing problem of ai generated code - The Real Truth

Gleb Khmyznikov

Open-source projects run on outside help. Any developer can send a fix or report a vulnerability, and the maintainer uses it to improve the product. With the arrival of AI, this arrangement has started to break down. At the end of January, curl, the data transfer tool built into billions of devices, shut down its bug bounty program. In the first three weeks of 2026, the project received 20 reports, and none of them identified a real vulnerability. curl’s maintainers linked this to a flood of AI-generated reports. With a language model, anyone can write a plausible report in minutes without understanding the code at all. A person still has to check every such report, and the maintainer spends hours on it that could go into the project itself. Dropping rewards or closing a project to outside contributions does not solve the problem, though. Along with the empty reports, the project loses the real fixes that open source depends on. Projects need a filter that sorts out weak contributions automatically, before a person opens them.

Paradoxically, AI itself can help build that filter, according to Gleb Khmyznikov, a Senior Software Engineer at Microsoft with more than 12 years of experience in software development. At the company, he is responsible for the infrastructure that keeps new releases of PowerToys, Microsoft’s open-source suite of Windows utilities, reliable. Khmyznikov set up UI testing for the project in which automated AI agents write the tests, and he reviews the finished result. With this approach, he is bringing PowerToys’ UI test coverage to 100%. In addition, as a Council Member of the Association of Information Technology Experts (AITEX) and a judge at the Code & Create Award 2026, Khmyznikov assesses other teams’ projects and sees how AI changes code quality in other software products.

Khmyznikov explained how AI helps a project cope with the flood of AI contributions and where people still fit into the process.

Gleb, at the end of January, curl stopped paying for vulnerability reports after a flood of AI submissions, and in February GitHub went further, letting repository owners accept pull requests only from collaborators or turn them off entirely. Maintainers are defending themselves against AI contributions however they can. What does a project pay for that kind of protection?

A ban takes the load off the maintainer here and now, but it catches both generated junk and a fix from someone who spent a week studying the code. For the project, this means bugs stay in the code longer. Outside contributors find bugs in conditions the core developers don't have: on different hardware, in different configurations, in other people's workflows. A small team can spend months finding such gaps on its own. In the end, both product quality and users' trust in the project decline.

Then what's the way out for a project that doesn't want to close, but can't check every generated patch by hand either?

Automated tests. These are programs that run the product and check that it works as intended. Every outside patch should go through them first. If a patch breaks something, the tests fail, the author gets an error message, and the maintainer never has to touch it. This works under two conditions. The tests have to be trustworthy, or their failures stop meaning anything. And they have to cover every part of the product, or a patch that breaks an uncovered area will slip through unnoticed.

In PowerToys, we started with the first condition. When I joined the project, its test baseline was broken. I restored it to a 95% pass rate, and the team could trust the test results again. With that baseline in place, we prepared and shipped release 0.95, which added a new utility and interface updates across several modules.

But someone still has to write those tests. Where does a project without a large team find people for that?

This is where AI can help. Today, AI agents can write tests based on user scenarios. You describe an action to the agent, for example, "the user opens settings and changes a parameter", and it writes the check, runs it, and looks at the result. If the test gives inconsistent results, the agent fixes it and runs it again until the result is stable.

Again, this is how we handle coverage in PowerToys. For this product, coverage mostly concerns the interface, meaning windows, buttons, and settings pages, and AI agents write the UI tests for it. That is how PowerToys' coverage is moving toward 100%, and a patch that breaks the interface fails the tests before a reviewer opens it.

There is an important caveat, though. This setup still doesn't work without a person. An agent can write a test that checks almost nothing, for example, confirming that a window opened without looking at what it shows. A test like that raises the coverage numbers but catches no bugs. That's why the final review stays with me.

AI, which caused the surge in patches, helps filter them, but the last word stays with a person. How do you decide whether a project needs a patch that has passed all the tests?

The patch has to fit the project's purpose. My own project led me to this principle. Before PowerToys, in November 2020, I released pwa-install, an open-source component that lets people install web apps on a computer the same way as regular programs. It now gets over 40,000 downloads a week, and more than 2.9 million in total, and more than three dozen outside developers have contributed code to it. Their patches could pass all the tests and still pull the component away from its purpose. So for pwa-install, I clearly defined what the component should do and which problems it should solve, and I check every incoming patch against that description. If a change falls outside it, I don't accept it, even when the tests pass.

The same principle can work in any open-source project. It's enough to write down what the project does and what it shouldn't do, and to add a rule for contributors that every patch has to explain which problem it solves. Then it's easier for the maintainer to reject a change that doesn't fit the project, even if all the tests are green. And the author knows from the start what's worth bringing.

So if an AI patch passes the tests and fits the project’s purpose, it can be useful?

Yes. AI assistants have become an ordinary development tool, used by beginners and experienced engineers alike. In early February, I was on the jury of the Code & Create Award 2026, an international competition where developers, designers and other IT specialists from around the world present their technology projects. Artificial intelligence and data have their own category there, alongside web services, mobile apps and games. This means the industry has already accepted AI as part of the work, and open-source projects will have to live with it too. What matters is what stands behind a patch. An author who uses AI as a tool reads what the model produced, understands every line and can explain why the change is needed. Such a patch is no worse than one written by hand, and sometimes better, because the author spent the time saved on checking it. The problem comes from people who send the model’s output without looking at it, and those are the patches that tests and clear project rules filter out.

You mentioned serving as a judge at the Code & Create Award 2026. Did you see the same quality problems when evaluating the competition’s projects?

Yes again, and it confirms that the question of quality goes beyond open source. With AI, developers build apps and add features much faster, but speed alone doesn’t make the result reliable. At a competition, projects are often judged by their demo, and it’s easy to mistake a solution that works in a single scenario for a finished product. So I paid attention to how the authors tested their work and whether they could explain how their solution is built. I was looking at the same gap I see in PowerToys: between a feature that worked once and a system that keeps working after dozens of changes. Both a startup with its first app and a mature open-source product run into it.

In that case, what do you think a maintainer's job will look like in a couple of years, when there are even more AI patches?

Maintainers will check code by hand less and less and spend more time deciding what the project should be. Tests will take over checking whether a patch works and whether it breaks neighboring parts of the product, and agents will write those tests. Two tasks will remain with a person: making sure the tests check the right things, and deciding whether a patch belongs in the project.

The maintainer's job will become closer to an editor's, who reads less text but is responsible for where the publication is going. Projects that start preparing for this now will find the transition easier. Those without tests will have to choose between closing and a flood of patches they can't keep up with.

Sign up to read this article
Read news from 100's of titles, curated specifically for you.
Already a member? Sign in here
Related Stories
Top stories on inkl right now
One subscription that gives you access to news from hundreds of sites
Already a member? Sign in here
Our Picks
Fourteen days free
Download the app
One app. One membership.
100+ trusted global sources.