TL;DR: I believe that LLMs are really powerful, but introduce a temptation to be lazy, which you need to be more on top of than ever.

Writing

I don't delegate authorship.

I strongly believe that LLMs should not be used to generate emails, blog posts, or anything else where we're talking directly to a human. I think it's lazy, and I think writing is a very important part of the communication process, where a lot of the thinking is done.

This means I don't use LLMs for blog post writing, for emails, or other written communication. I'm experimenting using them to help edit, but that's riddled with issues, and you have to be very selective about which suggestions you accept. I don't see myself changing this stance however good LLMs get.

This quote sums up my thoughts pretty well, and applies to non-AI generated content too (emphasis mine):

slop is something that takes more human effort to consume than it took to produce. When my coworker sends me raw Gemini output he’s not expressing his freedom to create, he’s disrespecting the value of my time

-- Neurotica (@schwarzgerat.bsky.social)

I'm unsure about how this applies to things like documentation in a codebase: LLMs don't do a good job without a lot of direction (I focus on why and how. LLMs seem more interested in what and where, which isn't the point. They also default to excessive verbosity), but they can be made to work here, and the alternative is often no documentation.

Agentic Coding

I really enjoy using LLMs for writing software: I've always cared more about the outcome (the way the software I write changes the world, even in small ways), than the actual code. I care deeply about writing maintainable, well structured software, but recently have realised that this comes from wanting to be able to change things easily and be confident in the quality of the software, not necessarily from an 'aesthetic' place.

That being said, I have fairly strong opinions on how agentic coding should be deployed:

For prototypes I tend to just write a detailed prompt, give it some way of verifying 'completion', and then let the agent run until it's finished something. I don't need to look at the code because it's going to be thrown away afterwards.

For production code, I care much more about the output of the agent. I currently review every line (I haven't found a reliable way of getting agents to produce 'good' code without burning a lot of money on tokens). I work hard during a 'planning' phase to build a shared understanding of the problem with the LLM. This involves interrogating interfaces and data structures to be used very carefully and making sure that they're at an appropriate level of abstraction, then breaking the implementation down into small chunks that can run in a single context window.

As a thinking aid

Given I said at the top that LLM use makes us tempted to be lazy this may be a surprising position to take, but I do find LLMs can be useful as a thinking aid.

I have started using Matt Pocock's "Grill Me" skill for things like ideation for 360 feedback during PDRs at work. I get an LLM to interview me about a person and how I've worked with them, grounded in the 'competency matrix' we use. This interview format often sparks other thoughts which I can jot down and get a better set of feedback for the person. I never use an LLM to write the feedback, just as an interviewer & note taker. This is similar to 'rubber ducking', but can be applied where that might not be appropriate!

Further Reading

As I've been thinking about this stuff, I've found the following helpful:

Last Updated: July 2026