My PC wouldn't stay on for more than 30 seconds. Fans spun up, lights glowed, and then: dead. At first I suspected something simple, like a cable out of place. But it quickly became clear: the CPU was overheating fast, and the cooler wasn't doing its job.

The culprit was my be quiet! Pure Loop 240 mm AIO. After nearly four years of faithful service, it had finally given out. I tried everything I could: topping off the reservoir with distilled water, tilting and rocking the radiator to bleed trapped air, and even testing different motherboard headers in case it was a simple power issue. But the truth revealed itself in the quiet. The pump was lifeless: no vibration, no RPMs, no circulation.

And of course, this happened just as I was about to dive into Act II of Hollow Knight: Silksong. I had been waiting years for this game, enjoying every careful beat of exploration and challenge. The game had its rhythm, its flow, its atmosphere, all drawing me in, and then suddenly I was forced to step away, mid-adventure, because of a failing pump. The timing felt like a cruel joke. It was an unexpected boss fight, not in-game, but within the very machine I was playing on.

From First Open-Frame Experiment to Closing a Chapter

Looking back at the photos and videos of this build over the years, I'm struck by how much the PC itself became a canvas. My first open-frame experiment wasn't just about airflow or thermals. It was about showing off the components, highlighting the radiator and glowing fans, and leaning into the aesthetics of exposed hardware. Each revision added personality, featuring new angles, cleaner cable runs, and custom RGB accents. I even replaced the be quiet! logo with a custom backlit cover to mirror the logo on the GPU.

The AIO cooler sat at the center of all that. It gave the build a certain balance; the sleek radiator, the soft glow of the fans, the idea that water was quietly moving heat away while the rest of the system hummed along. It felt like the heart of the machine and leaned into the Matrix aesthetic I love so dearly.

But the story of this cooler, and why its failure carries weight, goes back much further. I've been building PCs since I was a kid. What started as a love of video games became a fascination with the machines that ran them. Learning how to plan out a build, diagnose problems, and execute on technical details came naturally because I wanted to make those games run better. Over time, that tinkering turned into a set of skills: troubleshooting, patience, an eye for design, and the confidence to dive deeper when something broke.

Those early years of building for my gaming hobby put me in an environment where software was never far away. At first it was drivers, patches, or config files, but soon I wanted to understand what was going on under the hood. That curiosity is what pushed me from hardware into software, and ultimately onto the career path I'm on today as a software engineer.

This particular system, with its Pure Loop AIO at the forefront, represented another milestone. I built it as a reward to myself after a significant promotion at WeaveUp, the startup I helped create. That shift was a big one: moving from DevOps into a Product Owner role. It was more than just a title change; it was recognition of the growth in my skills and the trust the team put in me. Building this PC was my way of marking the moment.

That's why its death hit harder than I expected. A pump failing after four years is ordinary, but the meaning I had attached to it wasn't. In a way, this cooler's end feels like closing a chapter; one that began decades ago, when I first learned to crack open a case for the sake of better frame rates, and has carried me all the way into a career of building software.

Trading Looks for Silence

So what comes next, when the centerpiece of the build is gone? I'm replacing the AIO with a low-profile air cooler, which fundamentally changes the build. The open-frame rig had always been about looks: the long radiator, the subtle glow of the RGBs under the custom log, the green accents balanced against the rest of the components. With the cooler gone, that centerpiece is missing. The visual aesthetic that defined the build for years has shifted into something quieter, almost skeletal.

But silence has its own beauty. For all the Pure Loop's strengths, its weakness was the pump whine. The fans were inaudible at idle, but the pump was always there, a constant, high-pitched reminder that liquid was being pushed through narrow tubes. It didn't matter how well the PC ran; that sound cut through the silence of the room.

Air cooling changes the equation. The low-profile cooler I've chosen is anything but flashy. When the fans are off, the system will be actually quiet: no whine, no hum, no reminder that something mechanical is running just out of sight. I may lose the visual flair of a glowing radiator suspended in open air, but I gain a different kind of aesthetic: the calm of silence.

It feels like a shift in priorities. Where once the build was about showing off, now it's about being present. Function redefining form.

Resilience in Building

A pump failing after four years isn't surprising. Components wear out, designs shift, and technology moves on. But each build I've done has taught me the same lesson: what matters isn't how perfect the system is on day one, it's how you adapt when things inevitably change.

This AIO's death came at the wrong time, right in the middle of a game I'd been waiting years to play. But that interruption is temporary. The bigger picture is what it represents: the end of one chapter of building, and the start of another.

I've been putting PCs together since I was a kid. My first build was completely solo with mail-order parts using a guide from the print edition of PC Gamer. I was driven at first by the desire to play games better, later by the curiosity to understand the machines themselves. That path led me from swapping GPUs and perfecting cable management to writing software and designing systems. Each broken part, each unexpected shutdown, each fix along the way has been another step in learning resilience, both in the hardware and in myself.

Now that this build moves forward, it's a little quieter and less flashy, but still mine. The AIO cooler may be gone, but the machine, and the lessons it carried, remain. Another real-life boss fight completed! Now onto the next act, both in Silksong and in my build journey.

Addendum: How This Post Came Together with AI

A quick note on how this piece came to life. Writing has never been my favorite part of the creative process — I can do it when I need to, but it often feels like a chore. If I hadn't leaned on AI tools to help me process my thoughts and get words on the page, this post likely wouldn't exist. So in the spirit of transparency, and as someone who believes in sharing methods that might help others, here's how I worked with AI to create it:

Diagnosing the Problem

When my PC started shutting down within 30 seconds of boot, I turned to OpenAI's ChatGPT 5. It helped me reason through the symptoms, guided me in refilling and bleeding the cooler, and ultimately confirmed that the pump had failed after nearly four years.

Writing the Story

Once I decided this was worth writing about, I used ChatGPT 5 to brainstorm the structure, draft the narrative, and refine the voice so it blended technical details with personal reflection. The result is what you just read.

Creating the Hero Image

For the artwork at the top of the post, I turned to Google's Gemini 2.5 + Nano Banana. I iterated on Matrix-inspired colors and a "boss fight" aesthetic, then requested a pass that blended some of Hollow Knight's atmosphere. That's how the feature image you see here was born. It's something I never could have made myself.

Documenting the Process

And finally, this addendum itself was written with ChatGPT 5's help, as I reflected on the process and what I wanted to share about it.

Why mention all this? Because I think it matters:

Transparency is essential — if AI played a role, readers should know.

As an educator at heart, I aim to demonstrate that AI can be a tool to amplify creativity, rather than replace it.

For anyone inclined to say "you could have written this yourself": yes, maybe. But I wouldn't have. Writing doesn't bring me joy. AI unlocked this story by giving me a partner in shaping it, while the image generation replaced a skill I don't have and wouldn't hire out. No human artist lost a commission here.

For me, AI was the difference between this post existing and not. And if sharing my approach helps someone else use these tools to tell their own stories, then that's a win worth noting.

I couldn't find this anywhere else on the internet, so here it is! The controller layout for Helldivers 2 is pretty intense. Visualizing it instead of mentally mapping it from the in-game button list can make it easier to learn all the different functions you need to spread democracy.

A big thank you to PadCrafter for creating such an awesome tool! It made creating these reference controller layouts a breeze. You can view the layout right here.

And many thanks to Arrowhead Game Studios for making this phenomenal game!

Also for reference, here are screenshots of the in-game controller keybind menus:

Since I discovered the Dracula theme, it's been my go-to color scheme for any app or new project. I use it everywhere: my terminal (Alacritty), my editor (VS Code), my other editor (Micro), my chat (Slack), my browser (Chrome), my notes (Obsidian), etc.

I also use it as the color scheme whenever I begin a new project. It gives the project a great look from the start and is one less decision I must make. The Dracula website and their GitHub repo are both awesome and include a ton of helpful information, but they don't have any simple references for the theme's colors. I always have to dig up the color codes whenever I want to plug them into a simple starter web page.

Hence this blog post and https://dracula-colors.stormhold.net. I created this webpage to serve as an easy-to-use visual and code reference for the Dracula theme. The webpage includes the main colors of the Dracula theme and the extended colors that have variations, such as lighter and darker shades and accent colors. You can view the code for the page on my GitHub.

I designed the page to be easy to use and navigate. Each color is presented in a thumbnail format, with the name and RGB value displayed below. Clicking on a thumbnail will copy the RGB value to your clipboard, making it easy to paste into your own code.

The webpage also provides CSS variables for each color so you can easily integrate them into your own stylesheets. The CSS variables are presented in code blocks; clicking on the blocks will copy the entire code snippet to your clipboard.

I hope this webpage is a valuable resource for anyone looking to use the Dracula theme in their web projects. And don't forget to check out the origins of the theme - it's a great story.

Thanks for reading!

Have you ever stared at the Git commit message prompt, struggling to create the perfect description of your changes? I certainly have. Writing Git commit messages can be tedious and time-consuming, but it is essential for maintaining a clear and organized codebase. A well-crafted commit message can make it easier for your team to understand your changes and track down bugs.

In this blog post, I'll share the Ruby script I came up with to make this process easier by using ChatGPT to automatically generate Git commit messages.

Now, let's explore the script. The script requires Ruby 2.6 or higher, Bundler, and git. It also requires an OpenAI API key, which you can obtain by signing up for an OpenAI account. Once you have your API key, set it in the OPENAI_API_KEY environment variable.

The script uses the TTY-Prompt gem to display prompts in the console and the Clipboard gem to interact with the clipboard. It also uses the Colorize gem to add colors to the console output and the Ruby-OpenAI gem to access the OpenAI API. The use of bundler/inline allows the script to be run on its own without having to install the gems separately.

require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'
  gem 'clipboard', require: true # A gem for interacting with the clipboard
  gem 'colorize', require: true # A gem for adding colors to the console output
  gem 'ruby-openai', require: false # A gem for accessing the OpenAI API
  gem 'pry', require: true # A gem for debugging
  gem 'tty-prompt', require: true # A gem for displaying prompts in the console
end

require 'json'
require 'openai'
require 'ostruct'
require 'time'

prompt = TTY::Prompt.new

OPENAI_API_KEY = ENV['OPENAI_API_KEY']
if OPENAI_API_KEY.nil?
  puts 'Please set OPENAI_API_KEY environment variable'.red
  exit 1
end

OpenAI.configure do |config|
  config.access_token = OPENAI_API_KEY
end

The script starts by checking if changes have been staged; it will exit with an error message if nothing has been staged. Next, the script sends the changes and a prompt to the ChatGPT API to generate a commit message based on the changes. The prompt includes guidelines for the commit message, such as using the past tense, including a subject line and a body, and wrapping lines at 72 characters.

It also times how long it takes for OpenAI to respond. Everybody likes metrics, right?

# Check if changes have been staged
staged_content = `git --no-pager diff --staged --unified=1`
if staged_content.empty?
  puts 'No changes have been staged. Please stage changes before running this script.'.red
  exit 1
end

# Start timer
start_time = Time.now

# Initialize OpenAI API client
puts "\n--------------------------------------------------------------------------------".white
print 'Initializing OpenAI API client...'.white
client = OpenAI::Client.new
print '✓'.green

# Form the prompt for ChatGPT
question = <<~QUESTION
  I need you to create a commit message for me based on these guidelines:

  - Use the past tense for the commit message.
  - Include a subject line and a body with a list of more details.
  - The subject line should be followed by a blank line
  - The subject line should be a single line that is 50 characters or less.
  - If the changes only include 1 file, then the subject line should include the file name.
  - The body should use bullets if appropriate.
  - The lines in the body should wrap at 72 characters
  - Add a blank line followed by "Commit message created with help from ChatGPT." to the end of the body
  - Don't output anything except the commit message contents so I can easily copy and paste it.

  Here are the differences for the commit:
  ```#{staged_content}```
QUESTION

# Send request to OpenAI API
print "\nSubmitting request...".white
response = client.chat(
  parameters: {
    # The name of the OpenAI model to use
    model: 'gpt-3.5-turbo',
    # The prompt to send to the model
    messages: [{ role: 'user', content: question }],
    # Controls the randomness of the response.
    # Lower values will result in more predictable responses.
    # Range: [0, 1]
    temperature: 0.25
  }
)

# Check for errors in the response
if response['error']
  print "✗\n".red
  puts "OpenAI API Error: #{response['error']}".red
  exit 1
end
print "✓\n".green

Once ChatGPT generates the commit message, the script copies the message to the clipboard and prompts the user on how to continue: either submit the commit with the generated message, edit the message before submitting, or exit without committing. The script handles the user's input and proceeds accordingly.

# Extract the generated commit message from the response
message = response['choices'][0]['message']['content']
Clipboard.copy(message) # Copy the generated commit message to the clipboard

# End timer and display summary
end_time = Time.now
elapsed_time = end_time - start_time
time_message = "\nTime to get message from ChatGPT: #{elapsed_time.round(2)} seconds"
puts time_message.yellow
puts "\nThe commit message has been copied to your clipboard and is displayed below".magenta
puts "\nCommit message generated by ChatGPT:\n".white
puts message.cyan
puts "\n--------------------------------------------------------------------------------".white

begin
  # Prompt the user for how to proceed
  user_input = prompt.select("\nWhat would you like to do?") do |menu|
    menu.enum '.'

    menu.choice 'Submit commit with this message', 1
    menu.choice 'Edit message before committing', 2
    menu.choice 'Exit without committing', 3
  end
rescue SystemExit, Interrupt
  # Gracefully handle exceptions like Ctrl-C or Ctrl-D
  puts "\nExiting without committing...".yellow
  exit 1
end

# Escape double quotes in the commit message
escaped_message = message.gsub('"', '\"')

# Process the user's input
case user_input
when 1
  puts "\nSubmitting commit...".white
  system("git commit -m \"#{escaped_message}\"")
when 2
  puts "\nOpening editor...".white
  system("git commit -e -m \"#{escaped_message}\"")
when 3
  puts "\nExiting without committing...".yellow
  exit 1
end

Here's an example of the script in use:

And here's a link to the asciinema recording: https://asciinema.org/a/579883

You can view the full script and my other helper scripts on my GitHub: https://github.com/ryderstorm/helper_scripts

This Ruby script can save time and help you create better commit messages. By automating the process of generating commit messages, you can focus on writing code instead of crafting messages. However, it's critical to use this tool appropriately and ensure that the codebase you are working on is appropriate to upload to the ChatGPT servers.

Creating this script was an excellent opportunity for me to explore the practical usefulness of ChatGPT and similar AI technologies as they relate to a developer's workflow. The script has greatly benefited my development flow and improved my codebase, allowing me to quickly generate high-quality commit messages with just a few keystrokes. I hope it can do the same for you!

Last week I parted ways with WeaveUp, the software company I helped build over the past seven years. Joann acquired the company in March of this year and, due to changing priorities at Joann, the team at WeaveUp was recently downsized.

I was the fifth person to join the company, hired as the sole QA on the development team. My job was to build an automated regression suite in Ruby to test the main web application. It was a dream position for me. I had total freedom to build the suite, run tests for the application, and solve problems the way I wanted.

That autonomy continued throughout my career at WeaveUp. I learned what it takes to build a software company from every angle: QA, application development, DevOps and infrastructure, client relations, project management, product design, hiring, and much more. I worked on every codebase in our stack, helped manage our transition to containers and Kubernetes, and came up with UX solutions for some of our most complex user flows. There were opportunities for me to contribute and make an impact at every level of the business.

WeaveUp not only allowed me to grow my skills and develop my career in tech but also to work with and build an incredible team. I was directly involved in hiring every new member of the team over the past few years. That team and the culture we created are a point of pride for me, especially regarding our accomplishments over the past year. We were running fast, making great things, and having fun doing it.

My time at WeaveUp was the best job I’ve ever had, no question about it. I went to work every day excited to build awesome things with awesome people, and we did just that. A special thanks to our president, Flint Davis: you strived to provide an excellent workplace for me and everyone on the team. Thanks for the chance to grow and succeed in my journey through the tech industry.

This kind of transition always comes with challenges. Thanks to everyone for all the love and support, especially my incredible wife, Victoria. I couldn't do any of this without you!

What's Next?

It is nice to have a chance to slow down for a few weeks. I'm fortunate to have this time to recharge before diving into the search for what's next. I can focus on being with friends and family over the holidays, not to mention catching up on my Steam backlog. Maybe even start a blog?

I'm not sure what direction I'll take for the next step in my tech career, but all the options in front of me are exciting. I'm looking forward to exploring them after the new year. If you've got any leads or recommendations, hit me up on LinkedIn.