Comment by KingOfCoders | Hacker News Reader

Comment by KingOfCoders | Hacker News Reader

Parent Full thread

The end of programming will be no programming at all. First AIs will do the things that are necessary without someone telling them. If there are still companies, e.g. this means sending emails to customers (who have AIs that are reading their emails and acting on them ;-) to sell more things, create APIs or websites on their own, hire other people (AIs) to do things they can't do (regulation, other country, etc.).

For the mid future, it's like Star Trek: "Computer give me the customers that perform best" - from a data lake, no data warehouse, no CRM code, no web frontend. No programmers, just users.

For the near future, developers will become managers. Instead of hiring and managing people, they will select and manage different AIs for different tasks. See what those are doing, give them feedback (just like a manager would to developers), change the prompt (like a manager would clarify a task), give them data, grow them (again just like a people manager today).

Not really. Developers become TESTERS. Except developers don't want to be testers, and will do it badly.

Testing is hard. No, sorry, I meant to write that COMPETENT testing is hard. Any idiot can do shallow testing and say he tested, and many do. That's not the same thing as doing a professional job of it.

But, the fact is, AI can't be a software developer, because a software developer is capable of being accountable. AI is a machine. Machines cannot be accountable. You can't sue them. You can't jail them. You can't reform them. A machine cannot be a citizen.

A programmer is someone who mediates the gateway between the world of machines and the world of people. This is because machines behave in very particular ways. Just as you should not represent yourself in a court of law, no one who doesn't understand machines should attempt to create a professional grade products with them... Or if they do, expect it to be poor quality.

This is the truth. Everyone wants AI to write their tests, but that’s backwards. AI will write the code and programmers will write the tests. The tests are the real business logic - binary assertions of how a system should or should not behave. The internals of how that happens are inconsequential.

Inconsequential until you start caring performance, scaling, reliability, interdependence with other systems, maintainability, or any other things that tests don’t assert.

You can test performance, and you can monitor reliability. Scale and interdependence are spec requirements that are this theoretical AI's job. Maintainability is irrelevant to everyone here except the theoretical AI, as the AI does the maintaining.

This sounds a lot like some kind of government procurement process, which don't have a reputation for producing particularly good IT systems.

I've used ChatGPT to write my tests. It's pretty effective at getting the first 5-6 use cases written out, but in a style that isn't correct. Copy/paste a code module, ask it to write the tests.

Then, in the same context, you correct it by providing it with more information about how you like to structure the tests. It starts to understand the "style".

Then, you start to provide the context with testing concerns. By the end of it, the AI context is pretty good (80-90'ish%).

It's nice, as a developer, to be able to say: "test that asset is deleted when DELETE /asset/:id", and the AI converts that into a proper test case, using familiar variables / test structure / corrects the abbreviated text into a proper test title, etc..

I look forward to writing specifications ("property tests without RNG") in a theorem prover language and some AI writing the program against my specification.

Why not simply use AI to implement monitoring and evaluation so incredibly fine grained any human would go insane if they had to do it?

Strange argument, it's not common to sue and jail developers, and our average software isn't particularly good quality. Companies will use whatever works for less money, as they always did.

I also see very limited accountability beyond firing.

There was some in #Dieselgate (Developers going to jail for their code).

James Robert Liang got jail.

It is quite strange, since the defeat device part was actually quite insignificant to work around a vehicle reset during testing and skip the warm up timer.

The real scandal is that emission treatment in diesels did not work outside of synthetic kinda steady state tests. And that applied to way more manufacturers than VW.

A developer is accountable in the way of being fired. Not accountable in the way of paying for the loss.

In this way an AI is accountable too, I can switch from Claude to Mistral.

Testing is what LLM coding models are born for..

- We want this

- We Had this

- This happened

- Already at work

Code is much harder to maintain than to write. You'll save 6 hours writing it, only to spend many more maintaining it.

Of course, eventually the AI will be smart enough to do maintenance, but at that point it'll basically take the job of anyone who does their job entirely on a computer.

I do think, as soon as you stop caring about the code, this goes away.

Just like with garbage collection, "we need to have proper malloc and free". The moment we gave this to a JVM, the problem went away.

It means giving up control and don't care about the internals (0.1% of developers today care about the detailed internals and performance of GCs.)

Except that the JVM didn't take over all of programming (as some predicted back in the late 90s/early 2000s). C, C++ and Rust are popular programming languages today. Probably because Java isn't a good systems language, or the ideal for all embedded tasks. And that tons of widely used code is written in C/C++.

Mostly because Java did the mistake to gate AOT behind commercial licenses, thus C and C++ kept being relevant for many tasks requiring AOT workloads.

Had Java shipped a AOT compiler in the box for free, Go would not happened, nor many of the workloads that Go has been taking away from C and C++ on the distributed computing space and devops.

C and C++ would have their use cases reduced to kernel programming, embedded, games and like else.

Let’s assume then that there is no GC for parts of the code. It’ll be constantly regenerated

> It’ll be constantly regenerated

What do you mean by this?

probably a misunderstanding of what the GC is and does.

The GC works on data, not code.

I think the generous meaning would be an experience like Rust (handles memory allocations/deallocations, doesn't mess up unless you really mess up) except that it doesn't complain all the time when you're doing "ok things" and maybe even makes it impossible in practice to mess up.

It could even dynamically decide between using a GC for a given program or not, depending on what makes more sense (thus "constantly generating it").

The problem didn't go away.

It got better, but memory leaks are a thing in Java too.

Besides the fact that they're actually fairly good at maintaining code/building tests, they don't get bored maintaining code like people do

I'd say that's a far easier task than development (from the POV of a machine) because you already have a known "standard" to aim for, and there's much less need for 'lateral thinking'. Anytime you have a delta you can initiate responses (even incredibly minor ones)

And you could send a proverbial army of them at any small regression or complaint for almost no cost.

Programmers won't turn into managers of technology because programmers are already the managers. Writing code in symbolic formalisms is how we control reality and impose our will upon it. The people you call managers have very little power in this process and focus primarily on controlling the human social processes that enable programmers to do what they do. There's no social process interacting with machines so there's no managerial position you can graduate into.

Sure, in the same way that we'll all stop driving cass and have self driving cars any day now.

What you just described is more of a tech lead than a "manager", and that's really the point. Reality that's not encoded in pure language is a fundamental limit of LLMs; they're probably never going to correctly diagnose a hardware bug based on misbehaving software, for example, because that's a world where everything that they are (ingestion material, available documentation) and reality conflict and an LLM has very little ability to detect and overcome such a problem.

Those "reality vs the text" impedance mismatches mean that LLMs are probably never going to escape human oversight. Which means we'll all probably have as many low quality (occasionally brilliant) fresh grads as we like, but taking the jobs of experts seems unlikely.

The end of programming looks like lots of work for programmers.

We have self driving cars.

So why are people still driving cars? Why are there still Uber, delivery and truck drivers? 99.99% of vehicles are driven by humans.

It's like saying we have flying cars. Sure, working prototypes have existed for some time now. There were (are?) companies making them. But it makes no real world difference.

In the context of "no more programming", it makes no difference if some fancy AI model can in theory replace programmers, if they don't actually end up doing that on any real scale.

> So why are people still driving cars?

Because it costs Waymo about US$200,000 per car, not including the operating and maintenance staff. It will get cheaper.

You do realize the first ever decent AI has appeared less than a year ago? It’s available to anyone today for $20/mo, and it will get better and better every year. What we have now was considered pure science fiction just five years ago, a hypothetical technology - decades away at best.

Why are people still driving cars? Because the autonomous driving technology wasn’t good until very recently. It has improved a lot in just the last few years, and you can already see self driving cars operating commercially in several cities. Again, it will get better every year, and as it gets better it will spread everywhere.

It’s true that flying cars exist but haven’t become popular or widespread. I’m not entirely sure why. But it is much easier to ask ChatGPT to write some code than to actually try out a flying car.

Because they are poor, also because of regulations crippling fsd (for better or worse).

What are the regulations preventing FSD?

E.g. keep your hands on a wheel, be present and in a driver's seat. Anything unlike getting a cab.

stuff like needing to take responsibility and accountability, if you are also taking control. Ewww, what a horrible concept that stifles innovation!

Coding won't die, it will simply shift from the language of computers to a weird half-natural half-computing dialect.

I remember hearing that exact same thing about SQL. Managers wouldn't need analysts anymore because SQL is a human like language that anyone can use. I've been through at least a half dozen different iterations of this, and each one makes it slightly true while also creating new jobs. Each generation of manager gets a bit more savvy and able to do things on their own, but the amount of work down in the trenches keeps on increasing. Perhaps LLMs will be different; each generation of these tools promises to be the one that lets management cut programmers out of the loop. Perhaps someday one of them will be correct but history so far hasn't worked out that way.

That is a bit silly as SQL is a language itself, it's not a thing that can write in (many) other languages while still understanding human natural language.

LLMs are that 'blurry jpg of the internet' but now also more finetunable/specialized.

I'm going to look at siccing some LLMs on old Jenkins errors today, ideally it will give me more time to spend on building things (and hopefully less fires later).

I obviously don't expect it to magically fix everything but I have a good idea of what they're capable of, what they need help with, and what their pitfalls are

I can now have some scripts and some "agents" scan through 250GB of logfiles and do various sanity test things and either report back or make a branch and try to fix it, before i even need to look at it. It costs almost nothing and if it finishes early I can have it "go do the same thing but in rolling 3 month windows to see wtf happened when"

FWIW I think LLMs are more powerful for the language side of things. I get a lot of the programming improvement from python/metaprogramming/etc - but the combination is like having a group of interns you can make do a bunch of tedious/shit work that nobody wants to do.

I would love it if we got the ship's computer. That doesn't seem to be anywhere on the horizon.

Until recently there was a button on my phone I could press to get immediate directions somewhere, to start a timer, any number of other things etc. A few months ago they updated the button, now it just searches Google.

I don't think rational interfaces of the sort you described will win out. Windows peaked at 7, which was an all but perfect desktop operating system, and they deliberately wrecked it.

The companies who've invested in this technology and control the hardware don't work by solving problems and queries straightforwardly. Rather they are very good at getting in between you and the solution/answer. Even on a B2B level - don't get me started on enterprise CRMs.

I also don't think it would make any sense for me to browse images and fiddle with prompts all day trying to make something happen programmatically, maybe, instead of just writing the code that will surely make it happen.

Copilot and chat gpt the other hand are amazing assets for now.

I think it's fun to consider how the capitalist mentality of "always be growing" has influenced the software we use. There is some software we've used all our lives that has hardly changed, it is dependable, and maybe we paid for it once, long ago. Then there is software that is constantly changing, and in some cases, it feels like too many even if it isn't, getting worse as a result. Windows actively pushes changes on users driven by this mentality, now we have a Copilot button, to replace the Cortana button I'd previously disabled. What will replace the Copilot button when they've decided too many customers have disabled it?

This is exactly my point of view, my only difference is that developers will turn into technical architects, a bit like nowadays for offshored devs, but it will be AI instead.

Reply on news.ycombinator.com