Qt and a neural network: how a developer built an app in Visual Studio with almost no hand-written code

A developer conducted an unusual experiment: he attempted to build a real C++ and Qt application so that AI would write most of the code. In the end, the model helped bring a program for recording binaural sound to a working state, while the developer handled task definition, integration, assembly, and testing.

How the Task Was Set Up

For testing, they chose not an abstract example or a toy task list, but a practical task — an application for recording audio from a binaural head. This is a model of a human head with microphones in the ear channels, which allows you to obtain a recording with a sense of spatial presence when listening through headphones.

Previously, engineering software on MFC already existed for the device, but the author wanted to create a separate Windows application with a more user-friendly interface and a modern tech stack.

The technical constraints were quite standard: C++, Qt, and building in Visual Studio 2022. The first attempt started with a free version of a chatbot and quickly ran into a basic problem: the model got confused by the project structure and couldn't even produce a minimal application framework properly.

According to the author, the experiment nearly ended at this point. The situation changed only after switching to a paid version, which began to better maintain context, distinguish between files, and provide more coherent answers.

What AI Did

After switching to a stronger model, the work became similar to pair programming. The author showed the desired interface, described the next small task, and received code snippets for windows, handlers, and logic.

First, AI generated a minimal QtWidgets framework with a main window and menu, then the project gradually accumulated real features. Initially, the interface was built directly in C++ without Qt Designer, but later interface files appeared in the project.

As a result, AI took on a significant portion of routine development:

• Qt application framework and source file structure
• interface elements and menus
• signals, slots, and button handlers
• integration of recording, playback, and calibration modes
• part of the computational logic and audio processing via PortAudio

The solution structure remained quite simple: one Visual Studio solution, a separate PortAudio project, and a separate application code project. The author sequentially added fragments that the model suggested and brought the experiment to a working interface called BingoHeadSuite.

AI acted here not as a syntax hint provider, but as an executor that quickly writes standard and semi-standard code if the task is formulated precisely enough.

Where It All Broke Down

The most important conclusion of the experiment turned out to be not that AI can write code, but where the boundary of its usefulness lies. The model may know Qt documentation well and generate neat C++ snippets, but it doesn't hit Compile, doesn't see red build errors, and doesn't observe window behavior in a real program.

Therefore, almost every step still required manual checking: something needed to be renamed, somewhere a slot signature needed to be corrected, and sometimes the request had to be reformulated.

You wrote it nicely, and I'll go catch the compilation errors.

During the work, typical limitations emerged: the model confused variable and function names, repeatedly suggested already-made corrections, and sometimes reverted to old solution variants.

Separately, it became clear that the cost of the model matters: the free version couldn't handle even a minimal project, whereas the paid version was able to maintain the structure of multiple files and gradually build up the application.

However, the author notes an unexpected nuance: the free mode performed better at generating icons and simple visual sketches.

What This Means

This case shows that AI is already capable of covering a large portion of applied development, especially when it comes to boilerplate interface code, event handlers, and standard logic. But the role of the developer doesn't disappear — it shifts toward being a task architect, integrator, and tester. The more precise the task definition, the more useful the model; the closer the work gets to building, debugging, and modifying existing architecture, the stronger the need for a human again.