skevyVibing a non-trivial Ghostty feature
Tip: I very often use AI for inspiration. In this case, I ended up keeping a lot (not all) of the UI code it made, but I will very often prompt an agent, throw away everything it did, and redo it myself (manually!). I find the "zero to one" stage of creation very difficult and time consuming and AI is excellent at being my muse.
This right here is the single biggest win for coding agents. I see and directionally agree with all the concerns people have about maintainability and sprawl in AI-mediated projects. I don't care, though, because the moment I can get a project up on its legs, to where I can interact with some substantial part of its functionality and refine it, I'm off to the races. It's getting to that golden moment that constitutes 80% of what's costly about programming for me.
This is the part where I simply don't understand the objections people have to coding agents. It seems so self-evidently valuable --- even if you do nothing else with an agent, even if you literally throw all the code away.
PS
Put a weight on that bacon!
> This is the part where I simply don't understand the objections people have to coding agents
Because I have a coworker who is pushing slop at unsustainable levels, and proclaiming to management how much more productive he is. It’s now even more of a risk to my career to speak up about how awful his PRs are to review (and I’m not the only one on the team who wishes to speak up).
The internet is rife with people who claim to be living in the future where they are now a 10x dev. Making these claims costs almost nothing, but it is negatively effecting mine and many others day to day.
I’m not necessarily blaming these internet voices (I don’t blame a bear for killing a hiker), but the damage they’re doing is still real.
I don't think you read the sentence you're responding to carefully enough. The antecedent of "this" isn't "coding agents" generally: it's "the value of an agent getting you past the blank page stage to a point where the substantive core of your feature functions well enough to start iterating on". If you want to respond to the argument I made there, you have to respond to the actual argument, not a broader one that's easier (and much less interesting) to take swipes at.
My understanding of your argument is:
Because agents are good on this one specific axis (which I agree with and use fwiw), there’s no reason to object to them as a whole
My argument is:
The juice isn’t worth the squeeze. The small win (among others) is not worth the amounts of slop devs now have to deal with.
100% agreed.
> "Put a weight on that bacon!"
?
Mitchell included a photograph of his breakfast preparation, and the bacon was curling up on the frying pan.
People get into this field for very different reasons.
- People who like the act and craftsmanship of coding itself. AI can encourage slop from other engineers and it trivializes the work. AI is a negative.
- People who like general engineering. AI is positive for reducing the amount of (mundane) code to write, but still requires significant high-level architectural guidance. It’s a tool.
- People who like product. AI can be useful for prototyping but won’t won’t be able to make a good product on its own. It’s a tool.
- People who just want to build a MVP. AI is honestly amazing at making something that at least works. It might be bad code but you are testing product fit. Koolaid mode.
That’s why everyone has a totally different viewpoint.
Real subtle. Why not just write "there are good programmers and bad programmers and AI is good for bad programmers and only bad programmers"? Think about what you just said about Mitchell Hashimoto here.
I'm not sure that's a fair take.
I don't think it's an unfair statement that LLM-generated code typically is not very good - you can work with it and set up enough guard rails and guidance and whatnot that it can start to produce decent code, but out of the box, speed is definitely the selling point. They're basically junior interns.
If you consider an engineer's job to be writing code, sure, you could read OP's post as a shot, but I tend to switch between the personas they're listing pretty regularly in my job, and I think the read's about right.
To the OP's point, if the thing you like doing is actually crafting and writing the code, the LLMs have substantially less value - they're doing the thing you like doing and they're not putting the care into it you normally would. It's like giving a painter an inkjet printer - sure, it's faster, but that's not really the point here. Typically, when building the part of the system that's doing the heavy lifting, I'm writing that myself. That's where the dragons live, that's what's gotta be right, and it's usually not worth the effort to incorporate the LLMs.
If you're trying to build something that will provide long-term value to other people, the LLMs can reduce some of the boilerplate stuff (convert this spec into a struct, create matching endpoints for these other four objects, etc) - the "I build one, it builds the rest" model tends to actually work pretty well and can be a real force multiplier (alternatively, you can wind up in a state where the LLM has absolutely no idea what you're doing and its proposals are totally unhinged, or worse, where it's introducing bugs because it doesn't quite understand which objects are which).
If you've got your product manager hat on, being able to quickly prototype designs and interactions can make a huge, huge difference in what kind of feedback you get from your users - "hey try this out and let me know what you think" as opposed to "would you use this imaginary thing if I built it?" The point is to poke at the toy, not build something durable.
Same with the MVP/technical prototyping - usually the question you're trying to answer is "would this work at all", and letting the LLM crap out the shittiest version of the thing that could possibly work is often sufficient to find out.
The thing is, I think these are all things good engineers _do_. We're not always painting the Sistine Chapel, we also have to build the rest of the building, run the plumbing, design the thing, and try to get buy-in from the relevant parties. LLMs are a tool like any other - they're not the one you pull out when you're painting Adam, but an awful lot of our work doesn't need to be done to that standard.
I can't get past the framing that "people who like the act and craftsmanship" feel AI is negative, which implicitly defines whatever Mitchell Hashimoto is doing as not craftsmanship, which: ghostty is pure craftsmanship (the only reason anyone would spend months writing a new terminal).
No, I think my response was fair, if worded sharply. I stand by it.
Your response conflates the categories of people and ignores that statements like "people..." can mean "(some|most|all) people..." in casual writing/speech. It is not a fair response.
I agree with your frustration with the framing that _all_ people who like the act and craftsmanship feel AI is negative, and the consequence that if one does like AI, then they must not like the act of craftsmanship. Many such people view it as a tool, Mitchell included.
I'm the opposite, I find getting started easy and rewarding, I don't generally get blocked there. Where I get blocked, after almost thirty years of development, is writing the code.
I really like building things, but they're all basically putting the same code together in slightly different ways, so the part I find rewarding isn't the coding, it's the seeing everything come together in the end. That's why I really like LLMs, they let me do all the fun parts without any of the boring parts I've done a thousand times before.
It's funny because the part you find challenging is exactly the thing LLM skeptics tend to say accounts for almost none of the work (writing the code). I personally find that once my project is up on its legs and I'm in flow state, writing code is easy and pleasant, but one thing clear from this thread is everyone experiences programming a little differently.
Yeah, definitely. I do agree with the skeptics to a point, as I don't let the LLM write code without reviewing (it makes many mistakes that compound), but I'd still rather have it write a function, review and steer, have it write another, and so on, than write database models myself for the millionth time.
It's not that I find it hard, I've just done it so many times that it's boring. Maybe I should be solving different/harder problems, but I don't mind having the LLM write the code, and I'm doing what I like and I'm more productive than ever, so eh!
I was just talking about this in a chat today, because 'simonw had at some point talked about getting to the point where he was letting go of reviewing every line of LLM code, and I am nowhere close to that point --- I'll take Claude's word on Tailwind classes as long as the HTML looks right, but actual code, I review line-by-line, token-by-token, and usually rewrite things, even if just for cosmetic reasons.
Yeah, there's a definite continuum for where LLMs are most to least expert. They seem to be fairly OK with JS, less so with Python, and C is just a crapshoot.
It depends on the project as well, for throwaway things I'm fine to just let it do whatever it wants, but for projects that I need to last more than a few days, I review everything.