Intro
In this article, I walk through the process of building Phantom Pulse, highlighting how I used AI tools for planning and development. I share insights from exploring the LLM landscape, as well as the mistakes I made along the way. At the end of the article, I provide feedback and links to each tool I used, along with a brief explanation of my classification.
Why build Phantom Pulse (with AI?)
After being unexpectedly fired for the first time, I went to a remote location in Portugal's interior to relax for a bit and decide what I was going to do next. I was at a crossroads I had never been before—unemployed, with no immediate projects on my plate, and with no general sense of what lay ahead. Instead of dwelling on setbacks, I decided to make the most of my unexpected free time by experimenting with AI tools and exploring new workflows.
#VibeCoding was THE BUZZWORD during this time and, after all, my last two employers were becoming very AI-oriented, and while I was an early-access tester of GitHub Copilot, I never fully entrusted my workflow to our new AI overlords. So during this very offline vacation, I turned to Perplexity on my phone and asked it for a few project ideas using the Spotify API, which was something I had interest in working with in the past.
I skimmed through a few of its suggestions and one of them piqued my interest: A music visualizer. I often have friends over and my TV acts as the speaker, however it usually only shows the album artwork of whatever is playing in the background. If I could make a visualizer that would respond to whatever was playing in the background, I could make these trippy colorful effects and add a bit of ambiance to my own living room. I was excited - a bit too much as it would eventually turn out - so I asked Perplexity how I would approach building this and the approach made sense to me, so I asked it to break the project into tasks that I would then put into Linear. This spontaneous experiment marked the beginning of a fascinating journey into AI-driven development, blending planning, coding, and automation in ways I hadn't fully imagined before.
Armed with what seemed to be a doable project, I asked Perplexity for some branding elements like a logo and a color palette, and I was set on starting to work on it as soon as I grabbed a computer.
When hallucinations meet constraints
I got back home and I pulled the project conversation from Perplexity and started adding issues to Linear. Surely there must be a way to do this from an LLM, I thought. With the Linear MCP installed, I tried pasting the tasks to GitHub Copilot and to Cursor and hoped one of them would then automatically add the tasks to Linear. They were not able to complete the task—judging from the error messages—because Linear's MCP couldn't match my emoji-prefixed project title when I omitted the emoji in the prompt.
So I added all tasks manually to Linear, which did not take me a long time, but as a developer, alt+tabbing and copy/pasting over and over just feels dirty.
I remember Google I/O had just been around that time and they had released Stitch recently, so I gave it a prompt of what I wanted to build and it provided me with a nice-looking prototype, thus avoiding any kind of “dev design” one so often has to do.
So I started working at it: I set up the project with Vite, shadcn/ui, Tailwind, and Biome. I built most of the UI components and added all the contexts I would need for future state management. I implemented Spotify authentication with Supabase and, at the end of a few weeks, I had what can be described as a basic music player: I could listen to music, see what was being played, and pause/stop tracks. Time to connect what was being played to my React UI—and this is where it goes south.
When I was planning for this project—or rather, when I asked Perplexity to plan this project—I was not concerned at all with the visualizer reacting to whatever was being played in the background, as I had already heard of the audio-features API. I was planning on using it to pass some initial parameters to the visualizer, such as track tempo and energy. It turns out this endpoint had been deprecated in late 2024 and Spotify was not allowing any new applications to use it. I assume this was due to the increase of developers using it to train LLMs and other AI-related shenanigans. Despite the fact that there was an active marketplace scene selling API keys for apps with access to this endpoint, I tried another approach.
I tried to use a Web API for screen sharing that would allow me to share only audio; however, there was support for this only in Firefox. Before giving up on the idea of a Spotify Music Visualizer, I also considered making a desktop client (with Electron), but I would have to mess with OS-specific libraries to have it pick up any sound from the user's desktop.
In each of these approaches, I would turn to Perplexity or Gemini, which correctly told me that none of them would work. Still, I had been fooled before, so I verified my findings the old-fashioned way (Stack Overflow & GitHub comments) and decided to shift to something else—and this is how Phantom Pulse became a music quiz game. I did, however, use Warp terminal's agent mode and Gemini CLI, which did okay. Warp is my main terminal and I use it across all platforms; its recently launched Code editor is awesome for short edits, but as a non-CLI user, using these felt a bit clunky, especially Gemini CLI.
Implementation: Tools that powered the process.
So for actually building the thing I went out to experiment and, like all the cool kids, VIBE CODE!
The concept still feels wildly wrong for me, so I did not want to turn 100% to AI tools. Like I wrote above, the whole setup was made by me. I could have provided a screenshot of the prototype Stitch spat out, but I didn't. I built the skeleton and the router that would power the app.
I started by using Cursor when I wanted to create some React contexts for relevant parts of the application. I was not surprised by Cursor practically one-shotting this—after all, there’s plenty of documentation and examples out there on how to implement these. However, when I asked it to build a custom wrapper with react-query for my Spotify music player and authentication, it started providing code that simply would not work and was so bloated that I stopped using it altogether. ⚠️ For reference, I was using the free plan.
It was around this time that I received an email with an invite to the early access of Kiro. I installed it on my Arch-based machine and, to my surprise, the desktop icon was showing correctly (unlike Cursor 🙃). I read through their website to see exactly what it was capable of and decided to put it to the test by asking it to build the Playlist Selection component. This component would fetch the user's playlists from the API or react-query's cache. So before doing anything, it wrote three documents: a product definition, a tech document with the stack and basic commands, and a structure file that provided guidelines on where to store new files.
After Kiro understood everything about my project, including product details and tech specifications, it went to town on the feature I had just assigned it. Again, before starting any code, Kiro wrote a definition for the feature and asked me to validate multiple aspects of it. My friends, I felt like a PM and wondered if this is what they actually do with their time. As for the feature itself, it worked very nicely and, apart from a few tweaks and improvements, it did the job wonderfully, with the added value of having created some actual documentation for the app.
Because I was on the Early Access, I had a ton of tokens, and to my surprise, this ordeal had only burnt 30% of my tokens. However, this was still far more than the free plan and, given my current status, I decided not to commit to the Pro plan (like Cursor, priced at 20 USD/month).
The Power of Copilot Agents
It was at this point that I turned to GitHub Copilot again, as it was a familiar tool that I had been using ever since it came out. I sometimes tell the story of having it activated during a morning at work without knowing (early access would roll out to random users) and feeling like it was magic. I know how powerful it is, having used it before to create entire test suites, and I had been following the news and updates in the space to know that it is one of the best tools out there. The decision was made easier by the fact that the Pro plan was half of the other options out there. So I started my free trial with the intention of keeping the subscription afterwards.
Knowing Copilot, I am also aware of its limitations, so my usage of it consisted mainly of small tasks and code improvements while I did most of the heavy lifting—and it did pretty well at it. However, eventually, I found out about Copilot Agents and this was the game-changer. Agents allow me, from GitHub's dashboard (or now from the VSCode sidebar), to specify what I want built while I follow the process, which eventually culminates in a PR.
This effectively meant that I could work on something else while delegating other tasks to Copilot. Whereas up until this point I would stop doing whatever I was doing and let the AI tool take over, this tool just does its own thing while I do mine. Copilot had become my junior developer.
The new workflow - #copilot🤖
So for the next round of tasks, I decided to get back to the once-lost #VIBECODING spirit a little bit and when planning what I was going to tackle from Linear, I decided that I would delegate a few issues that I considered easy-but-boring to Copilot, and thus, the #copilot🤖 label was born.
Copilot did extremely well in these small tasks and bugs, sometimes even providing a screenshot when opening up a PR. It did show a little difficulty with Supabase-related tasks because I hadn't set up any environment variables or a mock environment for working on authentication-related issues.
I found myself doing actual code reviews and asking for changes from Copilot. Sometimes, if the change was too mundane, I would check out the branch and make the change myself in hopes of saving a few tokens, but I felt I could rely on Copilot to do most of what I asked.
One thing I found somewhat off-putting was that, despite the instructions specified in my AGENTS.md file, Copilot would generate tests even when I didn't request them. It would also sometimes add dependencies to some useEffect instances to satisfy the linter—despite having an ignore comment with an explanation above—which would lead to infinite loops. This behavior went away after I instructed it to ignore the exhaustive-deps linter warning. However, I still found myself checking out branches and running development servers to check if everything was working fine, making some changes, and merging Copilot's branch with master.
Before rating the tools and concluding this article, I think it is important to highlight how integrating these AI tools fundamentally changed our approach to software development. My little experiment showed that if you combine human creativity, planning, and care, you can speed up the workflow, reduce boring and repetitive tasks, and improve the final product. This synergy between human and machine not only optimized my workflows but also allowed me to be more creative and focus on the product.
Tools Used
Perplexity - 3/5
Usage: For search and planning, and for creating branding elements like logo, name, and color palette.
In the end, it either hallucinated browser capabilities or assumed I was using a deprecated API endpoint, forcing me to shift to a whole different end product. I'll take some blame for this, as I could not verify the information I was provided at the time and I did not double-check it when creating the Linear tasks. However, for searching the web for answers it is a great alternative to other tools like ChatGPT, Gemini, or even Google.
Linear MCP - 1/5
Usage: Tried to create project issues from a prompt.
Linear's MCP could not bulk-create the tasks from Perplexity, I'm assuming because it could not identify my emoji-titled projects from the prompts.
Stitch - 3/5
Usage: Prototyping the application.
While it did a good job with the prototype, I needed to repeat myself sometimes when prompting it. Also, the lack of any UI (at the time) to delete unused screens made the whole prototype very bloated.
Warp Terminal - 4/5
Usage: Main terminal + Warp Agent
It is an awesome terminal for those who prefer GUI-oriented software. It's got free, built-in AI features that I use daily as fast alternatives to looking up commands and system locations in Google, but for developing features it felt like it was not there yet. Plus, the paid plans are a bit too much for what a terminal tool should cost, in my opinion.
Gemini CLI - 3/5
Usage: CLI-based assistant
It worked fine for quick experiments, but as a non-CLI user it felt clunky compared to editor-integrated tools.
Cursor - 3/5
Usage: Developing
It took too many attempts to build basic features for the price. Also, the Arch-based build does not display the desktop icons correctly. I know their recent update features an Agents UI and it's an awesome tool, but for now I will stick with Copilot.
GitHub Copilot - 5/5
Usage: Developing
It's effectively the first of its kind and feeds on the world’s largest codebase. The Agents feature is a game-changer. Despite the fact that other tools are starting to have this feature too, this one seems the most cost-effective.
Kiro - 4/5
Usage: Planning & Developing
I only had a sneak peek of Kiro before I switched to test another tool, but I loved how it provided me with the entire app documentation and asked me a bunch of questions about the feature it was implementing. This feature in particular was a bit complex and Kiro delivered it with almost no issues.
Conclusions
In reflecting on the journey of building Phantom Pulse, it’s clear that the integration of AI tools has fundamentally transformed the way I approach software development. From initial ideation—fueled by AI-driven planning and brainstorming—to designing prototypes and automating repetitive tasks, each step was enhanced by the assistance of advanced tools like Kiro, Copilot, and others. These tools didn't replace my creativity or decision-making—they amplified them, allowing for faster iteration, better documentation, and even a touch of fun during what could have been tedious workflows.
However, this journey also highlighted the importance of human oversight. While AI can streamline tasks and generate impressive outputs, it’s essential to verify, adapt, and iterate on its suggestions to ensure alignment with your vision. Mistakes like encountering deprecated APIs or hallucinations serve as reminders that these tools are aids, not infallible sources of truth.
Ultimately, the Phantom Pulse project exemplifies a new era in development—one where human ingenuity is complemented seamlessly by AI collaboration. As these tools continue to evolve, expect even more streamlined, creative, and efficient workflows that empower developers to focus on what truly matters: building innovative, meaningful technology. The future of development is here, and it’s deeply human plus totally AI-enabled.
Top comments (0)