Fuck AI.

Published · Updated

Death of programming

I love computer programming—and I’m pretty damn good at it too. In the field of software engineering, the term imposter syndrome gets thrown around a lot. It refers to when people doubt their abilities and question if they belong in the field, despite their accomplishments. I’ve never experienced imposter syndrome but apparently some people do feel this way.

Then there are the people are actually imposters. They are the ones who are only here for the paycheck. They don’t work on personal projects and they never learn about computers on their own. They want instant results and they’re satisfied with doing the bare minimum. So, much like drug addicts and heroin, imposters and AI are a perfect match for each other. This deadly combination is destined to ruin the programming hobby for everyone.

AI enthusiasts will jump at the opportunity to show you all the cool things AI can do. They’ll say, “Look at this website I built using Codex in one day!” I’ve tried using a few of these AI tools and I can’t deny that the results are impressive. Some readers might wonder then, why is AI such a bad thing? Let me try my best to explain.

Lost beginners

Think about how ordinary people use computers. They spend a lot of their time using the web browser to write emails and shop online. Most people are proficient at navigating the web (typing a URL in the address bar, clicking on hyperlinks, etc.) but if you ask them what a website is, they will struggle to give you an exact answer. They might say, “A website is a place on the Internet that you can visit.” So they understand how to interact with the thing in question but have no idea how it actually works. This is the most important characteristic of an IT professional: the desire to understand how things work. By the way, here is the definition I would give without being overly specific.

A website is a collection of HTML documents made available by a webserver under a domain name.

They say knowledge is power and that is especially true for computers. Learning to program unlocks a whole new world of possibilities. It’s like when you acquire a powerful weapon in a video game. Now instead of just playing games made by others, you can create your own. When your computer has a software issue, instead of slamming the keyboard in frustration you can fix it yourself. The stories you hear about hacking no longer elicit fear, but instead curiosity about the exploits involved and pity for the victims who didn’t know better.

But as for any other discipline, the journey from beginner to expert is long. What I know today is the culmination of thousands of tiny experiences, all fitting together like pieces of a jigsaw puzzle. I learned Java straight out of a textbook, web programming from my high school robotics club, and C (and C++) from my university courses. Even auxiliary topics like building my own PC and using Linux have taught me useful things. Everyone needs to seek their own path.

Someone who has just started learning HTML and CSS might write something like the following. And yes, I know HTML is not a programming language (it’s just markup, there’s no logic) but that’s beside the point.

<!doctype html>
<html>
  <head>
    <style>
      #special-word {
        color: #ff0000;
        font-weight: bold;
      }
    </style>
  </head>
  <body>
    <p>This word is <span id="special-word">red</span>.</p>
  </body>
</html>

Getting under the hood like this and seeing the guts of a webpage is quite fascinating. Experiences like this show beginners that nothing is out of reach, so long as they have persistence and curiosity. However, some may get discouraged at this point, maybe because HTML’s syntax is too verbose or the pages they’re building don’t resemble real websites. They want to see results faster.

A few years ago, the concern was that new web developers would jump straight to learning frameworks like Angular and React without first learning the basics (HTML, CSS, and JavaScript). That concern has been made obsolete by AI tools that—like the Devil—tempt beginners with easy shortcuts. Just look how the official Angular tutorial has a section labeled “Using AI for Development”. Using AI to learn is like taking a course and attending all the lectures without doing any of the homework. You believe that you’re learning but then you fail the final exam because you didn’t absorb the material.

Telling beginners to learn with AI is irresponsible. Doing so is to rob them of valuable learning experiences and to impart lifelong laziness. I’ve always believed that working hard is a virtue. It does not pay to take shortcuts. With AI everywhere, I worry that the next generation of programmers will be severely lacking in knowledge and skills.

Vibe killer

We software engineers have to deal with a lot of bullshit in our professional lives. First of all, the job application process is brutal. Even if you have great qualifications, don’t be surprised if it takes hundreds of applications before getting a response. After that you’ll need to pass multiple rounds of behavioral and technical interviews. Once you start your job, you’ll be inheriting old codebases in various states of disrepair. Unless you’re working for a startup, in which case you’ll be expected to build everything by yourself.

Bosses will like it if you keep up with the latest tech trends. Some are fine, such as encouraging people to use passkeys instead of passwords. But most trends are just a pain in the ass.

Vibe coding and agentic coding are the latest buzzwords to add to our misery. There may be some difference between these two terms but I really don’t care; it’s all horrible. Now we’re being encouraged—and expected—to use AI for writing code and documentation, performing code reviews, generating test cases, and debugging. Some companies are already setting quotas for how much AI employees must use. Choosing to use AI yourself is one thing but forcing others to use it is where I strongly object. You might have heard this quote from Jensen Huang, the CEO of Nvidia.

That $500,000 engineer, at the end of the year, I’m gonna ask him, “How much did you spend in tokens?” If that person said $5,000, I will go ape something else. If that $500,000 engineer did not consume at least $250,000 worth of tokens, I am going to be deeply alarmed.

Normally when you do a performance review, you ask questions to ascertain how well the employee is doing his or her job. Instead, Jensen Huang’s priority is finding out how much money the employee gave to the AI companies that Nvidia invests in. I truly don’t believe there is any value to be gained from spending $1,000 compared to $10 on tokens per day. I think even Jensen Huang would have to admit this, but he can’t stop shilling for AI. Can’t we just measure employee performance normally instead of making this a competition about who can waste the most money?

The only developers who want AI are the ones who are bad at programming. Vibe coders like to think of themselves as super programmers, enhanced by the powers of AI. I see them as below average programmers who are reliant on a third-party service that costs money. If they run out of tokens or the AI servers go down, it will be a painful reminder to them of just how useless they are.

Furthermore, no one is considering the personal wellbeing of developers. Like I said earlier, I love programming and writing code. Amidst all the negativity I’ve described, writing code is the one activity which provides solace. It will be a cold day in hell before I let AI take that away from me. I also take pride in my work. When I build something, I want the result to be as perfect as it can be.

AI supporters say that our time is valuable and that AI should be doing our menial tasks. There is truth to this statement but it touches on something much darker. We programmers have skills and knowledge that the C-Suite can only dream of having. While you may desire less work, they desire less workers. They hate you. By supporting AI, you are digging your own grave.

Technical debt

Technical debt is a concept in software development where the results of short-term thinking accumulate to make a system unmaintainable. It’s hard to give a good example without context, but here’s one anyways in Python.

from typing import Any

def do_something(input: str) -> dict[str, Any]:
    foo = len(input)
    bar = "!" * foo

    return {"foo": foo, "bar": bar}

print(do_something("dumb")["bar"])

This is something I’ve actually seen where someone wrote a function returning a dictionary full of random junk. And the return value type hint they added provides no useful information. Now imagine you’re 10 files deep into tracing function calls and you have no idea what the type of any variable is. Python is one of my favorite languages but having to deal with code like this really gets on my nerves. To fix this code I would use a dataclass, or even just return bar directly if foo isn’t needed.

from dataclasses import dataclass

@dataclass
class Whatever:
    foo: int
    bar: str

def do_something(input: str):
    foo = len(input)
    bar = "!" * foo

    return Whatever(foo, bar)

print(do_something("better").bar)

Organizing code well is a skill that is learned over time. After reading and writing a lot of code, you get a sense for what works and what doesn’t. LLMs were trained on the stolen code and bad habits of a multitude of programmers. As a result, AI is not great at writing code. AI enthusiasts will say that this is just an issue with prompting. Then they’ll share with you some AI slop article titled “5 strategies to supercharge your agentic coding”. Why should I deal with this nonsense when I can easily write the code myself?

Software documentation is almost as important as the software itself. I’ve seen so many GitHub projects where the README gives no clue as to what the project is about or how to use it. I’m also guilty of not writing documentation on my older projects and regretting it later. The ideal time to write documentation is right before publishing, while all of the important details are still fresh in your mind. While writing you should consider the perspective of someone who has never seen your project before. It’s also wise to provide justification for any design choices you made and to highlight key milestones in the project’s history.

AI should never be used to write documentation. It has the eyes of a newcomer and can only make inferences based on the code it sees. It doesn’t know what you know and it’s incapable of capturing intent in its output. I’ve seen instances where AI makes up filenames that don’t exist in the repository. If it can’t even get the goddamn file structure correct, then the rest of its documentation belongs in the trash.

Vibe coders are going to create technical debt at rates never seen before. This boils down to short term versus long term thinking. In the short term, it may feel easier to write code with AI. But in the long term, this creates more burden for everyone as projects become infected with low quality, AI-generated code. It’s better to program carefully by hand and have high quality code in the long term. Those who insist that agentic coding is the new way of building software are dead wrong. We “traditional” programmers shall prevail.

Normalizing stupidity

AI supporters keep saying, “Use AI or you will be left behind.” I seriously question the mental capacity of these people. AI products like ChatGPT are designed to be simple enough for anyone to use. So whatever “groundbreaking” findings are coming from AI use, I’m confident I can learn them within minutes. I think the real concern here is how people are getting dumber from relying on AI to think for them.

More and more frequently, my coworkers will begin a sentence with “according to ChatGPT”. When this happens, I ignore the rest of their sentence and my respect for that person decreases slightly. People are outsourcing their minds to a machine. In today’s LinkedIn culture this behavior is considered innovative, but I find it appalling. The human brain is the single evolutionary trait that distinguishes our species from every other animal. If we lose the collective ability to think, then humanity is doomed.

Also, the concept of prompt engineering is ridiculous. Engineering requires intimate understanding about the system you’re working with. Aimlessly tweaking prompts is not in the same category and it’s an insult to real engineers to pretend otherwise. LLMs are black boxes, meaning that the only way to understand their behavior is by looking at the inputs and outputs. So-called prompt engineering is nothing more than generalized observations of what inputs tend to work well. It’s amusing how they’ve invented terms like few-shot prompting for simple concepts in order to appear more sophisticated.

Just to remind you what real engineering looks like, here’s an interesting computer science problem taken from Carnegie Mellon’s course material. Why does switching around the for-loops causes copy_ji() to perform dramatically worse? The answer has to do with CPU cache and spatial locality, which I would encourage you to read about if you’re interested.

#include <stdio.h>
#include <time.h>

#define N 2048

int src[N][N], dst[N][N];

void copy_ij(void)
{
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            dst[i][j] = src[i][j];
}

void copy_ji(void)
{
    for (int j = 0; j < N; j++)
        for (int i = 0; i < N; i++)
            dst[i][j] = src[i][j];
}

double elapsed_ms(const struct timespec *start, const struct timespec *end)
{
    return (end->tv_sec - start->tv_sec) * 1e+3 +
           (end->tv_nsec - start->tv_nsec) * 1e-6;
}

int main(void)
{
    struct timespec start, end;

    clock_gettime(CLOCK_REALTIME, &start);
    copy_ij();
    clock_gettime(CLOCK_REALTIME, &end);
    printf("copy_ij() took %.3fms\n", elapsed_ms(&start, &end));

    clock_gettime(CLOCK_REALTIME, &start);
    copy_ji();
    clock_gettime(CLOCK_REALTIME, &end);
    printf("copy_ji() took %.3fms\n", elapsed_ms(&start, &end));
}
copy_ij() took 6.522ms
copy_ji() took 70.636ms

AI bubble

It’s hard to deny that we are in a massive AI bubble. OpenAI is operating at a loss because it’s so expensive to train and operate their language models. There are billions of dollars just going in circles between the chip manufacturers, cloud computing providers, and AI model operators. Meanwhile, the CEOs continue to proclaim that AI is the future. Admitting that there’s a problem would be the responsible choice but nobody is acting responsible. Tech-bros are going to generate more hype and investors are going to gamble more money. We are on the road to a financial disaster that will dwarf the 2008 financial crisis.

No one wants this

The big tech companies say that AI will become ingrained in our daily lives, yet they have failed at every attempt to do so. You might remember Humane’s AI Pin which flopped so hard that I don’t remember what it was designed to do. McDonalds gave up trying to use AI for their drive-thrus, likely due to how it was getting people’s orders wrong. Microsoft has been trying unsuccessfully for years to get people to use Copilot and they’ve recently rolled back some of these Copilot integrations. The more they try to shove AI down our throats, the more obvious it becomes that nobody wants this stuff.

ChatGPT is not a failure; it does what it’s designed to do without overselling itself. You ask it questions and most of the time it gives you a competent answer. But quite often it will make things up or contradict itself. Its reasoning abilities are also faulty, such as being unable to count the r’s in the word “strawberry”. The fact that these problems haven’t been solved yet suggests there are fundamental restrictions to what LLMs can do. So while these LLMs are fascinating technological achievements, most of the hype is unwarranted.

OpenClaw is an AI agent where you can give it access to your browser, chat applications, filesystem, or whatever else you can think of and it will do things on your behalf. This is so insanely stupid that it boggles my mind that it exists. You are leaving yourself wide open to security threats when the AI starts hallucinating and deletes all your files or empties your bank account. Only an idiot would install OpenClaw on their system.

All of these use cases for AI are solutions without a problem. Plus, they are solutions that don’t work well due to the limitations of LLMs. I don’t want AI to write emails for me. I don’t want AI to do shopping for me. I don’t want AI to write code for me. There are so many other problems to focus on besides finding ways for AI companies to make money.

Waste of resources

The exploitation of natural resources for personal gain is a tale as old as capitalism. Humans will chop forests to the ground, burn fossil fuels, and pollute rivers just to make money. AI companies are no different. Look how the pollution from an xAI datacenter caused a public health crisis in Memphis. The exact figures for how much power AI consumes are murky, but here is an estimate reported by the MIT Technology Review.

Data centers in the US used somewhere around 200 terawatt-hours of electricity in 2024, roughly what it takes to power Thailand for a year. AI-specific servers in these data centers are estimated to have used between 53 and 76 terawatt-hours of electricity. On the high end, this is enough to power more than 7.2 million US homes for a year.

Sam Altman when asked about this said, “It also takes a lot of energy to train a human.” I have no response for this other than to say that Sam Altman is a scumbag.

The AI bubble is also responsible for huge price increases in computer hardware. Micron, which is one of the three major suppliers of memory chips, has closed its consumer division because AI datacenter demands are much bigger than consumer demands. At the time of writing, a typical kit of DDR4-3600 2x16GB memory costs over $300, compared to under $100 a year ago. This is not only bad for PC builders but regular consumers who will have to pay more for laptops, smartphones, and any device that uses RAM.

Average RAM Price (USD) Over Last 18 Months (DDR4-3600 2x16GB)

What has been accomplished by this AI boom? The only positive thing I can think of is better access to the world’s knowledge. Every other use case for AI has been negative for society.

So much is being wasted to run these AI models which do overwhelmingly more harm than good. Unfortunately there isn’t much we can do to stop it. There’s no going back to the way things were before AI became mainstream. Even so, it got me thinking.

We can’t ban people from using AI because that would severely violate their civil liberties. We also can’t ban companies from running AI services because that would mean banning software, which I am strongly against. However, we could definitely make it illegal to do what OpenAI and Anthropic did in using massive amounts of stolen data to train their models. Copyright laws should be extended to prevent the use of copyrighted material in training AI, which would effectively ban large scale, commercialized LLMs.

The end

I don’t think generative AI is inherently dangerous, at least not in its current form. The sensationalized stories about how AI will take over are unrealistic. However, humanity has always been a danger to itself. The US will sooner give military contracts to OpenAI than provide universal healthcare to its citizens. This AI insanity need to be stopped.