When it comes to AI, there seem to be only two camps right now: those for it and those against it. That is why I find the way Linus Torvalds talks about it so interesting. To him, LLMs are tools that can help you: "AI is a great tool, but it's a tool", combined with a "love-hate relationship".

What that looks like in practice is documented in one of his commits, fixing a bug in the Intel Xe graphics driver. The LLM repeatedly declared the problem "impossible and unsolvable" and said they should just write a report about it. Torvalds did not give up and went through what he calls a "debug session from hell": 24 patches adding more and more debug output and 18 kernel boots until the bug was found. In the end, a round_up() had to become a round_down().

It hardly gets more ambivalent than that. The tool wanted to give up several times, and without the tool the session would have been far harder.

I have the same ambivalent feeling about using AI, or more accurately large language models, in everyday life. On the one hand, I find coding through an agent boring and somehow unsatisfying. On the other hand, I use agents practically every day, and they save me a lot of time and nerves.

Two Tasks, Two Feelings

Recently I was on holiday with my family at the North Sea. Even so, there was a small task in the back of my mind that I wanted to tackle: moving my website from Jekyll to Zola.

When I first built the site, I set up a simple GitHub Page and had an agent create the design. You should know that I have not done any web development in over 20 years. As a teenager I had a few hobby sites about gaming, and that was it. I was very unhappy with the result: the site was overloaded and could not be built without special packages.

This time I wanted to build at least the basic structure myself. So I started the Zola tutorial and quickly realized that web development does not really interest me. In classic fashion, I kept putting off the rest.

Back at work, the next task came up. As a Product Owner, part of my job is creating roadmaps in PowerPoint and budgets in Excel, and once again a roadmap was needed. I am not much of a designer. So I wrote the most important information on a slide and had an agent create the design. After several feedback loops, everything was done in less than an hour.

For one task I did not really want the agent around, for the other it was a real relief. The reason is simple at first glance: I do not like designing PowerPoint presentations, but I do like writing code.

What I Miss

That falls short, though, because with code I care about more than the result. I find the typing itself meditative. That goes for code just as much as for the knowledge I work out in bullet points for my Zettelkasten. It forces me to slow down and stay with one thing. Writing the bullet points up into finished notes is something I happily leave to an agent, because by then the thought is already there. But if the agent also takes over the thinking before that, I get a text or some code, and the time spent with the thought is gone.

Then there is the puzzling. I want to solve problems that challenge me cognitively myself, because that is exactly the exciting part. If I have the solution generated, the problem is done, but I got nothing out of it.

For things that annoy me, on the other hand, I gladly turn to AI. Lists, presentations, boilerplate: here I want the result and not the road to it.

When Learning, the Shortcut Is the Wrong Way

There is a second reason for restraint, and it has nothing to do with fun. Especially when you are learning something new, AI is not particularly useful. You do not really learn the material and you come to rely on the LLM too easily. As long as everything works, nobody notices. You only notice when you have to find the bug yourself or judge whether the answer is even right.

My website is a good example. The agent built me a site, but I am no better at web development because of it.

I am thinking a lot about learning at the moment, because my son has started school. What I found interesting in Brainhacks by Henry Hildebrandt is that our brain and memory learn above all through repetition, imitation, and trying things out. Typing along with tutorials or reading books can help, but without doing it every day the knowledge will probably be gone quickly. So a Zola tutorial alone does not make me a web developer either.

This is exactly where AI can help after all, as a learning coach. It can give me exercises, quiz me, revisit topics, and explain my mistakes without handing me the solution. The difference lies in who does the work: if the agent solves the task, I learn nothing. If it makes sure I keep solving it myself, it becomes a coach.

A New Pair of Hands

For me the most important insight was how you have to work with agents. I used to treat them more or less as equals. That was a mistake. An agent is more like a new pair of hands that I delegate tasks to. The head stays with me.

Torvalds' debug session shows exactly that. The LLM wrote debug code and analyzed the output, but he was the one who decided to keep looking. Giving a hard problem to an agent does not mean giving it away. I can hand off the grunt work, while the persistence and the judgment stay with me.

It also means that "Build me app xyz" is not a sensible task. It leaves the agent with all the decisions that should be mine. That is why I prefer a spec-driven approach: before the agent starts, a spec clearly defines the goal, what the architecture looks like, and which constraints apply. The thinking still happens with me, just before the implementation.

An example: in Neovim I use parrot.nvim with a local model. This is how I would specify that setup today:

# Spec: Local AI Chat in Neovim

## Goal
Chats, code reviews, and draft Zettel directly in Neovim,
without any content leaving my machine.

## Architecture
- parrot.nvim as the plugin, Ollama on localhost as the only provider
- Model and context window configured in exactly one place
- Chats are stored as Markdown in the vault
- The Zettel prompt lives as a file in the vault, not in the code

## Constraints
- No cloud providers, no API keys
- No background requests: no model list, no LLM-generated chat titles
- If the prompt file is missing, show a warning instead of an empty chat

## Non-goals
- No agents that change files on their own

## Acceptance criteria
- :PrtReview checks the selection or the whole file and shows the result
  in its own window
- :PrtZettel starts a chat with the prompt from the vault
- Everything keeps working without a network

Every one of these lines is a decision the agent would otherwise have made for me.

Even my PowerPoint slide was exactly that on a small scale. The content came from me, along with parts of how I pictured it, and the agent took care of the form and the actual work in the tool.

What Has Changed for Me

Many will consider this a trivial insight. Even so, I believe many people do not use agents this way and see them more as a question bot.

For every task, I now try to be conscious of the following: Do I find it personally and intellectually interesting and want to puzzle over it? Do I want to learn something from it? Or should it simply get done quickly? Only in the last case does the agent get it, and even then with a clear spec. If I want to learn, it may at most be a coach.

At work there is a fourth question: Does this need to be done at all? An agent writes the meeting notes faster, but was the meeting necessary? I have already written about why output alone has no value in Beyond Busyness.

For me, all this means: I want to write blog posts and think about them, but spend less thought on web development. For now.