It’s just like the oldest profession, you’re paid to scratch an itch - make someone happy. They rarely care about exactly how or why you’re doing it, just that you do it.

code was always written only once

What universe do you live in? My whole life has been modifying code. I may spend 20% of my time on “greenfield” writing of new code, but the rest is modifying other people’s code, modifying my own code, explaining to people how my and other peoples’ code works so they might modify it.

Writing code with LLM centric way and just focusing the high level gets hazardous pretty quickly, since somebody actually needs to understand the codebase deep down (or at least the relevant part) when something goes wrong.

In my industry we spend a significant amount of effort to ensure that “something goes wrong” before we ship, rather than after. Of course, we’re only human, bugs do ship, but they’re relatively rare - and field fixes get 10x the scrutiny of the already heavily scrutinized greenfield code.

For the past 6 months or so, I have come to respect LLMs’ ability to find more bugs earlier in the process - doesn’t matter if the code is written by people or LLMs, bugs happen. LLMs don’t find them all, but people find even fewer.

The other thing LLMs are starting to excel at is verifying that the documentation says what the code does, and the code does what the documentation says. Docs out of sync with code has been the bane of my past 3 decades, and before that I just didn’t write a lot of docs.

That’s a thing any time you decide you want one bad enough to find and buy it, or make it yourself. For far less than the cost of your cellphone you can contract with people who know how to make you a 3D printed little bug that does exactly that digital recording, possibly leveraging your phone to do most of the storage and user interface work.

Like many judges appear to be…

I consider myself as a seasoned programmer.

Is that hot pepper, salty, or both?

Interesting thing I see is that LLM slop generators are actually quite efficient at generating documentation, both for the end users and for developers, and like human generated slop-docs, the more cycles you put into review and refinement of them (both human guided and LLM self-review/refinement) the better quality you get out. Investing even half the person-hours in LLM generated documentation generates higher quality, more complete, better organized and more readable documentation for me than “working with a team” of writers who all have to meet and re-meet and explain and re-explain ad-nauseum until we’re all sick of the process and late for delivery of the documentation products.

When this documentation investment is made in the code, some remarkable things come out like: a project co-developed with Claude in Python took 10 interactive days to make. At the end, the Python was performing fine but a little on the noticeably slow side, so the LLM was told “do it again in Go” and 3 days later with very minimal prompting, the whole thing was re-implemented in Go, running 10x faster, and flawlessly performing the same functions which were developed in Python in 10 days - I believe precisely because a significant part of the Python project was: documentation of requirements, design specifications and automated tests.

The interesting thing, to me, is how much/little architectural level design matters depending on the complexity of the system you have built, and the longevity of its maintenance in the field.

I watch things get built with bad architectural compromises for what appear to be bad reasons all the time, and they rarely “come home to roost” until years later… then the question becomes: was the implemented design a success for having gotten to market quicker and lasted so long without serious problems, or a failure for having created a mess 5 years down the road that could have been addressed with a 5 day delay of launch for a refactoring? Or, should we instead spend 5 weeks attempting to predict the optimal architecture before we even start and maybe get a good solution or maybe still end up learning things we didn’t know during early development - and when we learn those things down the line from the initial architecture specification, when it it time to slaughter the sacred cow and re-arrange things?

Code is the God in the machine.

Then God has no soul.

Yes, code defines what happens, how it happens. But what defines what the code is intended to do? Where is the intelligent design? You can wire up a bunch of relays with intelligent design, simple electrical work, define gates, build the gates into memory registers and arithmetic processing stages, make a CPU - but… are you any closer to achieving the goal for having done all that work?

Are you better off for having a hands-on deep understanding of the machine from electrical first principles, or does the warehouse full of circuits and wires and the power it consumes outweigh that benefit?

If you use a modern processor do you need to have hands-on the assembly code? Do you need to deconstruct and understand every stage of the compilers and linkers and optimizers? In the 1990s I did, because those stages weren’t reliable enough, yet.

There’s nothing different about “deterministic code” built on layers and layers of tools today than there was about assembly code built on the processors before than there was about assemblies of modular circuits that form processors and memories and peripherals… it’s all parts of the system. And for critics of the “unpredictability” of LLM code generation, you might want to look into the mysteries of “garbage collected” languages.

If I eventually stop writing C or Rust or Go or Python or Javascript or any of the other hundreds of common choices of languages out there and instead learn to feed a LLM with instructions that generates the Rust that generates the Assembly that drives the CPU that manipulates the electron flows - that doesn’t change the intelligent design of: making a thing do what it is intended to do.

I think it was when we started organizing into walled cities surrounded by agricultural lands… that was really conditioning to a miserable way of life (for most, benefitting only a few) that carries through all the way to today.

In the early 1900s the Collier family made themselves a big pile of money and bought what later became Collier County, Florida. Pretty much all of it was privately owned by them, along with a collection of every type of Porsche ever made and a bunch of other “gee, what can I do with ALL this money” activities… Property taxes encouraged them to sell the land off and now what once was a private family “farm” about 100 years ago is now home to over 400,000 people.

At least we’re not burning dead dinosaurs (and plankton) to deliver dead trees.

Are you sure? Co-dependent symbiotic relationships evolve in nature all the time - starting at the macro scale with plants and animals.

I think the bot traffic is the open mesh.

It also comes into play for civil damages if the recording is published.

Interesting question: what if the call crosses from a two party area to a one party area?

If the call goes from Georgia (one party) to Florida (two party) can the Georgia caller legally record without the Floridian’s consent?

Can the Georgia caller then use the legally obtained recording in a Florida courtroom? In a Georgia courtroom? On national news? If both parties are Florida residents but one party drives into Georgia for the duration of the call?

that will certainly require

Nothing. Legally - all kinds of requirements. Companies and their employees following ALL the laws? Never happens with 100% certainty.

In the old terms: there’s an app for that…

Even when the default app recording is disabled there are plenty of audio recording applications which work quite well - including with transcription. Ever need a transcript of a meeting? Put the phone in your shirt pocket with a recording app active - it’s amazingly efficient.

smartphones have all call recording features disabled.

By default - I believe if you are determined enough, you can record the call, if nothing else with a mechanical device attached to the earpiece of your phone.

Free versions already do this. If you pay for enough tokens they can also do the real work and generate summaries better than your average human docu-drone.

Well, the old “web of links” still works, if people valued that enough to put the effort into it it could continue to thrive and grow…

Your DNS style distributed reputation system needs one fundamental foundational element to have a chance at providing any kind of value: reliable/secure author identity. PGP and signed documents have been available through standard formats for 30+ years, but almost nobody has adopted that kind of identity for mainstream publication and consumption. Until they do, reputation is going to be chaoticly fluid, unreliable and trivial to hijack/poison.