To me, literally writing code by hand instead of letting AI do it feels like digging a foundation pit with a shovel instead of letting an excavator do it. Sure it can be done but much slower and the benefits are questionable. But curious if you have reasons to believe otherwise?

▲

bluGill 5 hours ago | parent | next [-]

Every excavator crew I've seen has a shovel on the truck. They sometimes pull it out of the truck and use it. Most of the time though you can get the excavator there and get the job done faster than any hand work.

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."

	▲	dimonomid 4 hours ago \| parent [-]
		Yeah a small amount of manually-written code still makes sense, when it's faster to write it than to tell LLM to write it. 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.

▲

alerighi 5 hours ago | parent | prev | next [-]

It's not the same example, the excavator is driven by a human being, it's a tool (in coding world the same as using an high level programming language instead of writing bits into the computer memory).

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.

	▲	dimonomid an hour ago \| parent [-]
		Yes, LLM is a tool. And CEOs of the tech companies are retaining developers not because there is value in writing code by hand, it's because developers can use that tool effectively and responsibly: they can tell bad code from good code, they design the solution, let AI do the hard boring work of coding it out, then these developers check its output, test it, also they can be creative and e.g. ask LLM to review LLM's output, etc etc. But the need to manually type stuff out arises very infrequently in my experience. It happens but it's an exception, not the rule.

▲

swatcoder 5 hours ago | parent | prev | next [-]

If your work is analogous to digging a foundation pit or something like framing up homes in a development, that makes a lot of sense. But that's not the only kind of work many of us do, and analogies to things like finish carpentry, functional sculpture, or fine furniture are more applicable. Hand craft doesn't always make a difference, but there's plenty of places where it does.

Plus, for a lot of people with fluency and experience, it's simply more fun/natural and not meaningfully less productive.

▲

greggoB 5 hours ago | parent | prev [-]

Genuine question: do you feel this disparity despite being diligent and checking the LLM's output, or is that not factored in?

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.

	▲	dimonomid 5 hours ago \| parent [-]
		Of course checking the LLM's output and testing it and iterating on it is factored in. And yeah that verification and testing and iteration where most of the time goes, and still it ends up being significantly faster than typing everything manually, and the end result quality is often higher I believe. 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)