> This assumes every individual is capable of succinctly communicating to the AI what they want. And the AI is capable of maintaining it as underlying platforms and libraries shift.

I think there are people who want to use software to accomplish a goal, and there are people who are forced to use software. The people who only use software because the world around them has forced it on them, either through work or friends, are probably cognitively excluded from building software.

The people who seek out software to solve a problem (I think this is most people) and compare alternatives to see which one matches their mental model will be able to skip all that and just build the software they have in mind using AI.

> And that there is little value in reusing software initiated by others.

I think engineers greatly over-estimate the value of code reuse. Trying to fit a round peg in a square hole produces more problems than it solves. A sign of an elite engineer is knowing when to just copy something and change it as needed rather than call into it. Or to re-implement something because the library that does it is a bad fit.

The only time reuse really matters is in network protocols. Communication requires that both sides have a shared understanding.

▲

fauigerzigerk 9 hours ago | parent | next [-]

>The only time reuse really matters is in network protocols. Communication requires that both sides have a shared understanding.

A lot of things are like network protocols. Most things require communication. External APIs, existing data, familiar user interfaces, contracts, laws, etc.

Language itself (both formal and natural) depends on a shared understanding of terms, at least to some degree.

AI doesn't magically make the coordination and synchronisation overhead go away.

Also, reusing well debugged and battle tested code will always be far more reliable than recreating everything every time anything gets changed.

▲

lioeters 9 hours ago | parent [-]

Even within a single computer or program, there is need for communication protocols and shared understanding - such as types, data schema, function signatures. It's the interface between functions, programs, languages, machines.

It could also be argued that "reuse" doesn't necessarily mean reusing the actual code as material, but reusing the concepts and algorithms. In that sense, most code is reuse of some previous code, written differently every time but expressing the same ideas, building on prior art and history.

That might support GP's comment that "code reuse" is overemphasized, since the code itself is not what's valuable, what the user wants is the computation it represents. If you can speak to a computer and get the same result, then no code is even necessary as a medium. (But internally, code is being generated on the fly.)

▲

fauigerzigerk 8 hours ago | parent [-]

I think we shouldn't get too hung up on specific artifacts.

The point is that specifying and verifying requirements is a lot of work. It takes time and resources. This work has to be reused somehow.

We haven't found a way to precisely specify and verify requirements using only natural language. It requires formal language. Formal language that can be used by machines is called code.

So this is what leads me to the conclusion that we need some form of code reuse. But if we do have formal specifications, implementations can change and do not necessarily have to be reused. The question is why not.

	▲	saezbaldo 4 hours ago \| parent [-]
		This reframes the whole conversation. If implementations are cheap to regenerate, specifications become the durable artifact. Something like TLA+ model checking lets you verify that a protocol maintains safety invariants across all reachable states, regardless of who wrote the implementation. The hard part was always deciding what "correct" means in your specific domain. Most teams skip formal specs because "we don't have time." If agents make implementations nearly free, that excuse disappears. The bottleneck shifts from writing code to defining correctness.

▲

Sharlin 6 hours ago | parent | prev | next [-]

> I think there are people who want to use software to accomplish a goal, and there are people who are forced to use software.

Typically people feel they're "forced" to use software for entirely valid reasons, such as said software being absolutely terrible to use. I'm sure that most people like using software that they feel like actually helps rather than hinders them.

▲

RealityVoid 9 hours ago | parent | prev | next [-]

> The only time reuse really matters is in network protocols.

And long term maintenance. If you use something. You have to maintain it. It's much better if someone else maintains it.

▲

skydhash 15 hours ago | parent | prev | next [-]

> I think engineers greatly over-estimate the value of code reuse[...]The only time reuse really matters is in network protocols.

The whole idea of an OS is code reuse (and resources management). No need to setup the hardware to run your application. Then we have a lot of foundational subsystems like graphics, sound, input,... Crafting such subsystems and the associated libraries are hard and requires a lot of design thinking.

	▲	joquarky 15 hours ago \| parent [-]
		There is a balance. Some teams take DRY too far.

▲

jimbokun 14 hours ago | parent | prev [-]

Which is why we should always just write and train our own LLMs.

I mean it’s just software right? What value is there in reusing it if we can just write it ourselves?

	▲	bandrami 8 hours ago \| parent [-]
		Every internal piece of software you write is a potentially-infinite money sink of training