How AI changed the way I work

I went back through my repositories and development setup to see how things had changed. First, moving to Neovim to code faster. Then came AI autocomplete, followed by agents that planned and implemented tasks, but I still reviewed their PRs. Now several agents run in parallel, and I barely look at the code.

At first, reviewing their work meant reading the diffs, understanding the decisions, and checking whether the result made sense in the product.

As that workload grew, I spent more time on the environment around the agents. Tools to investigate failures, sandboxes to reproduce them, checks that confirm the change works as intended. The software needed clearer boundaries too, so an agent could change one part without disturbing everything around it.

That judgment came from years of writing and maintaining software. I had already dealt with integrations that broke, abstractions that became expensive, and changing requirements that the original implementation could no longer support. That experience helped me decide what agents could handle and how to verify it.

The move from suggestions in the editor to delegating whole tasks made me realize how much of the work lived in my head. The conventions I took for granted, the boundaries I expected to stay intact, what I actually meant by “done”. Translating that into instructions required more precision than explaining the implementation.

I had to make the intent clear, give the agent enough context to act, and define how it could check the result. As I watched where agents struggled, I kept revising those instructions. I followed Anthropic and OpenAI’s lead in building harnesses around coding agents, adapting their approaches to my own instructions, tools, environments, and feedback loops.

Over time, building that harness became a substantial part of my engineering work. I began to think of the whole process, from giving agents a task to shipping the result, as a software factory.

As agents took on the implementation and code review, more of my attention could go into using the product, noticing where something feels awkward, and deciding whether a feature would help or just give us more to maintain. I have become more interested in those decisions, and more comfortable leaving things out.

For example, in IDHS, agents helped me overhaul the search and sharing experience and add more providers. Clear boundaries between parsers, adapters, services, and views made those changes manageable, while automated checks covered existing conversions and browser flows.

Measuring performance also helped me decide where to focus. Shared links were leaving people waiting for every provider before showing anything. Loading the track details first and the remaining links afterward made the page useful sooner. I could give more attention to decisions like that, with agents handling the implementation and verification.

Being able to try more ideas has made me more selective about the ones I keep. I can now ship more useful software, drawing on years of experience to make it safe to change, perform well at scale, and feel right to use.