We live in a time when more and more tasks can be delegated to AI. Code is written faster, solutions appear instantly, and the final result often looks perfectly acceptable to the end user.
It is convenient and fast. But together with that, it is possible to lose an important part of the whole process — the enjoyment of building things. Things like:
- finding an elegant solution for a non-trivial problem
- designing and applying a clean architecture
- releasing a product and receiving the first feedback from users
If you delegate not only routine tasks to AI, but the entire process itself, you may also lose the very reason many of us got into development in the first place — the joy of creating and the process of building.
This article describes only some of the moments that made building my own application genuinely enjoyable.
Elegant solutions in code
Let me give one example from development. The application has a filter by levels. It contains seven different values, and the user can select either one value or several at the same time. All of this needs not only to be processed in code, but also stored in memory. The most obvious solution is to create seven boolean variables, store each one separately, and manually build the final state every time. It works. But it does not look very elegant.
In the end, I implemented it in a much cleaner way: all filter states were combined into a single Int8 variable using a bitmask. This made the state compact and convenient to manage. I also moved the processing itself to a background thread.
On one hand, there is nothing fundamentally new here. Bitmasks have long been described in algorithm and data structure materials, and thread management is well explained in documentation. But combining solutions like this and seeing the final result brings a very specific kind of satisfaction. And there are many such moments during the development of an application.
This is one of the reasons why it is difficult for me to imagine development where the entire process is fully delegated to AI. Even if it can suggest a similar solution, the enjoyment of searching, understanding, and implementing simply disappears.
Well-designed application architecture
The application architecture started with a fairly difficult goal: the iOS application needed the ability to open any screen from any other screen while still keeping a clean navigation stack, avoiding memory leaks, and maintaining performance. At the same time, the application itself is much simpler than the architectural goals I set. But that is exactly why pet projects are valuable — they allow you to improve your skills and experiment with solutions that you may never encounter in regular work.
As a result, the application architecture includes several fairly advanced approaches for iOS development: Coordinator, Assembler, Dependency Injection, MVVM, and Observation. Designing and implementing this entire structure took a lot of time. But the enjoyment of good architecture turns out to be reusable.
Now that it is time for updates, adding a new screen happens quickly and calmly. And every such update once again brings satisfaction from the fact that the architecture was designed properly from the beginning.
With AI, a significant part of the application could be regenerated for a single new screen. But the process of this kind of generation is difficult to call engineering work. It cannot be compared to extending a well-designed architecture that a developer built and evolved personally.
User feedback
All of the things above gradually turn into something personal — a project that the developer starts treating almost like their own creation. That is why user feedback feels especially meaningful after release.
Every positive review is a small moment of euphoria.
“Convenient tool”, “Well-designed educational materials” — comments like these bring an incomparable feeling that all the work truly had meaning.
But negative reviews are important in their own way as well.
“It would be nice to add…”, “This part feels slightly inconvenient…” — after comments like these, you immediately open the project and start thinking about how to improve the product.
It is exactly this deep involvement in your own project that allows you to experience all these emotions. When an application feels not like a set of generated code, but the result of long and thoughtful work, the connection with the product becomes completely different.
AI is not our enemy
After everything written above, it is important to say this clearly: AI is absolutely not an enemy of developers. On the contrary, it can genuinely speed up work and help with a huge number of tasks. In my case, AI helped with many things:
- Routine tasks. For example, educational materials had to be assembled into XML following specific rules. AI handled this very well.
- Help during app publication. Texts, App Store questions, and various publishing details become much faster with AI.
- Small code-related things. While working on architecture, it is easy to forget even the simplest things. AI helps quickly recall a solution or syntax.
- UI and design discussions. Even with a finished design mockup, small UI questions constantly appear during development. In situations like this, AI becomes a good assistant for discussing solutions.
AI handles tasks like these really well. And at the same time, these are rarely the tasks that bring real enjoyment from development itself.
AI is an ideal assistant, but keep the enjoyment for yourself
AI can genuinely provide strong and fairly qualified help during development. It can answer many questions, remind you about different mechanisms, help with routine tasks, and even create a work plan for a pet project. In this sense, AI is truly an excellent assistant.
But the process itself means nothing to it. By delegating not only routine tasks, but the entire development process to AI, a developer loses the experience, the enjoyment of building an application, and the satisfaction of the final result.
So perhaps the best way to use AI is to keep it in the role of assistant while preserving the development process for yourself. Stay involved in the work, search for solutions, build architecture, release products, and enjoy the entire process of creation.