GitHub Copilot and major world religions
Using GitHub Copilot is like biting into a toasted ravioli at Applebees. You need to justify to yourself why you’re at Applebees to begin with (if anyone asks, you were given a gift-card and it expires in THREE DAYS), you’re definitely not going to enjoy any of the food — it’s bland; tasteless! — only Neanderthals would eat here, and even in your internal dialogue you pronounce “Neanderthal” with a hard ‘T’ because you need to prove to yourself that you’re cultured. But dang, you wouldn’t want to waste a $25 gift card.
Enter the toasted ravioli.
Folks, you can’t find this delicacy on the Applebees menu outside of St Louis, Missouri. That’s right, STL is the only place in the world (!) Applebees will bread a ravioli and fry it in oil. Toasted ravioli is a St Louis thing. And daggumit if that Applebees toasted ravioli don’t just beat all — it makes the sides of your mouth show signs of involuntary curling. That fried goodness is just too much — you look straight into that ravioli, shake your head, and let loose an ear to ear smile.
A few months in, this describes my experience using GitHub Copilot.
I suppose GitHub is Applebees in this metaphor? This article is pretty unclear tbh. I have misgivings about using the product to begin with: one that does what I do, except much faster and sometimes much better. And, while I know Copilot is definitely not a real brain— it’s just a perceptron ouroboros you fool — I am often shocked to find myself physically smiling, like I might to a friend, when it does something that ten-minutes-in-the-future-me would have done given ten minutes and a lack of an AI co-programmer.
There’s a word for this feeling that produces the Untamable Smile, and that word is delight.
I did not make this up. This word came about in a very natural iMessage conversation about using Copilot.
Isn’t that an interesting word choice? I don’t want to get too philosophical here; after all, deep thinking is a hard sell for Applebees-based Medium articles — but isn’t this a word you might use to describe the actions of… maybe a pet? Maybe a person? Definitely something you’ve anthropomorphized.
There are already scores of terrible Medium articles on the subject of GPT3’s consciousness from unqualified morons like me, so I’m not going to add another (two) thousand words to the pile (though what you are reading now is easily among the best Applebees-related Medium articles, if I do say so myself). However, before moving on, I will point you to Melanie Mitchell’s blog, who actually does know what she’s talking about. She wrote a great article on GPT3's mixed/poor results on Hofstadter’s Copycat tests, which is — to summarize thousands of pages from people much smarter than me — a succinct way of measuring the ability of a machine to understand metaphor.
Another smart person I’ll point you to is Ilya Sutskever, chief scientist at OpenAI, who tweeted (in different words) “by the way, umm…… I think GPT3 may already be kinda-sorta conscious.” I’m imagining him twirling his hair around a finger while he says this.
My contribution to the field is not quite as academic (not sure if you could tell). It’s pragmatic. Copilot, at least for now, is a power tool that I consume on a daily basis. How do I use Copilot and how does it affect me? How many involuntary smiles per minute? Sample size of one (now two, because of the iMessage convo). I have to admit that it goes deeper than the smile. I have found myself also involuntarily talking to Copilot… let’s say, more often than perhaps I feel comfortable with, in retrospect. Er, um. Out loud.
Wow, according to these stats, 83% of my faithful readers have now closed the tab.
We all anthropomorphize. In fact, in software it’s even encouraged! But I’m starting to notice some distinct differences between how I talk to Copilot and how I talk to my car. “Come on, turn over you magnificent engine.” This is a plea for function in cold weather (did I mention St Louis?). Or maybe I’ll give the dash a light pat for some decent acceleration from the modest, triple-digit-horsepower 4-cylinder. This is excitement about, I don’t know — loud noises and the physical sensation of acceleration? I am Tim the Toolman grunting at the latest Binford tool. Child’s play.
When I talk to Copilot, I find myself uttering things because I am surprised and delighted from successfully reasoning with a machine. Even if you disagree with me about exactly how great Copilot’s code is (it can be an idiot, it’s true), or you have misgivings about copyright infringement, or perhaps you’re concerned about Copilot’s racial bias — consider the difference in the kind of thing it produces, compared to every other programming tool. The kind of thing Copilot outputs changes the nature of the beast (relax — it’s probably not that beast).
From what I can gather from my own experience, working with Copilot is materially different in nature from working with my car, working with a pen, or really any other tool, programmery-tools included. When I talk to non-programmers about using AI day to day, I wrestle internally with how to communicate the growing feeling of this difference.
Let’s talk about pens.
In some ways, using Copilot isn’t so different than using a pen to think through my thoughts. I often do this and then foolishly hit “publish” on half-baked ideas (like this one, for example). Don’t you reason with a pen too? Fair. For me, however, my pen gives me clarity on ideas already in my head, not ideas from millions of other heads I’ve never had contact with. Instantly. The pen also helps me link together ideas that have been floating around from disparate sources, like in my last critically acclaimed post where I used the pen to connect the Unix Philosophy with Agile. However, the pen does not teach me new programming techniques or new ways of thinking about problems all on its own, the way Copilot does. The pen conjures nothing ex nihilo. This tool is fundamentally different than a pen.
What about programmy-stuff?
The astute among you may realize that we programmers are already used to using tools that are fundamentally differently than tools used in other domains. We learn to use computers as part of a feedback loop, and our feedback loop operates several orders of magnitude faster and “more correctly” (I put this in quotes so you will give me the benefit of the doubt) than any other domain. This already sets our tools apart, and in turn how we approach problem solving. I’ve made the analogy to construction or woodworking a few times in the past, and here’s the fundamental difference in how we approach problems differently: construction workers don’t get to build a building wrong. Ever — let alone literally thousands of times. Physicists, chemists, and biologists don’t get to run billions of experiments in Docker containers (i.e. “near-perfectly controlled environments”). Programmers, on the other hand, insist on building the building wrong before we build it right. We write code, called test code, that tests the correctness of our code and lets us know we’re wrong, quite literally faster than we can react. In this way, we get to lean on being wrong as a real-time reasoning tool in a way that other domains simply cannot.
I bring up this slight diversion to concede that there are already tools for programmers that are fundamentally different than tools for non-programmers. However, I think Copilot is carving out another fundamental difference in tooling, even among programming tools. Let me quote myself from a little further up in the article:
When I talk to Copilot, I find myself uttering things because I am surprised and delighted from successfully reasoning with a machine.
This is not what we programmers normally do with our tools. Not quite, anyway. We usually do the reasoning ourselves, based on output from the machine. I think up some solution, I write it, it tells me if I’m wrong or not. Copilot flips this on its little robo-head. Copilot does the reasoning itself and asks ME if it’s right.
Here’s an example. With “legacy tools”, like what the entire industry uses right now, I would start by writing some test code like this:
assert(4 == add(2, 2))
Like I said, we programmers want to fail first — so this assertion fails because add doesn’t even exist. Next, I write an add function that I know is wrong.
add(a, b) => 0;
Again, the assertion fails, because 4 does not equal add(2, 2) = 0. Finally, I go back in and, using the fact that the computer told me the code was wrong, I use my own reasoning to write code that will make this test pass:
add(a, b) => a + b;
Let’s redo this experiment with Copilot. Remember, this whole thing is backward — Copilot is going to reason and I’m going to tell it whether it’s right or not. Or am I?
First, I need a test, so I write:
// test that add function correctly adds two numbers
I write this in English and Copilot asks “is this right??”
assert(4 == add(2, 2))
According to my finely tuned reason, this looks like it checks out. Now I need the actual add function so I write:
// function that adds two numbers
Again, Copilot answers in it’s annoyingly high-pitched voice, “is this right??”
add(a, b) => a + b;
See the difference? Copilot took some of the reasoning from me. We’re in this together now. To put it lightly: what the heckin hecks?
If this article is a Key and Peele skit, this is the the part when the skit turns into an episode of the Twilight Zone.
You’ve been faithfully reading my posts for decades now, so naturally you understand that I usually explain things through complicated metaphors in books I’m currently reading, like in my least viewed post that I foolishly entitled “Thoughts on Gardening (eventually)”, in which I use a gardening book I randomly read as an extended metaphor for— you know what, it’s really not worth explaining. This time, to switch things up a bit, let me explain with a movie reference and some major world religions (oh boy).
In the film, 300 (it’s about shirtless men killing things, I believe), when Xerxes the god-king (an actual King of Persia, who was worshiped as a god in his time) meets King Leonidas, he says something interesting. “Come Leonidas, let us reason together.” I say it’s interesting because Zack Snyder didn’t conjure this line out of the aether. The god-king said it because he believed he was a god — and that specific phrase, Xerxes lifted word for word from the Hebrew God. In other words, it’s a Bible verse — er, except for the “Leonidas” part. Not just any old section of the Bible, mind you, but from the Nevi’im, or prophetic books of the Jewish tradition; a subsection of what you may know as the “Old Testament”, from a conversation that the prophet Isaiah has with God. You know, Isaiah? A prophet honored by Christian, Jewish, and arguably Islamic traditions? So roughly 55% of the modern world (and much much more of the ancient world).
This is all extremely easy to dismiss — in fact I’m borderline dismissing it myself. Applebees, shirtless men, world religions. But the reason (pun intended) I bring these things up is because this characteristic of reasoning together has been, in some way, “set aside” by billions of people, for millennia. I certainly didn’t start it.
Isn’t that worth taking a second to think about?
I’m constantly in conversations with people around me who ask if I think AI is conscious yet. They think that because I know how to write some glorified if/thens that I’m qualified to analyze how freaking consciousness works. Oof. And rather than come up with an original thought that’s probably wrong, I am appealing to the opinions and beliefs of scores of others. Programmers, whether they want to or not, are having to think more and more about philosophy (let’s not start on how unprepared our industry is for this). What is the nature of these tools I’m using? Am I affecting the world in a positive way?
We are startlingly close to needing to ask: How are my tools feeling today?