One straightforward suggestion has gathered notice: no longer allow AI agents to compose your code. The piece, known as “How to keep enjoying programming in a world of LLMs,” presents a direct argument. Its author urges programmers to write code on their own, without exception, instead of entrusting every assignment to an agent.
A disclaimer sits at the top of the post, warning readers that the text was once mistaken for machine-generated writing. The author has since corrected the record: it is 100% human-written without any AI assistance. That correction is the entire point. The writer is not a techbro pushing for more machine involvement. They are a programmer who wants to keep the craft alive.
The Book That Started It All
Sean Mcmullen’s book “Souls in the Great Machine”, which the writer read as a teenager, tells of a vast machine made from human souls acting as a single calculating unit. The joke comes at once: LLMs are real machines, built from actual processors, doing the same job while pretending to be super-human. The writer finds the gap between the tale and the present small indeed.
We are turning into mere parts within a machine instead of the people who produce software. A system that depends on specs gives us a plan, forces it into the LLM, and cries when tokens run short because some lord of technology chose to give out fewer of them. This change is shown as gradual, not sudden, by the writer.
Why Haskell Matters Here
This author describes themselves as someone who writes Haskell and enjoys doing so. They believe this pleasure applies to most programmers working with Haskell, but they do not think it holds for many other languages. That distinction helps explain why supporters of different languages see the LLM-assisted future in such different lights.
A great deal of the pleasure of writing code is endangered when an LLM produces it. Giving up these large language models is not the answer. The writer wishes to carry on composing Haskell programs, without needing to study and check too much generated code. At the same time, they hope to put those tokens to some worthy purpose that does not steadily wear away their mind.
The aim is to get a little more done using LLMs without seeming far more productive and giving up the pleasure along the way.
Keep Writing Code
Keeping control over a codebase requires continuing to write code yourself. If you let the whole thing be generated instead, the codebase becomes an LLM wasteland where only coding agents can survive. It will eventually be lost.
Continuing to write code helps maintain programming skill, because skills fade without practice. The point at which someone decides to give up coding entirely and hand the work over to an agent is surprisingly easy to reach. According to the writer, after just a few weeks of letting agents do all the coding while you sit back, you’ll find it difficult to start coding again on your own.
LLMs Are Worse Than Advertised
Artificial intelligence systems are much poorer at crafting readable, human-friendly code than claimed. They do manage to produce something serviceable when the code will only ever be worked on by another AI. Yet the writer is confident readers have felt the frustration of staring at an entire file produced entirely from scratch, knowing there is a flaw within it somewhere, and feeling helpless to spot it oneself, since the territory looks so unfamiliar.
The route to achieving greater productivity does not involve letting agents handle the coding. Instead, it lies in assigning them almost every other responsibility, particularly the tedious jobs that cause annoyance. The ideal tasks are those that are not difficult to execute correctly and simple to verify.
Planning With LLMs
Computers have served as bookkeeping aids since their very beginnings. Treat LLMs as such a tool, one that accepts instructions given in plain speech rather than through a formal interface. It turns long exchanges among specialists into practical tasks. Record the outcome of a test, and let the system sort those findings into a course of action aimed at correcting any flaws.
Use tools like a todo tool, or better even markdown files with frontmatter to make it track planning items properly. LLMs can have a huge context, but still if it is too full it can silently lose information. Don’t let it make any crucial decisions. Make it ask you. If you don’t understand the question, it is the LLMs fault not to give you the relevant context (or you might be exhausted and need a break).
When you find yourself going over the same problems repeatedly, pause and look at the situation on your own, so that you can come back with a clear idea of where you stand.
Researching With LLMs
An agent’s research task can lull you into watching it query and “thinking”, or into starting up another agent on a separate project, or into making a coffee. Of those three choices, the coffee is the best one. The superior choice is to research yourself alongside the agent using a search engine, so you at least roughly know everything the agent will come across.
Don’t just let it research something, accept its results as facts and plan from there. This will lead to embarrassing technical debt. The point of making an agent research is not for it to present all the relevant knowledge to you, or make a better decision than you could have made. The point is that you don’t have to go “Let Me Google That For You” on it.
Make sure you know the field you’re building models for at least as well as the agent does, and preferably better. Have your agents record their research findings along with references to the sources they drew on.
The Irony of the Post
The humor here comes from the author’s own confession. Once they were taken for an LLM-generated text, they felt compelled to correct the impression. It is ironic that the proposal to halt agents writing code originated from a text that had previously been mistaken for AI-generated work.
The writer’s position is consistent. They are not anti-LLM. They are pro-productivity, pro-judgement, and pro-the coder’s joy. The writer wants to use LLMs for planning and research, but draw the line at code generation.
What We Make of It
This post serves as a helpful reminder that relying on an LLM for assistance need not mean giving up craft entirely. There exists a middle ground between complete reliance and complete rejection. The writer refers to this approach as a moderate productivity gain.
Instead of treating LLMs as replacements, it’s best to use them as tools. Let them take care of the organising, the bookkeeping, and the research. The coding should stay your own work. Skills can fade fast, and the bugs in generated code are real.
The writer’s advice is worth repeating:
- Keep writing code yourself, at least the enjoyable parts.
- Let agents handle the boring, repetitive tasks.
- Use LLMs for planning and research, but verify their results.
- Don’t let them make crucial decisions without asking you.
- Understand the domain as well as the agent does.
The guidelines address a genuine concern for those who fear LLM burnout, and they have spread far and wide. The case made is plain, the consequences weigh heavily, and the humor in it is sharp.
Source material: “How to keep enjoying programming in a world of LLMs,” haskell.org.
Get the Notebook.
The day's best stories and every fresh verdict, in plain English, in your inbox by seven. One email a day, no more.