A Better Way to Open an Uglier Window

Noctalia already had a Spotify search plugin.

It was almost perfect.

Almost.

I could open the launcher with Alt + Space, type /sp followed by a song name, and get matching results.

The only thing missing was album-cover caching.

Which sounds minor until you care too much about UI.

Without the covers loading properly, the feature worked, but it did not feel finished. So I fixed the caching.

Now I can open the launcher, search for a song, see the correct cover art, press Enter, and Spotify opens with the track already playing.

This is exactly the kind of unnecessary integration that makes a desktop feel personal.

It is also slightly absurd.

I still cannot get Spotify’s ugly blue title bar to match the rest of the theme.

The application itself refuses to blend in, but I can now summon any song from a perfectly themed launcher with its album artwork displayed correctly.

The difficult part was not making Spotify easier to use.

The difficult part remains convincing it not to look like a surviving component from Windows Vista.

I plan to extend the same launcher idea beyond music.

Anime, series, movies, YouTube, and anything else that makes sense to search without opening a browser first.

I will publish the code with light documentation.

A complete setup guide would probably be dishonest anyway. Linux desktops are too personal. Everyone has a different compositor, launcher, theme, package format, keybinding, and opinion about where configuration files should live.

The code can be shared.

The consequences are yours.

For now, the feature works exactly how I wanted.

Spotify still looks wrong.

But at least it now looks wrong more efficiently.

Ricing looks fun

At first, KDE looked fine.

Then I decided I wanted a taskbar at the top and an application dock at the bottom.

This was apparently enough ambition to destabilize the entire concept of a desktop.

I installed Noctalia because it gave me more control over the shell, the launcher, the widgets, and the overall look.

It also made my window management chaotic.

So I switched to Niri.

Niri worked.

Spotify did not like that.

Under KDE, Spotify blended in well enough. Under Niri, it suddenly looked like it had arrived from another operating system and refused to acknowledge the theme around it.

That was when I realized Linux theming is not one setting.

Noctalia can look correct.

Niri can look correct.

GTK apps can look correct.

KDE and Qt apps can look correct.

Ghostty can look correct.

Then Spotify opens with a blue title bar that looks like it escaped from Windows Vista.

Apparently, every application gets a vote.

The frustrating part is that “make everything match” sounds like one task.

It is not.

It is several theme systems, application toolkits, sandbox rules, and client-side decorations pretending to be one problem.

Still, one of the most satisfying parts of the setup came from Spotify.

I built a Noctalia launcher integration that can search for songs and display their album covers directly in the results.

That worked.

The ugly title bar remained, but the useful part finally felt integrated into the desktop.

I plan to extend the same idea to more media-related content.

That is probably the best summary of Linux customization so far:

The thing I wanted to fix stayed blue.

The feature I did not originally plan to build became one of my favorite parts of the system.

Making Fedora Last More Than Five Hours

When I bought this laptop in 2024, Intel had apparently discovered battery life.

Six hours on a Windows laptop suddenly felt possible.

Apple’s M-series chips were still the obvious benchmark for efficiency, but I wanted to stay on Windows at the time, so the Intel Core Ultra 9 185H felt like a reasonable compromise.

Fast-forward to 2026.

The battery now holds around 87% of its original capacity, Windows was filled with third-party services and bundled software, and the machine regularly used around 12 GB of RAM while doing absolutely nothing.

An impressive amount of resources dedicated to being idle.

Part of my move to Fedora was about reclaiming that performance and efficiency.

I also wanted animated wallpapers, something I had avoided on Windows out of fear that a wallpaper application would permanently reserve half the computer.

On Linux, I connected the visual experience to the power profile instead.

The power settings, display refresh rate, and wallpaper behavior now change together instead of acting like three unrelated systems.

When the session is locked, the computer is idle, or the display turns off, the animated wallpaper process stops and the screen drops to 60 Hz.

After five minutes of inactivity, the internal display dims to 30%.

In power-saver mode, it drops to 5%.

The objective was not to turn the laptop into a slow machine with a nice battery estimate.

I bought a 3K OLED display capable of 120 Hz because I wanted to use it.

The point was to keep the expensive features available when they make sense and stop paying for them when I am not even looking at the screen.

That is what I like about the setup now.

Performance mode behaves like performance mode.

Power saver actually saves power.

Balanced mode makes decisions based on the battery instead of simply having a reassuring name in a menu.

I moved to Linux because I wanted more control over the machine.

Apparently, that also meant personally negotiating when my wallpaper was allowed to move.

Working Is Not the Same as Understanding

During a technical interview, a Google Developer Expert in Data Analytics reviewed the Bitcoin Cash data platform I had built for a Data Engineer take-home challenge.

The project used Terraform, BigQuery, dbt Core, and GitHub Actions.

It was also my first time using Terraform.

The review was positive.

The reviewer especially appreciated how I had used AI. I did not let it complete the project for me. I used it to move faster through unfamiliar tools, then went back through the code, logs, and architecture until I could explain what most parts were doing.

Most parts.

When I was asked why I had configured the BigQuery permissions in a specific way, I could explain what the roles allowed, but not why I had chosen them.

The honest answer was simple:

I had let the AI decide.

The reviewer explained that BigQuery separates compute from storage.

A service account needs permission to create query jobs, but it also needs permission to read or modify the relevant datasets.

The configuration worked.

My understanding arrived later.

We also discussed Terraform.

I knew how to use plan to preview changes and apply to deploy them, but my state file was still stored locally.

That may be acceptable for a small personal project, but not for a team. Shared infrastructure state should usually live in a secured remote backend so it does not depend on one person’s machine.

He recommended that I learn more about Terraform’s plan, state, and apply lifecycle, as well as dbt Cloud and its configuration system.

The most useful part of the interview was not the technical correction.

It was the direction it gave me.

The engineers I spoke with were able to move between data analysis and data engineering depending on the problem.

That is the kind of profile I want to build.

My long-term goal is to become a data project manager, but I do not want to reach that role only knowing how to manage deadlines and meetings.

I want practical experience in analysis, engineering, infrastructure, and delivery.

I want to understand the work before I am responsible for leading it.

This project showed me that AI can help me enter unfamiliar technical territory quickly.

The review reminded me that a working system is only the beginning.

The next step is being able to explain every decision inside it.

A small thank you to Dither UI

I recently came across Dither UI, created by @grimcodes, and it immediately matched the visual direction I wanted for NotFinalDev.

Because the library and my website use different frameworks, I could not integrate it directly. Instead, I built a small implementation inspired by its dithered aesthetic and adapted it to my existing Markdown publishing system.

That currently includes dithered charts, step-based visual blocks and an editor that can insert editable JSON components directly into my notes and projects.

It is only a modest adaptation, but it helped NotFinalDev feel much closer to the monochrome, technical public notebook I had in mind.

Full credit to @grimcodes for the original library and the inspiration behind it.

Connecting the dots between dbt, BigQuery and Terraform

I recently completed a technical take-home assignment that required me to build a small data platform using Terraform, BigQuery, dbt Core and GitHub Actions.

I had already encountered most of these tools separately. The assignment forced me to understand how they work together as one system.

Terraform defined the infrastructure and permissions.

BigQuery stored the data.

dbt transformed it into tested analytical models.

GitHub Actions checked that everything still worked when the project changed.

The part that taught me the most was IAM.

Creating a service account is easy. Understanding which permissions it needs, where those permissions should be assigned and how dbt or a CI pipeline authenticates with it is where the architecture starts becoming real.

I also gained a clearer understanding of the separation between staging models and data marts.

They are not merely different folders containing SQL.

Staging models prepare and standardize source-oriented data, while marts expose business-oriented models intended for analysis and reporting.

I am not claiming to have mastered the entire stack after one assignment. But dbt, BigQuery and Terraform now feel connected rather than theoretical.

I am preparing a longer article covering:

• The architecture I implemented
• The Terraform resources
• BigQuery datasets and IAM permissions
• The dbt project structure
• Staging and data-mart models
• Data tests
• GitHub Actions
• The mistakes I made
• A reusable playbook for future data-engineering assignments

Sometimes the best way to understand a data platform is to be asked to build a small one from nothing.

Local AI Is a Necessity

Local AI matters to me because I do not want large companies to have free access to my personal data, my family’s data, my code, or my private documents.

Independence came first.

That became more important as Windows pushed more telemetry, more accounts, and more cloud integration. I cannot stand the idea behind “you will own nothing and be happy.”

I would rather own the machine, the model, the storage, the electricity bill, and the consequences of whatever I break while setting it up.

Local AI is not only about privacy. It is also about leverage.

Frontier models are becoming more capable, but most of the strongest systems are closed. We do not control their weights, pricing, availability, policies, or long-term direction.

If open models and local infrastructure do not remain competitive, individuals and smaller companies will lose what little leverage they still have.

I believe everyone should eventually have access to a local model for personal tasks.

You do not need enormous compute to summarize documents, help with taxes, search private files, draft emails, organize notes, or handle basic everyday questions.

These are also the exact tasks where privacy matters most.

What matters to me is simple:

• private data;
• control over the model;
• predictable costs.

I am willing to sacrifice electricity and setup time for that.

Cloud models still win on context size, speed, availability, and raw capability. A local system does not need to beat them at everything.

It only needs to become useful enough that privacy does not feel like choosing the worse tool every time.

My definition of success is reaching a point where OpenAI, Anthropic, or any other external provider never needs to go near my codebase or private documents.

The models can change.

The hardware can improve.

The stack can break repeatedly.

But the boundary remains mine.

Autopilot Does Not Teach You How to Drive

AI became useful before I had time to form a proper opinion about it.

It simply arrived and became better than me at many of the programming tasks I least wanted to do.

Mostly frontend code.

I do not miss writing endless interface boilerplate. I am not nostalgic for moving a button twelve pixels, fixing one responsive layout, then breaking another one by breathing near the CSS.

At this point, I see AI as something close to an IDE: not magic, not a replacement for understanding, but increasingly difficult to ignore if you want to work efficiently.

The problem is that people exaggerate what AI can do because many of them do not understand machine learning or neural networks.

The model does not understand the world the way we do.

It produces its best guess and presents it with enough confidence to make us wonder whether we misunderstood the world instead.

That is useful.

It is also dangerous.

I do not think AI teaches programming.

Saying that would be like claiming autopilot teaches you how to drive.

A tool is most beneficial when the person using it already understands the task well enough to recognize when the tool is wrong.

Beginners should be careful with AI until we reach a point where programming concepts are universally understood and AI writes code the way a compiler translates a language into machine instructions.

We are not there yet.

Today, it can give you working code before you understand why it works, which is a very efficient way to borrow technical debt from your future self.

Local AI matters to me for another reason.

It is one of the few parts of the AI ecosystem that individuals can still build at their own scale.

You can invest in hardware.

You can run open models.

You can experiment with open harnesses.

You can create useful systems without owning a data center or having several billion dollars available for “research.”

That matters because we should not allow a small group of wealthy companies to gain an irreversible advantage over the entire technology industry.

Local AI is not only a hobby.

It may be one of the best technical investments an individual can make right now.

AI has probably made me ten times more productive.

But that does not mean I now need to produce ten times more work.

The weight of the work has shifted.

Less time writing every line manually.

More time deciding what should be built, checking whether it is correct, connecting systems, understanding consequences, and fixing the confident nonsense generated along the way.

So the real challenge is not keeping up with AI’s speed.

It is becoming at least twice as intelligent myself.

Not by thinking faster.

By developing broader knowledge and better judgment.

Because the machine can generate more than I ever could alone.

Someone still has to know whether any of it is a good idea.

I Grew Up With Windows and Somehow Outgrew it

I’ve used Windows since Vista, so I don’t really hate it. I think I’m just disappointed by what it became.

Going from Windows 7 to 8, 10, and 11 felt less like watching an operating system evolve and more like watching Microsoft repaint the same old house while leaving the broken plumbing untouched.

The Control Panel is still hideous. Bluetooth still behaves like dark magic. Half the settings live in a new interface, while the other half are hidden in a menu that looks like it survived three corporate reorganizations.

Then I upgraded from 16 GB to 32 GB of RAM, and Windows somehow decided it needed nearly 10 GB at idle.

At idle, guys.

We lost the plot.

Meanwhile, macOS became more polished, and Linux kept offering more control, personalization, and possibilities. They made using a computer feel exciting in ways Windows gradually stopped doing for me.

I wanted Windows to bloom into something cleaner, lighter, and more coherent. Instead, it became heavier, noisier, and increasingly full of things I never asked for.

I’m not angry, really. I’m just sad that Windows never became the version of itself I thought it would.

The only thing still keeping me around is Marathon.

So Bungie, please put Marathon on Linux.

Seriously.

Marathon on Linux.

I am trying to leave.

Nothing here is final

I’m using this space to document what I’m building, what breaks, and what I learn along the way.

Local agents, cloud agents, code, data, experiments.

Some things will ship.

Some things will stay unfinished.

Both are worth documenting.

Also shoutout https://www.ascii-magic.com