The LLM Critics Are Right. I Use LLMs Anyway.

2026-07-15

I almost agree with all of the LLM critics, yet I still use LLMs a lot. I know this sounds like I am delusional, and I also feel like that sometimes because of this dissonance, but I don’t think I am alone with it.

This week I was at Local-First Conf in Berlin, and the dissonance was everywhere. Armin Ronacher had just given a talk about building machine entities. He created Flask and was one of the early team members of Sentry, so he is clearly a good software engineer. Just recently he founded his company Earendil, which builds Pi.dev, an “open-source coding agent harness”. After the talk you could ask questions via Discord, which would be read out loud on stage, and I asked:

are you accepting PRs for Pi, or how do you handle the flood of PRs from LLMs?

He replied, live on stage, in front of the entire audience, that they auto-close almost all PRs and issues. But that one shouldn’t be discouraged from opening PRs, because the human will always shine through.

So it is not only me, but apparently some pretty clever engineers too. The people building a tool for working with LLMs are themselves flooded by their own creation, and in order to protect themselves they are auto-closing it all. On their purpose page it says:

In a world hurtling towards AI, we believe humans are the best agents.

Again, dissonance.

When I was sitting in the audience, I could see a lot of people having Claude Code open. And then the speakers would say these critical things about LLMs, and they would get this big round of applause. Even from the people with their Claude Code open.

And again, this dissonance.

I spoke at that conference myself, and when I later talked to some of the people, they described the feeling as pretty similar to mine, which is a relief, because I know I am not alone with this.

So this article is me trying to describe it. I’ll start by going through all of the fair and valid concerns about using LLMs, the things that would get the big round of applause. Then I will explain what makes me still use LLMs. And I’ll finish up with some of the patterns I found, in the hope that by giving concrete examples, others can step in as well and describe their experiences, so we can all come together and get a better understanding of this dissonance.

A few impressions from yesterday‘s talks 📸

@adamwiggins.com @martin.kleppmann.com @stevenruiz.bsky.social @jakelazaroff.com

— Local-First Conf (@localfirstconf.com) July 13, 2026 at 3:44 PM

LLMs are bad

Just by listening to people or the talks or reading HN, I think I got a pretty good sense of why certain people refuse to use LLMs. And what makes it extremely weird is that I agree with almost all of their points!

It is full of copyrighted materials, yes. It is bad for the environment, yes. All the ethical problems, yes. And this whole NVIDIA, OpenAI, money-moving circle-jerk is not going to end well. It is a bubble, and it is definitely going to burst.

Let me go through the biggest ones one by one.

Let’s start with the most common critique “LLMs produce a lot of slop”.

Yes, they do. Definitely.

If you look at open source software, you will see more and more repos and projects either straight up refusing all types of contributions or trying to put some kind of filters in front of it. Similar to what Armin and Earendil are doing with their auto-closing.

I think the core issue here is trust. You should never trust random people on the internet anyway. But before LLMs, there was this base thing: creating a proper PR with proper descriptions would require at least some human time, so it would keep trolls and low quality submissions out. Or at least you could easily filter them out within a couple of seconds. So even if a new person came in, you could trust that this person would have at least spent a couple of hours on that. And then it was probably worth taking a closer look at it.

That base thing is not true anymore. Everyone can simply create a new GitHub account and let their LLM loose, and as a maintainer you cannot easily tell whether someone put a lot of time into the PR (and maybe used Claude for just the PR description), or whether it is just an OpenClaw machine acting on its own. Projects like Zig or Gentoo are already refusing to accept LLM generated PRs (which I don’t think is the solution, because how would you even tell?)

I think LLMs might have serious potential to kill OSS, if we don’t find ways to restore that trust. One idea could be to only allow a small set of verified people to contribute to a project, and in order to get verified you would need to go to a real-life meetup or something.

And then there is the situation about junior engineers. There are actually two different points in there: a) you cannot trust the effort behind your junior’s code anymore, and b) seniors have no incentive left to teach juniors.

Let’s start with a): Senior people have always corrected and fixed the code of junior people. And juniors have always written some pretty bad code (my worst code was written in the before-LLM times). It is just now that as a senior while reviewing you don’t know if that junior just vibecoded it in 10 minutes, or if he sat there for a couple of hours but is genuinely lacking some good insights.

And b), the teaching, aka “How do we teach new people?”: previously, there was this balance aka “the junior does some pretty mundane tasks, but for this the senior reviews it together with him and helps him to grow”. Now as a senior, you don’t need juniors anymore. The mundane tasks, at least I find that a lot of people agree with that one, can be fully outsourced to an LLM. So why hire juniors at all?

And then there are the geopolitical tensions. What happens if China or the US cut us off overnight from these technologies? Just a couple of weeks ago the US government showed it was able and willing to cut off non-US citizens from Anthropic’s latest frontier model.

I don’t want to be a doomsayer here. I think Martin Kleppmann described it on stage in his talk pretty well:

the probability of a conflict between Europe and the US is still very low. But last year, it was zero.

Last but not least, even when just researching with LLMs, they have the natural tendency to silently sneak in the thoughts of the majority of the training materials, or sometimes even the political convictions of the ones who created the model.

It is like two humans talking to each other: over time, their opinions will slowly merge. Ever noticed that one single friend who just keeps using this one weird word, and then a couple of weeks later your entire friend group is using it? It is like that, just with opinions.

And one of the participants of the conversation is not a human.

LLMs are good

But we cannot make them go away entirely anymore. They are here, and they are here to stay. And instead of going against the flow, we can go with the flow, and then control it and shape it as well.

For example by ensuring models can run on your laptop. They are already getting better, and they make us programmers independent of these big corporations. And when the subsidies end and the prices rise, it is the open-weights models that keep the large vendors in check. And a model that runs locally on your own hardware cannot be cut off overnight by any government either. I would even make the argument that when the bubble bursts, there is going to be a lot of damage to the world economy, and a lot of companies will topple. But the open weights models are not going anywhere, so we programmers can fall back on them. Even at the conference, the talks that were about AI mostly took local models seriously.

Imagine: you would have this Sci-Fi AI running in the background, and you could always ask it questions, and it would always answer you. Like in Star Trek or something.

In many of the talks, AI appeared only as an aside: “we built this with Claude Code.” Some of the speakers even openly said “yeah, I just gave it to Claude Code”. But their talks got accepted, and they got a big round of applause from the audience, including from some pretty senior and well-respected people in there.

The main thing is that there are humans who put their credibility on the line. And THAT makes you listen. If they presented something with AI slop they would lose their credibility. And I think that makes them use AI differently. They say: “I just asked Fable 5 to implement it.” It sounds like a tech-bro. And it is exactly how I would describe it too. But I am guessing here, and I can only speak for myself: they are not letting the LLM do the thinking. It is their thoughts, now supercharged and put on crack.

LLM’s amplify what you already have: opinions, structure, frameworks. If you have thoughts, they come out sharper and faster. They are good at helping with brainstorming, checking your grammar, iterating on sentences, giving alternatives, acting as a rubber ducky or a devil’s advocate. If you have nothing, nothing comes out, very fluently. LLMs are good at producing massive amounts of content that looks good, but that nobody would read out loud in front of an audience.

And this is where the value is for me: I can simply make things higher quality than I could do them alone. I can do way more with it, but I use it to make fewer things more high quality. I tend to use an extreme amount of tokens, just to prepare a couple of sentences for a human. I think this is a good use of LLMs. And I find very much that LLMs can support you in thinking.

I strongly agree that written text should be from humans to humans. Yet I still write all of my texts with LLMs. And I don’t find that contradictory. What distinguishes “AI slop” from “good writing” is whether a human has put thoughts behind it. And you cannot outsource thinking.

But here is the problem: whether a human has put thoughts behind it is exactly the thing you cannot see from the outside. The sentence “I use AI to think better” is word for word the same coming from me and from some random AI tech-bro, and there is no way for you to tell, based on what I am saying, if it is bullshit or not. You simply cannot. Since amplified bullshit sounds like genius, all that’s left is trust. And trust is difficult to gain, and easy to lose. Especially in the era of LLMs. I see it myself: a single em dash can somehow invalidate the entire thing, as I catch myself thinking, didn’t the person want to at least remove the obvious signs of AI slop?

In the conference Discord, during one of the talks, someone asked how the others deal with the tension: a lot of people who are politically interested in local-first are also staunchly anti-LLM. Did it worry them to make software with LLMs, knowing it might get rejected by the community? Someone answered that a number of speakers, including the one on stage at that moment, had been saying “complicated thoughts” about exactly this. And I think that says a lot: even here, people feared saying out loud that they use LLMs. I am a little bit scared to say this too: last month I spent almost 10k USD on tokens. It sounds so insane.

When AI was new and I was trying it out, I partly ruined my own credibility with it. But then I realized that credibility is how you earn the trust: would you stand in front of an audience and read it out? If the answer is “well, I would explain what was meant by it”, then it is slop. If you would actually read it out, word by word, and not be ashamed of it: congratulations, it is a good text.

Some of the patterns I found

So how do I use them? There is this unexplainable fine line that is hard to describe, and I think it can only be experienced, learned from using these tools with an open mind. I know how this sentence sounds. It is exactly what the tech-bros say. I cannot even invite you to try it without sounding like them. So I will try to describe some of the patterns I found. Not as a “this is how to do it,” but in the hope of clarifying the situation.

Yes, it will write bad software if it doesn’t understand the actual problem and the requirements. With the right skills and tools, you can produce some pretty decent software. But between you and that decent software stands agreeableness: it will not tell you when it didn’t understand something, and just go ahead and do something. This is also why the /grill-me skill, adapted from Matt Pocock’s “grill me” technique, is so extremely powerful. It is extremely short:

Interview me relentlessly about every aspect of this until we reach a shared understanding. Walk down each branch of the decision tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.

Ask the questions one at a time, waiting for feedback on each question before continuing. Asking multiple questions at once is bewildering.

If a fact can be found by exploring the environment (filesystem, tools, etc.), look it up rather than asking me. The decisions, though, are mine — put each one to me and wait for my answer.

Do not act on it until I confirm we have reached a shared understanding.

And honestly, the grill-me feels good. When I found this skill, I was absolutely excited about how something so simple can have such an impact. Because it forces you to form your own thoughts, question by question. I have since adopted this step-by-step approach for everything, this spending-an-extreme-amount-of-tokens-on-a-single-sentence kind of approach, for example for writing articles. This article here was written by me chaotically writing down my thoughts, and then going sentence by sentence, getting roasted by the LLM.

Whenever I code something, even for minor things, I follow the Basecamp “Pitch” and think really, really hard about a short “Problem,” “What we are shipping,” “What we are not shipping.” I force myself to write a problem statement of three sentences. It is incredibly easy, and even easier with LLMs, to fill this out. But it is incredibly difficult to make it good. I think this works so well in an LLM workflow precisely because it was designed for humans: three sentences force me to actually read them. And if I read them, another human can also read them.

I tend not to actually read most LLM output anymore; I skim it, to check if I vibe with it. But a problem statement of three sentences, that I will fact-check really hard. It is like code review: a review with 1,000 lines of code gets an “LGTM”. A review with 100 lines gets 15 comments.

The same care goes into my PR descriptions: I spend a lot of time on them, to ensure they remain readable, are concise, and always describe the actual problem, what we are shipping, and what we are not shipping. And I add screenshots of it working, to give the reviewer an obvious sign that it is worth interacting with this PR, as it is clearly working. But I have to always fight with Claude about the descriptions, as it keeps adding slop to them. And sometimes I just let Claude win too much there, if it is not an important PR.

You need something against them, to counter the large amount of stuff they create. In my coding workflow I put in smaller agents that counteract that.

Another technique I like (the Ralph Wiggum loop, or more modernly Claude’s ultracode) is to lock the LLM in with a text or plan or statement or code or whatever, and keep spawning subagents (LLMs with a fresh context) with their only task to rip apart the context. And they keep doing it, until they are forced to hallucinate problems. And only then do I continue with the workflow.

If they are forced to hallucinate, you can actually use their weakness: they are trying to agree with you that there are problems in there, but they cannot find any.

Especially if you combine it with the /grill-me skill, you end up with a result where you as the human have no further comments or thoughts, not even the most minor thought. The LLM has tried ripping apart your thoughts as well, and sometimes roasted you for hours, and forced you to form your own thoughts.

There is even a way to use the hallucinating itself: at last year’s conference, Anselm Eickhoff described how you can let an LLM hallucinate the API or the UX it expects, before showing it the real thing. Whatever it guesses is probably what most humans would guess too. So instead of fighting the hallucination, you use it: as a cheap test of whether your design matches what people expect. I have built this into a skill as well, if you want to try it.

All of these patterns have one requirement, though: I need to be able to tell whether the result is any good. And the more LLMs I use, the more I end up in fields I do not know well. And then I need experts. Because I can only program things if I understand them. It is like delegating: I only delegate a task to another member of my team if I at least understand the basics and know what good is. Same for LLMs.

If I know something very well, I can quickly tell “good” and “absolute dogshit” apart. And if I know something not well, I use LLMs only to help me learn it. Because if I use them while I cannot yet distinguish good from dogshit, I will end up with full-blown slop production.

There are two ways to learn, based on whether the result can be clearly differentiated as good or bad. Good or bad as in: the code compiles or it does not, the test suite is green or it is not, the protocol decodes or it does not. Not as in “the code is good,” because code quality is a thing. In fields with such a clear check, you can point the LLM at it and learn together. One guy at the conference described how he reverse-engineered binaries and protocols using Opus 4.6, and the only thing he needed was basic knowledge of reverse engineering. Either his patched binary worked, or it bricked the device. It was clear whether the result was correct or not, so he could even find his own techniques along the way.

In fields where you have a lot of opinions, like programming, the LLM will just tell you what most people would want: the most popular technique, which is maybe not the best one for your case.

We had a team discussion once, where people were telling me code was AI slop, and that it was a general AI problem. When we went into it, it turned out they didn’t like TDD. But we had another one on the team who did a lot of TDD long before the age of LLMs. So suddenly, AI slop wasn’t about AI slop anymore. It was about humans having different opinions. And like I said, LLMs only amplify. With them, you can amplify your opinion. Here you need humans, to point you roughly in the right direction and give you good starting opinions, which you use until you are able to continue on your own.

I am not alone

I hope that you can trust me, and I fully understand if you don’t. The only way for you to really know is to engage with my content, but that takes a lot of time, so I understand if you don’t. But if you are still here at this point, you have already engaged with this text for quite a while. And maybe you already know that a lot of effort went into this article, and that it is not some obvious slop.

I am not alone with this dissonance.

Writing alone did not show me that. But while writing, I looked through the Discord of the conference, I asked people at the conference directly, and I went through the HN articles of the past weeks. That showed me: other people, describing the same dissonance. So maybe others can describe their experiences and learning paths as well, to clarify this fine line.

Somewhere in all of this is this very good stuff. Not the hype, but a genuinely good tool that enriches your thinking. It will never replace your thinking though.

Go ahead, try it out. I know, that is exactly what a tech-bro would say. I cannot say it any other way.

Thank you to all the people at Local-First Conf. You made my head explode with information.