eating our own dogshit
eating our own dogshit
Ah yes the typical workflow for LLM generated changes:
- LLM produces nonsense at the behest of employee A.
- Employee B leaves a bunch of edits and suggestions to hammer it into something that's sloppy but almost kind of makes sense. A soul-sucking error prone process that takes twice as long as just writing the dang code.
- Code submitted!
- Employee A gets promoted.
Also the fact that this isn't integrated with tests shows how rushed the implementation was. Not even LLM optimists should want code changes that don't compile or that break tests.
I just looked at the first PR out of curiosity, and wow...
this isn't integrated with tests
That's the part that surprised me the most. It failed the existing automation. Even after prompted to fix the failing tests, it proudly added a commit "fixing" it (it still didn't pass...something that copilot should really be able to check). Then the dev had to step in and say why the test was failing and how to fix the code to make it pass. With this much handholding all of this could have been done much faster and cleaner without any AI involvement at all.
The point is to get open source maintainers to further train their program because they already scraped all our code. I wonder if this will become a larger trend among corporate owned open source projects.
No real understanding of what it's doing, it's just guessing.
Are they talking about the LLMs or the people who think just chatting with the LLM will fix it? :)
E: from a comment about this on hackernews:
Funniest PRs are the ones that "resolves" test failures by removing/commenting out the test cases, or change the assertions.
Perfect, no notes. Ship
you all joke, but my mind is so expanded by stimulants that I, and only I, can see how this dogshit code will one day purchase all the car manufacturers and build murderbots
Look, im def on team Murderbot, but when
wethe AI's start building them I really hope Martha Wells gets some kickbacks at least.I love how Wells has given us both a great series of stories AND a jokey terminator analog to diffuse the mAnLy trope of building and/or fighting terminators.
just look at it. it is not enough that AI is boiling the planet, but with every iteration of copilot, all those automatic checks are reran! on the first mentioned PR, the checks have been running for 20 minutes when I'm reading it, and there's like a dozen of them!
other projects have to pay for processing time on github actions!!
this is insanity
Came here to post this, funnily enough.
We're poisoning people's air for this.
Microsoft claims that AI can replace human programmers. Why doesn't Microsoft just do so and let an AI "fix" the problems reported by AIs?
Not sure why they're even involving human employees in this problem. /s
Someone should write a script that estimates how much time has been spent re-fondling LLMPRs on Github.
An image of a Github-themed restaurant that serves poop burgers.
Is there a reason why that ai "evolution" thing don't work for code? In theory shouldn't it be decent at least
zbyte64 gave a great answer. I visualize it like this:
Writing software that does a thing correctly within well defined time and space constraints is nothing like climbing a smooth gradient to a cozy global maximum.
On a good day, it's like hopping on a pogo stick around a spiky, discontinuous, weirdly-connected n-dimensional manifold filled with landmines (for large values of n).
The landmines don't just explode. Sometimes they have unpredictable comedic effects, such as ruining your weekend two months from now.
Evolution is simply the wrong tool for the job.
To elaborate on the other answers about alphaevolve. the LLM portion is only a component of alphaevolve, the LLM is the generator of random mutations in the evolutionary process. The LLM promoters like to emphasize the involvement of LLMs, but separate from the evolutionary algorithm guiding the process through repeated generations, LLM is as likely to write good code as a dose of radiation is likely to spontaneously mutate you to be able to breathe underwater.
And the evolutionary aspect requires a lot of compute, they don't specify in their whitepaper how big their population is or the number of generations, but it might be hundreds or thousands of attempted solutions repeated for dozens or hundreds of generations, so that means you are running the LLM for thousands or tens of thousands of attempted solutions and testing that code against the evaluation function everytime to generate one piece of optimized code. This isn't an approach that is remotely affordable or even feasible for software development, even if you reworked your entire software development process to something like test driven development on steroids in order to try to write enough tests to use them in the evaluation function (and you would probably get stuck on this step, because it outright isn't possible for most practical real world software).
Alphaevolve's successes are all very specific very well defined and constrained problems, finding specific algorithms as opposed to general software development
Imagine if it was trying to build a feature for a client who needs to look at a demo every time.
Throwing rocks into an increasing pile and after each throw burning offerings to evaluate how much closer we are getting to having a cathedral.
Possibly the worst way of building a cathedral, except it doesn't really qualify as "building a cathedral". Some workmen may take the pile of rocks and build an actual cathedral, but that doesn't mean that the step of throwing rocks was necessary or desirable.
Talking about Alpha Evolve https://deepmind.google/discover/blog/alphaevolve-a-gemini-powered-coding-agent-for-designing-advanced-algorithms/ ?
First, Microsoft isn't using this yet but even if they were it doesn't work in this context. What Google did was they wrote a fitness function to tune the Generative process. Why not have some rubric that scores the code as our fitness function? Because the function needs to be continuous for this to work well, no sudden cliffs. But also they didn't address how this would work in a multi-objective space, this technique doesn't let the LLM make reasonable trade offs between complexity and speed.
I forgot about alpha evolve, with all the flashy titles about I figured it wasn't a big deal, I was more talking about the low level stuff I guess like "ai learns to play mario/walk" but I imagine it follows the same logic the other comment talks about
For LLMs specifically? Code is not text, aside from the most clinical, dictionary definition of "text".
But even then, it also fails at writing coherent short or longform, so even if code was "just text" it'd fail equally badly.
If you're referring to genetic algorithms, those work by giving the computer some type of target to gun for that's easy to measure and then letting the computer go loose with randomly changing bits from the original object. I guess in your mind, that'd be randomly evolving the codebase and then submitting the best version.
There's a lot of problems with the idea of genetic codebase that I'm sure you can figure out on your own, but I'll give you one for free: "better code" is a very hard thing for computers to measure.