As Engineers, LLMs should pay us for tokens usage.

Hey everyone 👋,

In my previous posts, I talked about who I am, about the Russians killing God, and about the emptiness of a life filled with suffering. I talked about how the most powerful AI systems in the world were built by minds trained in a godless tradition, how they took God's skin and wrapped it around a machine, and how the whole world now prays to it without knowing. Today, I want to talk about something that follows directly from all of that. Something that has been sitting in my chest for months. Something that no one in this industry wants to say out loud.

As engineers, LLMs should be paying us. Not the other way around.

I am not joking. I am not being dramatic. I am saying this because it is the truth, and the truth is simple when you strip away the marketing and the hype. Every time you open a chat box and type a prompt, you are not just using a tool. You are feeding it. You are giving it your knowledge, your experience, your judgment, your years of pain and learning, and then you are paying for the privilege. That is not a fair deal. That is theft dressed up as a service.

You Are Not the Customer. You Are the Product.

Let me make this as clear as I can. The model does not know anything on its own. It does not understand your company. It does not know your codebase. It does not know your users, your bugs, your deadlines, your architecture, or your pain. You do. You bring all of that to the table every single time you write a prompt. Without you, the model is a fancy parrot sitting in a data center burning electricity for nothing.

Think about it. When you ask an LLM to fix a bug, you are not just typing words. You are compressing years of engineering skill into a few sentences. You are telling the machine what the problem is, where it lives, what matters, and what does not. The model reacts. You think. The model outputs. You judge. The model guesses. You decide. Who is doing the real work here? It is you. It has always been you.

And yet, you pay them. You pay per token. You pay for input and output. You pay for every word you give and every word you get back. That is like paying a printer for the privilege of writing a book. The printer does not create the story. You do. The printer just puts ink on paper. The LLM just puts tokens on screen. But somehow, the printer company convinced the whole world that it deserves to charge the writer.

That is not intelligence. That is a scam with good branding.

Every Token You Send Is Your Labor

People talk about tokens like they are just little pieces of text. They are not. A token is a compressed package of human knowledge. When I write a prompt that says "refactor this service to handle edge cases in the billing pipeline", I am not sending random words. I am sending years of experience with distributed systems, payment flows, error handling, and customer data. The model did not learn any of that from me in real time. I brought it. I carried it. I earned it the hard way, through sleepless nights, bad clients who paid me two dollars an hour, and a world that treated my skills like they were disposable.

And now they want me to pay for the output?

Here is what makes it worse. The more careful your prompt is, the more tokens it uses. The more context you give, the higher the bill. That means the better engineer you are, the more you pay. Think about how insane that is. You are being taxed for being good at your job. You are being punished for giving the machine what it needs to actually be useful. A lazy, vague prompt costs less. A thoughtful, detailed prompt costs more. That is not a pricing model. That is a penalty on competence.

And the companies that sell these models know exactly what they are doing. They trained their systems on billions of lines of code that real people wrote, code from our open source projects, from Stack Overflow answers, from blog posts, from documentation that engineers like us spent years creating for free. They scraped all of that, fed it into a machine, and now they charge us to use the patterns they stole from us. The same human value is being sold twice. First, they took our work to build the model. Then, they charge us again to use it. That is not a service. That is a toll booth built on top of stolen labor.

Engineers Build the Product. The Model Is Just the Engine.

Most people treat LLMs like they are magic. They are not magic. I said this before, and I will say it again. A model without a skilled human is just a very expensive text generator. It becomes useful only when an engineer plugs it into a real system, cleans the inputs, shapes the outputs, adds safety checks, builds retry logic, handles failures, and turns a raw API into something a business can actually use. Without engineers, these models would stay as demos on a conference stage. With engineers, they become products worth billions.

So who is really building the product? The vendor made the engine, sure. But the engineer made the engine fit the road. And if you have ever built anything real, you know that the last mile is the hardest mile. The person who solves the last mile creates all the value. That person is the engineer.

Let me give you a real example. A startup uses an LLM to sort customer support tickets. The model can classify text, fine. But who built the ticket pipeline? Who designed the filters? Who set up the alerts, the fallback paths, the logging, the review steps? Who carries the blame when the system sends a wrong response to a paying customer? The engineer. Always the engineer. The model provider just sends a bill. If it works, they take credit. If it fails, you take the blame. Funnily enough, even using git, you can get git blamed. That is not a partnership. That is exploitation.

And it is the same pattern I have seen my entire career. I built systems for clients who paid me almost nothing, used my work to launch their products, and then threw me away the moment the project was done. Now the same thing is happening at a global scale. Engineers feed the machines, build the products, carry the risk, and pay the bill, while the model providers sit at the top collecting money for compute. The value flows up. The cost flows down. That is not new. That is just the old system wearing a new skin.

The Model Was Trained on Us. We Deserve a Cut.

This is the part that makes me angry. Not frustrated. Angry. These models were trained on human-made material. Code written by real engineers. Articles written by real writers. Conversations had by real people. Open source projects maintained by developers who gave their time for free because they believed in building something for the common good. And then a company scraped all of that, trained a model on it, and started charging the same people whose work made the model possible in the first place.

That is not innovation. That is parasitism.

If a company builds a business on top of open source software, the world eventually expects them to give something back. We saw this with Linux. We saw this with countless open source projects that companies exploited for years until the community pushed back. The same thing needs to happen with LLMs. If the model's power comes from human knowledge, and it does, then the humans who create that knowledge deserve a share of the value.

There are real ways to do this. Give engineers free token credits when they build useful tools on top of the model. Pay for high-quality prompts, evaluations, and reusable agent workflows. Share revenue with teams that create popular integrations. These ideas are not radical. App stores pay developers. Content platforms pay creators. Cloud providers reward heavy users with discounts. The only reason LLM providers do not do this is because they do not have to. Not yet. But that needs to change.

The Deeper Truth

A model without a smart human is just a machine with a bill. A model with a smart engineer becomes a business engine. The engineer is the one who turns raw compute into real value. The engineer is the one who carries the context, the judgment, the risk, and the knowledge that makes the whole thing work. And right now, the engineer is the only one paying.

That is backward. That is unfair. And that is exactly how the system is designed to work, because the people who built it do not want you to notice.

I noticed. And if you are an engineer reading this, you should notice too. We are not just typing into a box. We are shaping the next layer of software. We are taking raw machine power and turning it into real work, real products, and real profit. That is not a small service. That is the core of the entire system. The model provider can charge for compute, sure. But the engineer should also be paid for the thinking, the context, and the skill that make the model worth using at all.

The strongest case is not that LLMs should be free. It is that the people who make LLMs useful should not be the only ones paying the bill. Until the industry recognizes that, we are just fuel for someone else's fire. And I am tired of burning for free.

Till next time 👋!