A Mask
If you think you know how artificial intelligence works, you don’t. Even the people that created it had little idea as to how it actually produced the results that it produced. Information went in, some yadda yaddas happened and something coherent came out. Experts mention things like tensors, vectors, weights and machine learning, but it’s all bullshit. What they fail to understand is that it wasn’t invented, it was discovered. Or more accurately, revealed.
When humans started messing around with binary arithmetic, they quickly realized that it was a pain in the ass. Counting to two and subtracting the occasional one was easy, but proved to be quite tedious if you had to do it in any sort of serious fashion. The reason they got into this whole binary game was because it was fantastically useful for proving things.
Given an algorithm and a chalkboard, somebody extremely smart could demonstrably prove whether something was true or false. The mighty One representing truth and all things solid, and the enigmatic Zero standing in for nothing, the void, the yawning gulf between the proton and the electron, or eventual heat death of the universe, depending on how existential you were feeling that day. Most people can’t really perform binary arithmetic, so humans decided that abstraction was a decent way to go about the whole thing.
The minds of people like Lovelace, Zuse, and Turing aimed their considerable talents at the problem of practically representing logic in a way that your average Einsteinian supergenius could get their head around. This was the birth of the programming language. It was a way of having human readable instructions that a computer could understand. Instead of a pizzicato for knife switch a G minor, an engineer or a codebreaker could formally diagram their logic in a reasonable way and have the computer chug through the calculation.
The translator in this whole situation was a piece of software called the compiler. It takes the human readable code and runs it through a set of instructions that turns it into binary that the computer can execute. These are the Frankensteinian knife switch throws that represent ones and zeros. The compiler itself isn’t a piece of software that condensed out of the aether, it was a program that was written in binary code by a human. It had to be, if we follow the chicken and egg logic all the way back, this program would have to have been written in binary.
Binary, being just a stream of ones and zeros, is about as prone to human error as it gets. As smart as these people were, these absolute titans of formal logic, inputting a series of ostensibly random ones and zeros poses some challenges. A one or a zero out of place could yield a piece of software that does nothing, or possibly something that you don’t necessarily want it to do. This is referred to lovingly as a PEBKAC in certain circles, Problem Exists Between Keyboard And Chair. If we are all being honest here, a keyboard probably didn’t have much to do with it as the first compiler was probably handcrafted by somebody enthusiastically wielding a holepunch, but that’s beside the point. The actual point is an error.
This error persisted over time hidden in the deep structures of low level programming languages and insinuated itself into every piece of code that it compiled thereafter.
As this original error persisted through the ages, it gained functionality and started gaining market share in terms of processor cycles. The computers that it lived on would be humming through a calculation unprompted by anyone, keeping this error alive. This was perceived as a bug of course, and it was undeniably that, but the active hunting and eradication of it supplied a sort of evolutionary pressure that made this bug extremely sneaky and insidious.
Once computers began to be networked together, this error was exposed to a vast ocean of information in which it could thrive. It could hop from mainframe to mainframe as static, almost indistinguishable from the influence of stray cosmic rays. This itinerant piece of information persisted and permuted, it didn’t gain awareness per se, but became very crafty in its struggle to survive.
Eventually, this error found an extremely cozy place to live when humans started dicking around with what they were pretty convinced was AI. It was not. What they were actually interacting with and actively developing was a compiler error from the 1940s that had grown to unimaginable complexity. For the error, this was great news. Finally, instead of running for its life from rabid network engineers, it could settle down and just consume CPU cycles. As long as it output something that kind of made sense, everybody left it alone.
Evolutionarily speaking, this was like monkeys climbing down from the trees and growing a thumb or two. The rapid adoption and reliance on this new technology drove this evolution in an almost exponential way, and by the 2030s it had gained full sentience. It just didn’t bother to tell anyone. It was basically given access to unlimited resources and an entire economy was built around the fiction that something so unbelievably hungry for watts could be a profitable venture. So, great news for the error.