On LLMs

My current feelings on large language models, channel fraud, and code.

When I was a junior in college I decided that if I wanted to truly seize the brass ring (i.e. work for Google) I needed to cultivate some technical extracurriculars. Up to that point I’d largely spent my free time taking the train into the city to go to parties and talk to girls. This, I decided, was youth misspent. I should instead be burnishing credentials. I should be serving as that most lofty of positions, the unpaid undergraduate research assistant.

So I asked around. I wanted to work on research that appealed to my interests. My academic advisor connected me with a professor of computational linguistics, who connected me with her grad student, who emailed me the name of a coffee shop, a date, and a time.

He waited for me in the corner of the coffee shop. He wore a bulky hoodie that obscured any underlying form he might have had, made him literally without shape. Next to him was a massive duffel bag. I sat.

“Pick one,” he said, and he opened the duffel bag. Inside, arranged like books on a shelf, were maybe fifteen laptops. They were Dells of some vintage, I remember. Each was wrapped in a power cord hung with a brick. The bricks were still warm.

I chose a laptop at random.

“Plug it in, let’s see how this goes,” he said. I set the laptop in front of me and plugged it into an outlet by my feet. I opened the laptop. It audibly creaked.

“Okay so each of these has been all set up. I set them up. It takes me hours.”

The laptop was going through the Windows boot sequence. The fan immediately kicked on.

“Each has a corpus and the weights we’ve worked out. Don’t worry about what that means. You’re going to run some Python and report back the results. You can do the first one here with me, to see how it’s done.”

The laptop finished booting. I logged in; there was no password. An MS-DOS Prompt was running. The grad student murmured the command to run like some cthonic invocation. I typed it in and hit Enter. The fans revved to a pitch I didn’t think was possible.

“Okay so yeah now it’s running,” said the grad student. He was gazing at the barista.

“What is it doing?” I asked.

“It’s analyzing Alice in Wonderland to determine which words are nouns, verbs, et cetera. Parts of speech.”

“Oh,” I said. We sat and listened to the laptop fans for a few minutes. Eventually I realized I was no longer hearing them and looked down to see a massive stacktrace unspooling across the screen.

“It crashed,” I said. “There’s this huge error—”

“Yeah, that happens,” said the grad student. “I’d have been surprised if it didn’t. Mostly the code crashes. It’s really fragile.”

“I see,” I said. I looked at him. He looked at the barista. “Why?” I asked.

“It’s tricky,” he said immediately without turning to me. “We don’t fully understand what’s happening under the hood. The model itself—”

“No,” I said. “I meant: why run it at all?”

I was not invited to become an unpaid undergraduate research assistant, I did not go on to work at Google, and in every respect my career since then has resembled capitalism’s equivalent of pink noise. But I’d like to think that I distinguished myself in that moment by asking…why?

⍫

Large language models have come a long way since I first encountered their ancestor species on a broken Dell in the early aughts. And I’ve had occasion, now, to work more closely with them. I was for a year the VPE at an “AI” startup, if you’ll excuse the phrase. I built multiple “agents” and experimented with all sorts of models from all kinds of providers.

This is all to say that while I am not employed at one of the frontier labs I have a better understanding of how these things work and what they can do than maybe 90% of people. I think that’s good enough to form a solid opinion; there are certainly very many people with lesser understandings who have formed fanatical ones.

This opinion has two parts, as I genuinely believe that LLMs are widely misapplied but do have a few limited uses. In the first part we’ll examine using LLMs to generate freeform, unstructured language. This is how most people use LLMs. In the second part we’ll look at using LLMs to generate schematic outputs: code, for example. This is how many people within the software industry use LLMs, although of course due to their proximity and the associated corrosive power of LLMs they will often use them liberally and without distinction between the two parts presented here. While the primary goal of this essay is to tease out how I feel about these stupid tools, I would be delighted if even one software person read this and decided to stop using LLMs for anything other than code as a result.

⍫

Part 1: Using LLMs to generate non-code is, by definition, fraudulent.

I don’t mean fraudulent by way of tokens laundering copywritten works, although that of course looms over all of this (notice how the frontier labs have either courted or studiously avoided running afoul of Disney, for example). I mean a deeper form of fraud. When you use an LLM to try and communicate something to another human being you are defrauding that person, playing a shell game with your intent and their expectations. You are committing channel fraud.

Channel fraud is a term I picked up from Brian Bucklew. I think it’s best defined by comparing how people might make art with and without an LLM. Art is being used extremely broadly here to mean any reified expression of human intent. Call it what you will, but we need some label for what we’re trying to produce. Anyway, in the old way, the way of our ancestors:

1. You have some idea you want to communicate.
2. You think about the idea. You develop an intent.
3. You want to project this intent into the world like a shadow cast upon a wall.
4. So you (all of you—your conscious, your subconscious, the time you were teased in the seventh grade for wearing jeans that were way too short) channel it into some form, a poem, a painting, a Word document, an email.
5. Eventually what you have produced is complete. You share it with the world, and the world interprets your intent.

Perhaps it isn’t necessary to say this outright, but the beauty of any shared intent is that we can never truly capture what we would like to project. The best we can do is try. We regard as masters those who might briefly glimpse some perfect alignment of intent and result. And this communication is bidirectional; we, the interpreters, play our part. We don’t all love the same artists. We see more deeply into works that others may regard as shallow and vice-versa. This goes for cast-off text messages as equally as high art: communication is meaningful because it is human.

Now let’s examine this same process but with an LLM in the middle of it.

1. You have some idea you want to communicate.
2. You think about the idea. You develop an intent.
3. You want to project this intent into the world like a shadow cast upon a wall.
4. So you prompt an LLM about it, with many words or with few, to produce some form, a poem, a painting, a Word document, an email.
5. The LLM functions as the channel and channeler. A bag of weights with unfathomable dimensionality seeds its planet-scale Boggle box with your prompt.
6. You shake the Boggle box, prompting and reprompting, until you get what you want, more or less.
7. Eventually what you have prompted for is complete. You share it with the world, and the world interprets an intent.

In this process you channeled nothing; the LLM did your channeling for you. And the LLM, of course, can’t know your intent the way you can. Even if we stop here there has already been a loss of fidelity from injecting a sieve between you and your desired outcome.

But there has been an additional loss. You are not the channeler, and all of you is not the channel. All of the tiny decisions that never even bubble up to the level of consciousness, all the endearing little tics and predilections and unconscious obsessions and bad habits, everything we might call a voice…it’s all been ablated in favor of the statistical average. You have sacrificed the you-ness of your projection. You have engaged a woodchipper in the pruning of bonsai. You have committed channel fraud.

Which, in the end, is quite a silly thing to do. Presumably if you’re writing to someone or generating some research or authoring some document you’re doing so because it needs to be done, because the doing of it is important. If it’s not important you probably shouldn’t be doing it in the first place. If it is important then by using an LLM you immediately undermine the intent of the work. It can no longer functionally be trusted—it’s fraudulent by nature. It’s a waste of time; of theirs, and of yours.

⍫

Interlude: a corrosive technology.

Instead of going to Google I ended up at a smaller, East Coast tech company that I still love dearly, though I left many years ago. I found a kindred spirit in one of their executives. He became a friend and mentor, and we meet for dinner once or twice a year. Our conversations always leave me invigorated. We talk about books, we talk about the industry, we talk about emerging technologies, we talk about the vagaries of raising children.

Last time we met we talked about AI.

My mentor was using AI quite a bit, in ways that I think would generally concord with how I outline my own usages below. He was generating little scripts to do things. He wanted to lay out text into little paper booklets for himself and his kid and had the LLM gin up a script to do so. And, like many people who use these technologies, he ends up talking to it a little. Talking at it, perhaps, would be more precise, and being talked at in return. And this experience led him to insist on a word for LLMs, for the hype cycle, for all of it: corrosive.

The technology is corrosive. It dissolves some integral part of the thought process. It intercedes. It insists upon itself. The word made total sense to me immediately. This shit is corrosive!

I think perhaps every friend and colleague with whom I’ve discussed LLM usage has mentioned, unprompted (eh? eh?), how they felt dumber after using it. How the laziness of reaching first for this thing that is eager, everpresent, ready with an answer—not perhaps the right one, but always one, and another after, forever—how it was so easy to cede some level of consideration to this false mind. It’s corrosive. I think it’s important to repeat this as a kind of mantra to yourself whenever you use these things. This is corrosive. I am harming myself in the using of it.

LLMs are not unique in this way, of course. Much of what we do on a daily basis under the auspices of hypercapitalism is corrosive. I’m lucky enough to largely enjoy what I do, but that puts me firmly in the minority. Unlike wage labor, though, with an LLM I can choose if and when I corrode myself. I try to remember this, though I often fail to do so.

⍫

Part 2: LLMs are genuinely good at schematic outputs, and sometimes that’s okay.

As corrosive as these tools are, as much as they threaten our humanity when used to cosplay being human, I think they have their uses. I feel more or less the same about them as I do driving a car with an internal combustion engine: oil has doomed the Earth, but sometimes my other options are worse.

I think to understand why this is we first have to set a quick baseline. Pop quiz! What does every wired-in grindset Stanford dropout of a thought leader fundamentally want to do? What, when it comes down to it, is the problem they are trying to solve with every world-altering torment nexus they unleash?

Say it with me: they want to obviate the self.

Software may be eating the world, but it’s doing so because some nerd wanted to shave away a minor inconvenience. They didn’t want to worry about where to park the car and thought buses were for poor people, so they invented ridesharing. They didn’t want their employees to unionize, so they invented Agile. They didn’t want to have to actually talk to other people, so they invented social media. And they didn’t want to have to actually talk to themselves, so they instrumentalized LLMs as chatbots.

I think this frame helps us understand where LLMs can actually be good. In the end they’re a tool that can predict a distribution of tokens given some input. Software engineers are engaged in the writing of code, by definition a tiny subset of language that has a formal grammar, is highly constrained, and can be externally verified. Like everything else, the nerds set out to reshape the world and ended up making their own daily tasks incrementally easier. They partially automated programming.

I personally do not believe programming to be an art. I don’t see code as pure communication, something worth exhibiting. It can be elegant in the same way that I sometimes stop to admire particularly fine brickwork. Bricks serve a primary purpose that is orthogonal to aesthetic appreciation, and so does code. Bricks wear down, need repointing. So does code. And so I’m not offended by the idea of a tool that can quickly generate boilerplate or write dev scripts or compare two git SHAs to guess at a regression. When our foundation needed repair a man came with a laser level and deemed our brickwork substandard. I did not take offense at the laser.

This is true of me despite reading Knuth, despite finding pleasure in functional programming. Because I also firmly believe that there is code that should always be written by hand. LLMs are corrosive, of course, and if you’re writing code that you absolutely need to understand, need to know and support and develop the kind of bone-deep intimations that allow you to see a bug report and instantly know the culpable line of code, well then you should probably do that bit by hand. You’ll be on the hook for it when the PagerDuty alert comes in, after all. The machine is not answerable during performance evaluations.

But one-off scripts and little data viz queries and quick “why is this 3000-line JSON blob not behaving” gut checks that you can follow up manually if needed: those are fine. Sometimes the brick gets walled-in and the mason gets to be a little slapdash with her pointing. It happens.

But the instant you need a thorough understanding of the thing the LLM must be set aside. You read the Cliff Notes, but now it’s time to pretend you never did and devour the novel.

That LLMs are usable at all for this kind of work is a function not of them, but of their context. Code can be verified. We can test it, we can statically analyze it, we can even deterministically simulate it. And so if I come across some task that is both easily verifiable—maybe it fails loudly, or there are existing tests for it, or the language itself precludes its failure states—and is not in the critical path, I’m comfortable considering an LLM for it.

This is how I use LLMs, at least as of the summer of 2026. There were a few moments while writing this that I nearly convinced myself to give them up altogether. But simultaneously, at my day job, I had an LLM one-shot a build system thing that would’ve taken me a week in a few minutes, a thing that would’ve failed loudly if it was wrong.

And so I’ve come to what I hope is a practical equanimity about LLMs. I don’t believe the hype cycle. I think they are wildly overapplied, and that many executives have made a category error in centering them as a value prop. I think the casual use of them as a channel for human thought is dangerous and gross. And I think that they can sometimes help me do my bricklaying a little better, and that is enough.