I had rebooted the laptop without really thinking about it. Just a normal restart. I was expecting the usual logo, a few seconds of waiting, then the desktop.
Nothing happened.
No logo. No error. No helpful message. Just a black screen.
That was the point where I stopped treating it like a minor problem.
This was not a spare machine or a test box. It was the laptop I actually used. My Linux setup was on it, Windows was on the same disk, and so were the files I cared about.
For a few minutes I just sat there going through the obvious questions. What had I changed?
What had I broken?
Was Windows still there?
Were my files still there?
The slightly embarrassing part was that underneath all of that was another thought:
I had built this system because I wanted something reliable.
And now it would not even boot.
That feeling has come up more than once while building JAZZ.
JAZZ is the Linux desktop I have been working on for AI engineering: running local models, building applications, testing them, red-teaming them and generally spending too much time in terminals.
But this is not really a post about the feature list.
The README can do that.
This is about the parts where it went wrong.
There were quite a few of those.
The corruption I never saw coming
The black screen eventually turned out to be filesystem corruption.
The shared partition used by Windows and Linux had developed cross-linked clusters, and over time that had damaged the boot.
There was no warning.
Nothing gradually got worse.
The machine worked, and then one day it did not.
I booted from a USB drive and chrooted into the broken system.
That was one of those Linux moments where you feel both completely in control and slightly terrified because you are typing commands directly into the thing that currently refuses to start.
I rebuilt the boot files manually and ran a filesystem check.
Then I waited.
The check came back clean.
I rebooted.
The machine started.
I remember actually exhaling when the login screen appeared.
Nobody else was in the room, which probably made the reaction more honest.
Paying by the hour to find out whether I was right
A few months later I had a different problem.
I wanted to know whether the AI side of JAZZ actually behaved properly on a serious GPU.
My laptop could run the code, but integrated graphics were not going to tell me much about real performance.
So I rented an RTX 4090 in the cloud.
That introduced a very different sort of stress because the meter was running.
Every minute I spent debugging was literally costing money.
I had also read enough about cloud GPU rentals to know that the machine you think you are renting is not always quite what you get. Sometimes the environment is more constrained than expected. Sometimes software listed as available is not actually there.
The instance I chose was supposed to have what I needed installed.
It did not.
So I ended up fixing the environment while paying for the privilege.
Eventually I ran the same code I had tested on my laptop.
The laptop result was around 155 milliseconds.
The RTX 4090 result was 2.4 milliseconds.
About 64 times faster.
I stared at the number for a second and then said something out loud to an empty room.
I do not remember exactly what.
Probably not anything sophisticated.
But that was the first time the performance side of the system felt real rather than theoretical.
Giving the whole thing to a machine that knew nothing about me
The test I cared about most came later.
I took a second laptop that had only ever run Windows and tried to install JAZZ using nothing except the public repository and the instructions.
No shortcuts.
No files copied from my main machine.
No “I know where this config really lives”.
Just the repo.
It failed.
I fixed the first problem and started again.
It failed again.
Then again.
Seven failures in total.
None of them was dramatic.
That almost made it worse.
One dependency was missing.
One path was hardcoded to something that happened to exist on my machine.
A stale lock file had been left behind after unreliable Wi-Fi.
There were small assumptions scattered everywhere.
On my own laptop, I had stopped seeing them.
A clean machine saw every one.
That was uncomfortable, but useful.
Every time I fixed something, I went back to the beginning and ran the process again.
I did not want a patch that worked once.
I wanted to know whether someone starting from nothing could actually reproduce the system.
On the final run, the second laptop booted into JAZZ.
That was probably the moment I started trusting the project.
Not when it worked on my machine.
When it worked on one that had no history with it.
The bug that turned out to be me
My favourite failure was the shutdown button.
It stopped working.
Naturally, I assumed I had broken the code.
So I spent a good part of the day looking in the obvious places.
Nothing made sense.
The implementation looked fine.
Eventually I discovered that the problem was not the shutdown code at all.
It was how I had been testing the machine remotely.
I had accidentally attached a process to the wrong login session.
The symptom appeared in the desktop, but the cause was several layers away from it.
The normal local desktop had never had the problem.
I had created the bug myself, then spent hours trying to find it in the software.
There is a useful lesson in that, although I did not particularly enjoy learning it at the time.
Sometimes the thing you are debugging is your own assumption.
I could have quietly fixed it and moved on.
Instead I wrote it into the build notes.
It seemed worth remembering.
What building it actually felt like
I am not sure there is a neat conclusion to any of this.
Building JAZZ did not feel like a smooth sequence of good decisions.
It felt more like this:
A black screen.
A filesystem check I was nervous to run.
A rented GPU charging me while I fixed something that was supposed to be pre-installed.
A second laptop exposing seven assumptions I had forgotten I was making.
And one shutdown bug that was entirely my own fault.
There were good moments too.
Seeing the machine boot after I thought I had broken it.
Seeing 2.4 milliseconds on the GPU test.
Watching a completely separate laptop install the system from the public instructions.
Those moments felt good precisely because the failures before them were real.
JAZZ is public now, but it is still early.
I expect people will find things I missed.
I hope they do.
If you install it and something breaks, I would genuinely like to hear about it: The repository is here:
https://github.com/holycowprojects/jazz The bugs, fixes and commits are all there too.
I would rather leave that history visible than pretend the project arrived fully formed.