Thu May 22nd, 2025

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.