The Old Work Keeps Getting Easier

I keep noticing that things I do for work are getting materially easier and faster, month over month. Both because the models themselves are getting better and because the form factors for using them keep improving. More tools, more integrations, more ways to point an agent at real work and get a useful result back.

The old work keeps getting easier. The new work is yet to be discovered, but it's going to be higher leverage.

The task that used to take an hour

The best example I have is understanding a codebase. Say you've got four services, multiple languages, infrastructure as code defining how everything is deployed, cron jobs running across six environments. You need to answer a question like "which of these services hasn't set up API linting" or "what are the differences in the cron job config across these environments."

The old way to do that: open a bunch of files in your IDE, run terminal commands to search for patterns across repos, keep the syntax for grep and find and awk fresh at your fingertips. Read Terraform in one tab, Python in another, YAML pipeline configs in a third. Context-switch between all of it, mentally stitch together how everything is deployed, then write up a coherent summary for your team.

That required fluency in terminal commands, familiarity with multiple languages, and the patience to piece it all together from dozens of files. Keeping all of those skills sharp takes real, ongoing investment. The number of people who could do it well was always small.

Now I write two or three sentences describing what I need to understand, fire it off to an LLM agent that can grep my codebase, read my infrastructure configs, and pull context from my issue tracker. I wait 30 seconds and get back a synthesized answer that accounts for all of it. I never opened a single file.

The model doesn't care that it's reading Terraform, then Python, then YAML. It doesn't context-switch the way I do. It just processes all of it and translates it into plain language. Three years ago this was impossible. Now it's 10x faster than doing it myself. That ship has sailed, and it's only going to get faster. What we tend to underestimate is how many doors that opens in the medium term.

Three types of work that keep getting easier

Understanding and synthesizing text. Three years ago this meant summarizing a document or writing a response to something. Now it means answering questions that require reading a lot of code and config across multiple repos in multiple languages. The scope of what counts as a "text task" has gotten way bigger.

Doing manual tasks in difficult interfaces. If a tool has a CLI or an MCP integration, you can skip the UI entirely and let an agent handle the interaction. Updating fields, running workflows, managing configurations. All the stuff you'd normally click through a buggy or unintuitive interface to do. The agent just talks to the API directly.

Building custom software for specific problems. One-off recurring jobs, small tools, things you need for your specific workflow. Get it built, deploy it on an inexpensive server, move on. A few years ago it was impressive to get a language model to change the color of text on a website in one shot. Now you can get a full-stack web app with auth, five API routes, CI with linting and test coverage, all done in minutes. The quality harness runs automatically. You never touch those checks manually again.

The complexity keeps moving higher up the chain. We don't need to multiply seven-digit numbers by hand anymore. That frees us up to work on the next problem instead of dealing with toil.

The actual skill now

The skill now is understanding the tools that are available to you and experimenting with them enough that you know what they're actually good at. An agent with access to your codebase, your cloud provider CLI, your ticketing system, your deployment configs can do certain work better and faster than any individual person. You just have to spend enough time with these tools to know where that's true, and then use them for everything in that category.

Text and digital data is where this hits hardest. There's an abundance of that information baked into the models. Transformers trained on massive amounts of text and code are really good at reading, searching, and synthesizing text and code. That covers a lot of what knowledge workers actually do all day.

Who this unlocks

The people I find most interesting in all of this are the independent builders. The ones who are self-accountable, who were already getting a lot done, and who now have access to tools that multiply what they can ship. If you're someone who doesn't need to be managed into productivity, this is an incredible time. You can build things that used to require a team. You can move from idea to working product in a weekend.

I've also noticed the flip side. When someone figures out how to compress an hour of work into 30 seconds, there's a natural instinct to keep that knowledge close. Get the same output in less time, use the rest for yourself. I'm sure plenty of people are doing exactly that right now. Eventually those gains become the new baseline anyway. What felt like a secret advantage today becomes the expected pace tomorrow.

Where I've landed

Nobody has predicted everything that's happened so far, and I don't think anyone's going to predict what's next either. The tools keep getting better month over month. MCPs, coding agents, CLI integrations, voice interfaces. There's more you can do with them every month.

I've been sharing what's working for me as I figure it out. That's basically what this blog is for.