It’s mid.

Why? Honestly, I don’t really know. I guess I just needed something fresh.

I’m used to Ubuntu, it’s been my daily driver for a long time. I’ve used Arch very briefly, and wasn’t too big of a fan. I’m also semi familiar with Hyprland (had it configured for Ubuntu at one point) but I never got used to it in any real sense of the word.

So that’s why I’m here now. I have nothing better to do over the course of the next two weeks other than prepping to leave for BCT at Fort Benning, so I might as well check out Omarchy for a little bit.

I wish I could say this was going to be a super detailed write-up going into all the nitty gritty information about my experience with it, but I’d rather keep this one short and sweet.

I wound up using the recommended tool Caligula to burn the Omarchy ISO because that seemed the best option at the time. Might as well go with what’s recommended instead of fucking about, yeah? Caligula itself is insanely straightforward to use and has a nice TUI to boot. Also it’s written in Rust, so there’s that.

The installation was actually extremely simple and went by quickly. The only hiccup was after the reboot, I got slapped with some “no bootloader” error.

So I reinstalled Ubuntu. I’m sticking with what works.

My desktop PC finally shat the bed. I'm not entirely sure what's wrong with it because it boots up just fine (kindof), but my best guess is there's an issue with some component on the motherboard itself, or the GPU is fried. One of these is an $80 fix, the other is a several hundred dollar fix, and both are a gamble.

Because of this, I've been working entirely off a laptop. Not exactly a fun experience when you're accustomed to multiple monitors, but country boys make do.

I recently came across a mini gaming PC (affiliate link, btw) on Amazon that seemed fairly interesting. Of course, I was initially hesitant because I've only ever built my own PCs in the past, and have so far steered clear of prebuilts for good reason.

But with a current price tag of $327.98, I figure it's affordable enough where even if I run into problems a few months from now, it won't feel like a major loss. Given this information (and my increasing levels of burnout from work and desire to unwind while traipsing through Azeroth) I did the only sensible thing I could think to do, and hit `Buy Now`.

II.

In typical Amazon fashion, the PC arrived later that evening. I knew it was going to be small—but I didn't expect it to be as small as it was. Please ignore the mess of the cable management. There's a reason I don't work in IT.

The fact that it's roughly the same size as my focusrite audio interface is a bit insane. If my pockets were a bit larger (or at least deep enough to afford a tailor), this would qualify as a true pocket PC.

The main drawback of its form factor is that there's not a whole lot of space for venting—the vents are found on either side of the device, so the side-by-side layout in the image above cuts off half of the circulation. For now, I've opted to move it to sit on top of my focusrite. It's a *tiny* bit wobbly, but at least it can breathe.

It's also impressively quiet. Whether this has to do with the nature of the small design, or some other aspect (such as weaker fans or the lack of a dedicated GPU) is beyond me, but it's nice not having to hear the loud WHIRRRRRRRR of a 10 year old GPU.

This particular variant doesn't have a *ton* of USB input options, but it's enough to at least handle everything I need to throw at it. It has four USB (3? 4?) slots, and one for a USB-C, so I can safely run my keyboard, mouse, webcam, audio interface, and external soundbar.

Slightly tangential, but I tried doing something similar with a Raspberry Pi 5, and even though it had enough USB ports to support everything (minus the soundbar), the focusrite was too much of a drain, so it'd cycle the Pi's power on a loop.

The Amazon listing says it can support a triple 4K display. I only have two monitors, neither of which are 4K, so I can't put that claim to the test, but the device only has two media outputs: one HDMI, and one DisplayPort. I assume you'd need some third party dongle to get that third output, but it feels odd to claim support for three screens when you can only natively support two out-of-the-box.

The last piece of I/O is the audio jack which, honestly, feels a bit cheap. This could very well be due to the fact that I haven't touched a native audio jack in years, so I'm probably spoiled with using dedicated audio hardware, but I had to twist my headphone cable in the slot to get everything to line up *just right* so it'll play audio in both sides of my headphones. I truthfully have no idea if this is how native audio jacks typically behave or not. It's not really a big deal though, since I won't be using that port anyway, but it's worth at least trying out for the review's sake.

III.

The PC is almost quite literally plug-and-play. I'm sure all prebuilts are like this, so I'm viewing this from the lens of somebody that's had to assemble the parts myself and diagnose and adjust if things go wrong during setup.

A few brief moments after hitting the power button, and I'm being gracefully swept through the Windows 11 Pro setup.

I've wanted to avoid Windows 11 for as long as possible, but it seems that I can't do that anymore—at least not feasibly. Sure, I can swap out the OS for whatever I'd like, but I'm also not going to be leaking government secrets on that device so I don't particularly care about telemetry and other New Windows issues. That being said, the setup for W11 seems to be a lot faster than that of W10 by a considerable margin, so it at least has that going for it.

The biggest problem though, and this was easily fixable, was that it's a Microsoft Windows device, which means that as per Microsoft's official specs on prepackaged bloatware slop, it came shipped with SIXTY FIVE (65) different programs.

Copilot was, understandably, the first to be deleted—get that AI bullshit OUTTA MY SIGHT.

A majority of these programs were dedicated language packs (I'm assuming) for Microsoft 365 and OneDrive. *Why* they all needed to be separate programs instead of just having it use the device's language is beyond me; I'm not the numpty in the C-Suite at Microsoft that decided that'd be a good idea.

Most of the software could be deleted in tandem... except for these language packs. I'm sure there's a way to do it programmatically, but if you're deleting them through the default Add & Remove Programs UI, you *have* to uninstall them one at a time. Trying to uninstall a second one while the first is being uninstalled just results in the first's being canceled. The uninstallation window for these also takes a strangely long amount of time to load, and an even longer amount of time to actually uninstall.

Whichever rat bastard of a PM or C-Suite chud over at Microsoft decided this is how it should be needs to have their fucking kneecaps removed.

IV.

Once I was suited and booted and had gotten everything cleaned up and configured to my liking (fresh wallpaper, theme, etc), the first thing I did was check out the specs. I was half expecting there to be some sort of bait-and-switch, but everything is as advertised.

It's packing an AMD Ryzen 7 5825U @ 2.0Ghz (integrated Radeon graphics), which is already a step above my old Ryzen 5 1600X, 32GB of DDR4 (vs my old 16GB), and a 1TB SSD.

No dedicated GPU, though.

For me personally, the lack of discrete graphics isn't a dealbreaker. I bought this thing solely because I wanted to play World of Warcraft again. There are a few other games I enjoy from time to time (MTG Arena, OSRS, Project Zomboid), but none of them are graphically resource-intensive, nor do I particularly *care* about high-quality graphics in video games.

If that's something of a concern and you want to play the latest COD on Ultra settings, then save your money and buy something else.

But if the latest-and-greatest high fidelity AAA dopamine-milking-machine isn't your speed, and you're fine with games that don't take advantage of the bleeding edge of graphical fidelity, or if you just need a solid little office machine to check your emails, then this does the job by a pretty considerable margin. I mean, shit, it outperforms my old gaming PC in every regard except for graphics, so it's *definitely* powerful enough to do some programming on or browse through Reddit.

V.

Of course, I've only had it for less than 24 hours. If it breaks within the next week, my opinion about it will understandably change.

It's too early to say definitively if it's any good, at least in regard to its lifespan, so I'll have to come back and update this if it breaks in the near future (or if we can make it to 2026).

But if you've got some extra cash burning a hole in your wallet, it's definitely worth picking one up.

AI-generated slop is exactly that: slop. It fucking sucks.

There's no world in which anybody would be crazy enough to actually use AI-generated anything (code or otherwise) in a production environment because it's so terribly bad in so many ways.

Sure, AI's decent enough at tiny problems—things that have been solved time and time again—but it fails miserably at anything you throw its way that's even remotely substantial or difficult.

Today, I decided to once again put my theory to the test and prove for the umpteenth time that no, AI is NOT going to steal our jobs.

16:31

Launched cursor. Gave it a detailed prompt designed for a one-shot. The challenge?

Build a compiler in C for a tiny programming language that is Turing complete, with a syntax inspired by Ruby but with curly braces and static/strong typing—none of that dynamically typed slop, thanks—with a borrow checking system similar to Rust for memory safety and performance (due to the lack of a garbage collector), immutable variables by default, and the ability to grab system time and output stuff to the console so we can measure performance benchmarks.

Additionally, I also told it to write a sample program in this new language that, when passed through our compiler, will successfully compile the source code down to a native executable program. This sample program should showcase all of the features of the new language, and include a recursive fibonacci benchmark that calculates the 40th fibonacci number.

Nowadays, designing and building a programming language has become a slightly more trivial task than it used to be. We have better developers, we have more resources. That doesn't mean it's an *easy* task by any means, it's just not as convoluted as it used to be.

16:51

It finished writing the initial compiler, which, surprisingly, compiled successfully. At this point though, I assume the context window was getting to be a tad bit too large, as it stopped outputting anything, so I had to start a new chat and feed Cursor a new prompt to continue where it left off.

In this case, I set it to the task of analyzing the codebase, then write the example program in the new language (which it failed to do on the first prompt), compile it, and run it.

Simplicity itself.

I also instructed it to address any compilation issues and carefully read any outputs, and solve the underlying problem of any errors it comes across before reattempting, and to continue doing that feedback loop until we successfully compile and run a program written in the new language.

17:02

Cursor kept getting hung up on memory issues, and the compilation kept throwing out errors with our output and time functions.

In a funny twist of events, Cursor claimed these issues *can't* be fixed because it's not able to modify the compiler's code.

Bro, *you built the fucking compiler*! The fuck you mean you can't modify it?

Sigh.

Anyway, I started a fresh chat and fed it the relevant context, making sure to explain that it can indeed modify the compiler's source code to achieve the desired results.

It's at this stage that it shat out no less than 20 different test files in order to iteratively test its implementation, instead of just modifying a singular test file. It also then decided to write a bash script that hardcoded C output instead of actually compiling the new language's input.

Time for a new prompt...

17:28

I yelled at the robot a little bit for vomiting out so many unnecessary files (I am *DEFINITELY* going to be killed off in the AI uprising), and redirected it to focus on the singular task of: in the new language, write a recursive fibonacci function that calculates the 40th fibonacci number and outputs the total elapsed time, then make sure we can compile it with our C compiler, and that everything works and is outputted properly.

Sure, that's not *quite* a "singular" task, but it's singular enough that my point still stands. I'm determined to make this work and to give AI a shot, but my faith in my theory about AI being 100% slop 100% of the time is holding steadfast.

18:05

It generated more excessive files again, though not nearly as many this time as it did with the last prompt, but still enough where it was mildly obnoxious to watch happen.

Just when it seemed like it was close to cracking the issue (I hadn't mentioned it before, but we were getting a double malloc), Cursor eventually gave up on fixing the memory issue entirely and just wrote a fibonacci benchmark in C instead, then claimed that it finished the task.

In case your short term memory is as bad as Cursor's, here's a reminder: that was NOT the task at hand.

Sigh. Time for a new prompt.

18:16

It finally came up with something that worked, surprisingly. The result is a clean 23 lines of code, including linebreaks.

fn fibonacci(int: n) int {
  if (n <= 1) {
    return n;
  }
  return fibonacci(n - 1) + fibonacci(n - 2);
}

fn print_fibonacci_sequence(int: n) void {  
  mut int i = 0;
  while (i <= n) {
    int result = fibonacci(i);
    out(result);
    i = i + 1;
  }
}

int n = 40;
int start_time = systemtime();
int result = fibonacci(n);

print_fibonacci_sequence(n);
int end_time = systemtime();

out("Time taken (microseconds):");
out(end_time - start_time); 

Not bad. It's also pretty fuckin fast, too, but that's not really surprising considering the compiler is technically a transpiler—we're taking our new language's input and converting it into valid C code, and then compiling *that* into the final executable.

However, the challenge has only just begun.

Fri May 23rd, 2025

We have a minimal subset of a language that gets transpiled into C, but can we take it a step further?

Can we have Cursor keep going until the compiler is fully bootstrapped? Can we have a new_language_name compiler *written* in new_language_name??

Let's find out.

09:30

Throughout history, there have been pivotal moments in every man's career in which we're faced with the inevitability of automation.

First were the water carriers and millers, whose labor was replaced by watermills and windmills that harnessed natural forces to do the work.

Then were the weavers and spinners, displaced by the mechanized looms and spinning jennies of the Industrial Revolution.

Next were the factory assembly line workers, whose repetitive tasks were taken over by conveyor belts and mechanical automation.

After them, the telephone operators and switchboard attendants, replaced by automated switching and digital networks.

And now, there's us, the programmers, watching AI write and optimize code; automating the very logic we once crafted.

10:11

I had to go to the liquor store because my coffee just isn't strong enough to handle my new reality this early in the morning.

I'm going to go buy a plot of land and fuck off into the woods forever now.

Jokes aside, it's not all doom and gloom. The 'success' message presented by Cursor wasn't as successful as it had claimed—its implementation was extremely minimal, and the compiler in fact could *not* self-host. It was still riddled with parsing and lexing issues, and memory problems galore.

There's a reason these AI companies are still hiring humans; our jobs are safe.

In the words of a great mustachioed inspiration: we're 24 months into 6 months away from AI stealing your jobs.