I think there are things LLMs are really good at coding up and experimenting with but I think there's still a need to understand the btoader context of your software so you need to dive in at some point.
I think if I fully understand everything the agent is going to do and trivially verify the output quality, LLMs are a win. For one off prototypes, the same is true. For software which is unique, complex, and performing a task which has not been fully specified I find myself needing to drop into my editor more and more.
Recently I've been moved to a research focused team and I really need to have proof that something is happening. I've had Claude Opus 5 gaslight me by telling me it did something and when I read the code it obviously did not. This happens more and more with my tasks that are kind of complex.
I've found a lot of the claims by AI people have been 6mo - 2 years "ahead" of my experience. I think we are now in an era where harness engineering is highly valuable (making a test, looping an agent, manually annealing with new ideas) but the claims that no one writes code manually seems like it may not be fully there for all code.
I harped on checking someone's ability to debug code back when I interviewed candidates, in part because I found that people who could debug effectively could also sniff out bad code. It was something of a bonus that I also happened to select for candidates who could explain their debugging strategies and what that meant for the software they were working on.
But you're right. The better indication of capability is debugging skill than writing skill.
One of the first things I do in any new-to-me project is set breakpoints in the integration tests and start stepping through the code so that I can establish some mental context. However, if there aren't integration tests, I begin writing them so that I can walk around with my debugger.
But yes I agree that as part of learning effort it's important to write, too.
edit to add: the irony of the grammatical error in this presumably hand-written sentence inside the "Who's behind this?" link:
> Jared’s web studio Whitefusion is currently partnering with quality businesses & organizations which believe in staying away from costly hype cycles and the value of the human touch.
Join a local meetup!
The most common use for a shovel seems to be "this is as close as I dare get to the wire we know is around here - scrape the dirt away until you find it and then I'll dig the rest out."
In particular comments. I'm not a fan of the comment style LLM tends to write, so I often just write them manually.
And also coming up with the right architecture is also often manual job. Design how to implement things, and let LLM implement it.
The LLM *may* be used as a mere tool, that is something you ask question time to time, but shouldn't be the thing that makes the work that you should do. Because if we arrive at this point (hopefully never) at that point the CEO of the tech companies may as well say, why we still need developers? Let's fire all of them.
Fortunately they did not, because there is STILL VALUE in writing code by hand, understanding what it happens, what the code will do, etc. I hope this will not be a lost skill, or well, if it does good for me, because the same as nowadays things being able to repair electronic devices makes a ton of money (I've considered opening a repair shop) because there is no one still doing it, will do programmers that well, know how to program.
But the need to manually type stuff out arises very infrequently in my experience. It happens but it's an exception, not the rule.
Plus, for a lot of people with fluency and experience, it's simply more fun/natural and not meaningfully less productive.
It's also been my experience that generating an entire app/portion of code can be much easier by typing out a relatively concise prompt, but this only applies if it's the kind of code I'm
1) free from having to verify afterwards,
2) not having to fight with the LLM to get right, or
3) is coming from someone else in the form of a PR that may/may not have been checked by them first.
Having to deal with these cases has sometimes been the equivalent of using a spoon to dig a foundation, at least in my experience.
To avoid fighting with the LLM to get right, it's useful to first come up with the architecture manually, run it by the LLM first (without writing any code - just talking to it, asking it to find flaws in your architecture), and once both you and LLM are happy with the plan, fire it to execute. This step removes a lot of friction (but not all of it - later iterations are still almost always necessary)
People dont seem to realize prompt to code is just another interface. Is the human review part that we should care about, did this code get reviewed and reiterated on? Is it fully AI generated and reviewed?
Those are the important tasks.
Whoever feels like a better programmer because they write all the terraform files by hand and not use an llm, dislike.
To each their own, though.
From the OED. The predominant use of "Luddite" has been disparaging for a long time.
You can debate whether it should be or not, but it's not reasonable to criticize conventional use.
I've worked in corporate environments for nearly two decades, and I can assure you that I have seen a lot of very low-quality "handcrafted" code running in production. I don't really see "handcrafted" as a signifier of quality, even if I agree that SOME SPECIFIC handcrafted code is better than SOME SPECIFIC AI-written code (and vice versa).
Sure, those 8 are often thrown away while that 1 often ends up moving mountains but so what?
For vibe coded code from what ive seen it's about 10:0.
We should clearly only write that from now on.
I'm sure a lot of the signatories on this list feel the same.
There's just no way I could go back to writing code by hand with the temptation of AI right there in front of me.
Anyway, I’ll briefly share why after trying full agentic coding in earnest, I’m back to writing almost all my code by hand (I even turned off AI edit predictions). I will not deny that a lot of AI code is quite good these days, but in my experience it’s nowhere near the point where I’m comfortable not reviewing it. So if I have to review it, then this means I need to read verbose more code than most human developers write and that is just not fun. But beyond just not being fun, as I got farther from writing the code myself, it felt like I was a worse reviewer. Obviously total skill atrophy doesn’t happen overnight, but I felt like even being away from coding for a few weeks or months, I was more and more “out of shape” and whenever I did dig into the code base, even if I had reviewed everything and guided the AI, it all felt really alien. And then there is the part about needing to read tons and tons of annoying AI generated prose and argue with it constantly. Ultimately after a few months of trying this on some personal projects, I realized that because I had been so disinvolved with writing the code, most of it needed to be reworked in pretty substantial ways. Once I started writing the code again, I realized my net ability to steer the code in the right direction was faster when I typed it out than by going through this tiring LLM prompt/review/re-prompt loop while my skills were subtly atrophying each day. Now that I’m back to writing almost all my code by hand, I sort of hold the opinion that hand-coding is an unreasonably effective away of developing software architecture intuition and steering a codebase in the right direction. Also, I realized typing code is not actually that slow - thinking is definitely the slower part and the more you offload your thinking and understanding to robot who has literally zero persistent memory or stake in your project, the less capable you’ll be of doing the thinking when you need it.
I still use AI for brainstorming, reviewing my code and one-off prototyping/benchmarking tasks, but usually even if it writes some decent code snippet in the chat for me, I’ll go and handwrite it myself because then I actually get to learn something! This also let’s me confirm that the AI suggested approach is correct (usually it’s pretty good, but sometimes it’s off). I know some people are saying you have to stop reviewing code if you want to be fast with AI - that’s true and maybe that’s what the future will look like. But if humans still need to be involved in understanding and guiding code, I think handwriting code is quite a good way to stay on top of things.
/s