The new AI Era #

Recently I read about Steve Yegge’s post about GasTown, an ecosystem of agent orchestration to go get monster-sized projects done.

I was a bit slow on the uptake when it came to AI: a lot of code last year was hand-written when many had already started letting agents do most of it. My thought was, at the time, the models themselves were often unable to produce a working feature. Let alone produce good code.

But only a year later, with models like Claude Opus 4.6 and Gemini 3.1 pro, these agents are generating code extremely quickly. And the code is actually… decent. It’s not mind-blowing - the agent still makes multiple stylistic mistakes, despite my prompt telling it not to:

  • It does not adopt functional programming methodologies, freely mixing IO with business logic.
  • It repeats itself constantly.
  • It often re-writes things it can use a library for.

But it’s good enough where I can get into a productive loop.

My workflow today #

My workflow looks like:

  1. Write up a design or prompt (I usually like to document my actual written prose somewhere, usually a DESIGN.md).
  2. Ask Cursor / Claude / Gemini to implement it.
  3. Review the code, ask it to fix things. Back to 1 if needed.
  4. Validate the feature e2e. Back to 1 if needed.
  5. Commit and push.

I’d argue this is very hands-on. But even with this level of micro-managing, I get a ton of changes done in a short period. Over 1.5 hours on a random Saturday, I got through 7 feature requests in aep-e2e-validator, and I felt good about the code and the result of those. Probably 3-4x what I could with a coding-first approach, and with probably one half of the mental load.

Oh, and I also created a code extension to fill in some missing gaps I had in openvsx (https://github.com/toumorokoshi/code-fileclrk). And a couple bugs in other repositories. So I guess that’s more like 10 contributions in a 1.5 hour period, and a 5x increase?

Regardless the multiplier at this point is astounding. As Steve said in his blog post, the bottleneck here really is no longer the code.

My workflow in the future #

I thought the above was great, but then I read GasTown. To be clear, I am a still a pessimist on AI, so I don’t want to say I’ve drunk the Kool-aid just yet. But the extremely detailed post helped me really understand what an 100x future could look like. It’s basically layers of abstractions, but with AI agents filling almost every single piece of the puzzle:

  • agents are writing code.
  • agents are reviewing PRs.
  • agents are helping summarize the changes and writing them out to a record of what decisions were made.
  • you talk to an agent to help dispatch these tasks to other agents.

And so on - multiple role-based agents, that fill whatever gap you’ve encountered with the other agents you’ve already deployed. Assuming the agent is good enough, or you’ve anchored the manual review to the point of no return (e.g. before performing a financial transaction, or perhaps cutting a release), you could delegate the next level of review over and over again.

And intuitively - this kind of makes a wacky kind of sense, where you are abstracting yourself to the point where you are focusing on the problem where human judgement is truly needed. In the past, for someone to get something accomplished with software, you had to work on every single piece by hand (perhaps except the hardware you run on). But now, if there’s a task you don’t find particularly appealing, and as long as you’re willing to do some manual review, you can definitely delegate that to an agent!

The caveat: you need the domain knowledge to succeed #

Some might read the above and believe that this means that an individual does not need the same skills that the agent does. For example, a non-technical person can write software. I don’t really believe that’s the case, at least not 100%.

For one, it’s important to know that there are just some concerns that are so mission-critical that you cannot reasonably accomplish that without some sort of expertise or awareness. Those are:

  • Proper resource management, quotas, and monitoring so you don’t get a giant check that backrupts you.
  • Security. If your service is compromised, the damage is irreperable.

But there’s a huge swath of things that you don’t really have to understand too deeply at the beginning. And as long as you have the skills and time to dive in, AI could take the first swag at it:

  • command-line interfaces.
  • applications that run locally.
  • any codebases that have significant guardrails (linting / testing / etc).

Final Thoughts #

So what is the bottleneck now? #

It feels like the bottleneck now is the human’s ability to reason about a problem and figure out a good solution. I suppose one can argue that human reasoning was always the bottleneck, but I think the abstraction is at a higher level now.

Oh, and money / energy. You can produce as much as you have money to pay for an agent to generate for you. That or your human ability to think about these problems, which limits you first.

Human interaction is still needed #

In this fever dream of AI, there are no humans. But to make real change happen in an organization, you still need to talk to people, and that’s the real challenge.

Pretty much everything that has real impact, to some extent, requires thoughtful interaction with others:

  • Getting buy-in on the idea.
  • Getting others to use it (sharing demos, recordings, talking to people in 1-1s and through slack).
  • Getting approvals to merge or ship the code.
  • Getting the team that owns the product to accept your idea and put it on their roadmap (or accept your code).

So although some coding is trivial now, I don’t believe that the bulk of the my work, for example, is removed. Communication and interaction with individuals is still key.

Agents give us the freedom to dive into the problem we want to #

Perhaps there is a world where someone chooses to completely ignore code or a particular engineering problem algother. But I don’t really see this as my motivation.

I think agents provide us the freedom to work on the problems we want to, or perhaps minimize the time we spend on the problems we don’t want to work on. We have a fairly autonomous coder / problem solver than can get things mostly right, and we can trust if we need to.

But if we want to, we can dive right in! And there’s reasons to do so: the code may have gotten too messy, the abstractions are not easily understood, or the code is not performant.

And if you want to assert that level of control and code something yourself, you can! So again, in some ways it’s refreshing in that you can spend more of your time on the problems you care about, not just the rote ones that need to be done.

When and how will we get to this glorious future? #

So when can we get to this world where agents completely autonomously write their own code and produce real, working products?

I think for some software engineers, they’re basically there today. GasTown seems like it’s run fairly automated with agents working on it all the time. I don’t think throwing agents at compilers and browsers has produced a working product either.

For me personally, I don’t know if I have a project that really is accelerated by 100 autonomous agents all writing code. But I’d like to start climbing this maturity ladder to see if I can squeeze out a little bit more of that time to think about the problems I’m really interested in diving into.