
I work in electrical installations, not in a software company. Outside my day job, I build and maintain an open-source music player for Android and Windows. It is an unusual combination, but it has taught me something about artificial intelligence that I rarely see in the biggest claims made about it: AI can make ambitious software projects more accessible, but it does not make the responsibility of building them disappear.
My project is called Levyra. I develop it independently, with the help of AI coding tools and the wider open-source ecosystem. What interests me most is not whether AI can produce a convincing block of code in a few seconds, but what happens to that code after it becomes part of an application people actually use.
It started with a problem I wanted to solve
The original idea was simple. I wanted my streamed music and the audio files I already owned to feel like one library, rather than two separate worlds. I wanted a player where I could manage my own collections without creating yet another account, and where the small details of listening mattered.
The practical work quickly became much bigger than the idea. A music player must handle unreliable networks, background playback, Bluetooth devices, changing queues, missing metadata and interruptions from the operating system. Something that looks straightforward on a screen can involve several layers of code working together, and a failure in one layer may appear somewhere completely different.
Levyra now uses Kotlin and Jetpack Compose on Android, with Media3 for playback and a desktop application built around Compose Multiplatform and libVLC. Those technical choices matter because they make the software more than a demonstration of an idea. They also mean that every change has to respect the behaviour of a real system, not just look right in a generated example.
Where AI genuinely helps
I use tools such as Claude and Codex to explore unfamiliar parts of a codebase, investigate bugs, compare approaches and draft possible implementations. When you maintain a project alone, context switching can be exhausting. One moment you are looking at an Android lifecycle issue, and the next you are trying to understand a network response, a database migration or a layout problem.
AI is useful at that moment because it can help reduce the time spent getting oriented. I can ask it to trace a specific execution path, explain why two components might interact badly or propose a small change with a clear purpose. Sometimes that saves a great deal of time, especially when the alternative is spending an evening searching through files before I can even start working on the issue.
But I have learned to treat its answers as proposals, not decisions. A model can produce code that looks reasonable while missing a condition that exists elsewhere in the project. It may solve the immediate symptom without considering what happens when a user changes a playlist, loses connectivity or returns to the app after several hours.
A music player is a good test of AI-generated code
Audio software is unforgiving in ways that a static demo is not. A screen can look perfect while music stops when the phone locks, a queue silently changes order or a download leaves a damaged file behind. These are not necessarily dramatic failures, but they are exactly the kinds of things that make someone stop trusting an application.
Consider preloading the next songs in a queue. On paper, it sounds like a simple performance improvement: fetch the next track before the current one finishes. In practice, you also have to think about what happens when the user skips several tracks, changes playlists, has limited connectivity or does not want the app using extra data in the background.
The same is true of a radio stream that suddenly stops responding. Finding another source is only part of the problem; the application must recognise the failure, avoid getting stuck, and tell the listener what happened. A code suggestion that covers the happy path is a starting point, not a finished solution.
Those cases have changed the way I use AI. Rather than asking it to “fix playback”, I try to narrow the problem, identify the relevant code and make it explain the possible side effects. I want to know what the proposed change might break before I decide whether to use it.
The difference between generating code and maintaining software
Generating a function and maintaining a product are different jobs. In a real project, a new feature needs to work with existing settings, saved data, user expectations and behaviours that may not be obvious from the task description. If a change improves one screen but makes another less reliable, it is not an improvement.
This is why I pay attention to the final changes, not just the explanation an AI tool gives me. I review the diff, check whether the proposed solution fits the architecture and test the affected behaviour. For more substantial changes, Levyra has documented quality checks, and the development notes explain how I approach testing and releases.
I also try to be honest about the limits of a test. If I cannot run something because a device or dependency is missing, that is an unresolved check, not a successful result. AI can make it tempting to move quickly from “the code looks correct” to “the issue is fixed”, and that is a habit I work against.
Real users are better than perfect-looking demos
Some of the most useful feedback comes from people using the application in situations I would never have thought to reproduce myself. They use different phones, different languages, different music catalogues and different listening habits. An issue that seems minor on my device can make an entire feature unusable for somebody else.
I follow bug reports and feature requests in Levyra’s public issue tracker. Sometimes a report is accompanied by a video or a description of exactly what went wrong; sometimes the only clue is that something “doesn’t work”. In either case, the important part is understanding the user’s experience before asking AI to suggest a fix.
This is also where working alone can be difficult. There is no separate support team, tester or release manager to hand the problem to. When I make a mistake, I have to investigate it, correct it and explain the change, and that responsibility has taught me more than any impressive-looking code sample.
Open source keeps the process honest
I chose to develop Levyra in public because I wanted people to be able to see how it works, not just what it claims to do. Its code, release history and discussions are available on GitHub. It also builds on ideas and components from other open-source projects, which deserve acknowledgment rather than being hidden behind the story of a single developer and an AI assistant.
That openness is particularly important when AI is involved. A polished result can hide uncertain decisions, copied assumptions or changes nobody has properly reviewed. Public code does not automatically guarantee quality, but it makes the work inspectable and gives other people a chance to challenge it.
It also changes how I think about credit. The AI tools I use are helpful, and the open-source community provides knowledge and building blocks I could not reasonably recreate alone. My role is to bring those pieces together, make choices, do the testing and take responsibility for the result.
The decisions AI cannot make for me
A tool can suggest adding a feature, but it cannot tell me whether the feature belongs in the application. It can propose a faster way to retrieve data, but it cannot decide how much complexity or dependence on an external service is acceptable. It can make an interface more elaborate without understanding whether it has become harder to use.
These are product decisions, and they involve trade-offs rather than one objectively correct answer. I have to decide when a feature should be optional, when simplicity is more valuable than novelty and when the right response to a proposed change is to leave the existing code alone. That judgement becomes more important, not less, when generating another implementation is so easy.
Privacy and transparency are part of those choices. Levyra does not require an account for its core experience and does not include user-tracking analytics. At the same time, streaming and online metadata rely on external services, so I think it is important to be clear about those dependencies instead of presenting any connected application as completely self-contained.
A smaller barrier to entry, not a shortcut around learning
I do not believe AI coding tools mean that software engineering has become effortless. They can help someone outside a conventional development career attempt projects that might once have felt out of reach, and I am a good example of why that matters. But the faster I can create something, the more important it becomes to understand what I have created.
Working on Levyra has pushed me to learn about architecture, debugging, Android behaviour, network failures, performance, licensing and the many responsibilities that surround a release. AI has helped me move through some of that learning faster. It has not spared me the frustrating parts, and I would be suspicious of any workflow that promised it could.
I am still one person maintaining a project in the time available outside my job. Some ideas take longer than I expect, some fixes need several attempts and there is always more I want to improve. That is normal, and it is probably a more useful picture of AI-assisted development than the idea that a prompt can instantly produce a finished product.
The lesson I keep coming back to is simple: AI can make writing software easier, but earning a user’s trust is still human work. That trust comes from what happens after the code is generated: checking it, admitting when it fails, listening to feedback and doing the unglamorous work of making it better.


