Post

This is where my opinion has landed as well. Most of the “typing” is done by LLMs for my own code these days, but I’m still in my IDE, reading, watching the diffs go by, interrupting to tell it to do something differently, refactoring regularly to make sure the code is legible.

dan@danabra.mov

having used claude extensively for the past couple of months, i think there is still a lot of value to understanding your code and steering it intentionally. the amount of incidental complexity claude accumulates otherwise (which mostly results in bugs that it can't ever fix reliably) is staggering.

This aligns completely with where I’m at too. Code may never have been the hard part, but it’s still an important part.

George Rodier@georgerodier.com

I care less and less about who is producing code and how they are producing it, but the longer I’ve been a developer, the more I care about that code (at certain levels of fidelity), because it has a direct impact on performance, cost, and user experience.

I think it’s going to follow a similar cycle to the discourse around dynamic languages. - “Developer time is the expensive bit, write in a more expressive language like Ruby or Python.” - “Actually this is really slow and annoying, let’s make it faster.” - “Maybe we actually rewrite in Rust.”

“Speed is a feature, actually.” And that’s not to say dynamic languages have no place, I love Python and write a lot of it. But the answer was never to completely eschew performance for ease of writing. The answer will never be Gas Town.

0 reposts3 likes

Gastown to me was like throwing 100 monkeys in a room and telling it to produce Shakespeare. We could hope that battling agents eventually produce something performant. Or we could explicitly direct the LLM on what can be improved because we have an understanding of the underlying code.

At some point the economics of have an understanding of a code base and being able to directly request changes via LLM will be cheaper than them consistently churning.

I think Gas Town’s primary value is as a form of entertainment and upvotes on Hacker News for whatever Steve Yegge is working on atm. And to be fair to it, it _excells_ at this.

I also liked it as a genuinely interesting speculative design for what multiagent system and a “selfdriving codebase” would look like. It’s crazy but it’s also genuine

The real challenge I’ve been thinking through is what’s the right fidelity of decision to delegate. I tend to be more granular than most and wanting more control over the decisions (which generally means more pre planning and keeping requests small so I can thoroughly review)

And I think a lot of that is what everyone is trying to figure out and it’s interesting to see how much people are willing or not willing to delegate and their decisioning process around that. I imagine plenty of books to be written on the topic in the future.