ES version is available. Content is displayed in original English for accuracy.
Advertisement
Advertisement
⚡ Community Insights
Discussion Sentiment
63% Positive
Analyzed from 5699 words in the discussion.
Trending Topics
#code#oracle#don#software#more#generated#java#need#llm#legal
Discussion (188 Comments)Read Original on HackerNews
If that's a reference to Thaler v. Perlmutter, the only thing that's been established is that an LLM can't be considered an author under the Copyright Act, only a human being can. It says nothing about the consequences of a human claiming authorship of LLM-generated code, which would be relevant here.
Thaler v. Perlmutter stands for a much narrower proposition and at any rate is not binding nationally, SCOTUS having denied certiorari.
They are trained on a narrow set of data and don't really understand the real world.
If you let them run wild with no supervision they'll turn your company into slop.
Someone needs to be there to reign them in, asking the all-important questions like "is suing all of our customers and making them angry REALLY the best option?" (to which they will reply, "You're right to push back on this").
This is typically the role of the CEO, however, as we know, most CEOs of large successful companies are too busy to actually do that. They're mostly training Brazilian Jiu Jitsu, shitposting on their own social media platform, trying to manipulate international politics, or helping run their family nonprofit.
This is why I believe that legal departments need to be demoted. The legal department should not report to the CEO, they should report to a new role that is above both PR and legal. And that person's job should be to force legal and public relations (which we know are natural enemies) to work together. Every press release goes through legal now, and it's only logical that ever legal action should go through public relations review as well.
The fact that public relations at most large companies has atrophied from disuse in our public-equity-owned unicorporate cooperation-over-competition chaebol/zaibatsu/conglomerate world is a problem for another day.
https://www.theregister.com/ai-and-ml/2026/08/03/as-larry-el...
The register article is about this post:
https://openjdk.org/legal/ai
It is 'OpenJDK Interim Policy on Generative AI' and their lawyers are writing the final version, according to this page.
It sounds like a sensible action, given past scars around Java and copyright, plus this is from a big old corp.
That said I personally don't expect that final proposal will end up any better.
How many of these were self-inflicted?
Especially for a project that runs to many major businesses, this could pose a massive risk.
Seems like a better way to do this than ban all AI generated code, but it's probably a matter where they're far more concerned about their own inconvenience than someone else's.
I’m sure someone could still just prompt their way through but it’s a decent soft gate IMO.
Humans still need to review code for taste, making sure AI is writing sensible, well organized output. That's a core "AI skill" for now, at least until it gets better...
I think for Java specifically, it's also very much: which prompts make sense to write. Java has had a storied history of features that made future development hard. That's resulted in a culture where they like to think quite deeply about how to add a feature BEFORE they sanction any sort of programming.
Google “Oracle org chart meme” and look at image results, only it’s not a meme.
The same problems that bedevil AI-written PRs here bedevil AI-written PRs at my place of work.
I'm sure it'll get better eventually, maybe, but something something Pareto principle.
>I'm sure it'll get better eventually, maybe
Why would it get better?
Selling it is one thing. Having to use it one's self is quite another.
Do as Larry does --- not as Larry claims to do.
I would short his stock but it has already lost half it's value over the past year. And his credit rating is one notch above junk.
AI is going to make fools out of a lot of billionaires like Larry.
Even the biggest institutional AI investors have to ban their contributors from spamming them with AI generated slop.
https://en.wikipedia.org/wiki/OpenJDK
code is a liability, and they likely have more to lose than gain by allowing AI contribution.
java never had that phase. If anything it had a full binary class (not even source, e.g. long and int are not compatible on binary level) compatibility. Generally you can take an application from '98 and run it nowadays.
It's only recent changes (jigsaw in java9 mostly) that were made them to drop some of that part.
It's shocking given Oracle's AI spending spree over the last couple of years.
If you know how to work with it it's great, but if you use it indiscriminately it does more harm than good.
The biggest use of Java currently is Android, and Google is on a path to migrate to Fuchsia eventually.
The second biggest use is Apache Spark/Kafka, but with LLMs now, you can pretty much re implement all of that functionality in pure C.
They just want a legal angle, since this is how they make most of their money.
The "limited ROI on AI investment" articles will continue to percolate slowly into the brains of the LinkedIn hive-mind until we hit a tipping point, and then we'll finally shut up about how a handy dev tool with some decent use-cases is the dawning of the singularity that will replace all white collar labor and get back to actually building business value.
I manage several teams of developers who use them every day professionally and use them for personal projects privately. Just last week, at the prompting of said devs, we had a working agreement conversation about curtailing the use of AI in our codebases because of rapid erosion of our teams' ability to operate, update and maintain codebases that had started to spill over with slop.
We have had multiple incidents of credential leakage, integration tests wiping live databases, comically broken code that passed vibe-written tests, documentation and code comments that were hallucinated and/or fake, and most importantly developers saying "we no longer know how this code works but it's massively bloated and unreadable and we can't tell you with a straight face that we can maintain it or fix it if it breaks." We have seen a flood of vibe-PRs from engineering adjacent teams that suddenly think they can code shipping prototypes into production that do not work do not scale and cannot be maintained. I am personally writing the tickets to decom one of those today. Which is great, I love telling business "the progress that was reported to you was a lie, this shit never worked, don't shoot the messenger but also don't let this happen again."
I embrace GenAI as a productivity tool for people who know what they are doing. It's a +10-15% velocity boost. That's great! That's a big deal, devs are expensive, and that might push some kinds of business model over the threshold into viability. That's great!
It is not, however, transforming the profession as I know it, it is rather making my job harder and less pleasant and it is making my leadership dumber by the second.
Absolutely no comment on vibe business decisions / vibe OKRs / slop reports or the host of other garbage that has started to creep into professional life. I have had to have some very uncomfortably direct conversations with peers in leadership about using complete bullshit to make decisions, and it is very, very frustrating. Do you know how hard it is to convince someone that metrics their bot hallucinated don't exist and would be meaningless if they did? You can't convince someone of something they are incentivized to not understand. It's been very eye-opening in terms of who I can trust to actually make sense when it matters. I'm grateful for the clarity.
Meanwhile we are rapidly losing brainshare from the top because our principal/staff engineers are pissed off and have the bankroll to just leave. We aren't hiring and training younger engineers to keep the talent pipeline moving. Which boy howdy is THAT going to cost us unbelievable sums of dollars to fix in the medium-term future.
I am in the uncomfortable role of trying to make the best of this but it would be a metric ton easier if the narrative from the c-suite aligned with reality in any meaningful way.
</rant>
Linux's LLM policy allows AI-generated code because the project was never vulnerable to this DoS attack in the first place. They kept the social defense they've had for decades.
The killzone here is Github culture, where people decided it was normal to accept code from anonymous randoms with anime avatars. They're doomed.
It would be interesting to see how this effects the copyleft Licences with contributors are using AI for the PRs
Which recent verdict?
> It would be interesting to see how this effects the copyleft Licences with contributors are using AI for the PRs
I know Linux and GCC have been diligent about tagging and tracking LLM based contributions. In the worst case they can chuck it all out and handwrite it back.
Refusing to use AI honestly seems more like vanity to me. Like "no machine could ever do what I do".
That said I would not necessarily accuse people who don't want to use AI of vanity - there are good reasons not to want to use it - but if someone else did it I'd find it easier to understand.
One also assumes the people maintaining OpenJDK have had their workload increase to an unmanageable level, like a lot of other free software projects and one thing I'm sure everyone can agree on is that Oracle certainly won't want to pay anyone more or hire more people to deal with that.
A lot of people (including the Register[0]) are pointing out that Oracle leadership are gung-ho about using LLMs for everything, and this seems to go against that. It makes sense to question this from a journalistic angle -- the executives are obviously full of shit and people would do well to remember that the next time one of them opens their mouth. But pointing at the apparent contradiction -- different rules for internal projects vs. open ones -- doesn't seem particularly meaningful on its own:
I don't think the CEO/CTO raving about LLMs should be taken as firm statements about how they actually operate internally. I'm surprised that this does not seem to be the default case. Among other things, Oracle stands to profit from greater adoption of LLM tools.
It would be unrealistic/unreasonable to expect their employees/contractors working on internal projects to be held to the same standard/guidelines/rules as developers contributing to a free software project. This applies either way, whichever side (internal/open) has the worse deal.
I don't know what the rules are for their internal teams. As far as I know, I'm not alone in that. Oracle also don't need to post anything publicly to change those rules.
[0] https://www.theregister.com/ai-and-ml/2026/08/03/as-larry-el...
sips tea
> If I use a generative AI tool to create 100 lines of code, and then edit ten of those lines myself, may I contribute the result?
> No. Your contribution would still include, in part, AI-generated code.
I totally agree with you on this! The engineer is still actively engaging while getting the performance gains of not having to type out functions. The Engineer is still in charge vs agentic "engineering" a model + harness can spit out whatever and the engineer is left to review tons and tons of code
There is also the approach of Microsoft putting AI all over the place on .NET, and CoPilot driven development all over the place.
What if someone generates code with AI and then goes into the IDE and then bathes it, dresses it (including adding comments) etc, in a way a human would? What then? No, here I am not exploring a way to fool the code DNA checking, but rather trying to find out what the real problem is with the AI generated code? (Other than license issues, too many PRs etc)
Too many PRs wouldn't be a problem if they were easily digestible: But they often include these giant refactors with confusing changes that aren't elaborated.
The real underlying problem is with authors who do not understand the code they submit. If you cannot defend the PR, you shouldn't be submitting it.
Will you submit an AI-generated pull request to OpenJDK? No? Voilà, you have successfully self-enforced the OpenJDK policy.
Or do you go to the trouble of finding an interesting issue to work on, get your agent to code it up, manually polish it to make it less AI-looking in case there are doubts, and then submit it? Yes? No. Why would you? To prove some kind of point, to yourself, that you can never disclose publicly? Most people have better things to do. Voilà, the policy is, again, self-enforced. Enjoy your day at the beach instead of trying to trick a project that is politely asking you not to trick it!
And if you catch somebody submitting code they can't explain, you don't know them anymore.
It's really simple. Open source has always had a social layer. Github culture tries to eliminate it, and that's the source of this vulnerability.
I accept @jerf's explanation is the right one but this is an absolutely almighty signal that AI-first developers should heed. And someone should ask Altman about it on the record.
The people you refer to are delusional idiots and should be treated as such.
But people at Oracle below the C suite don't even fart in public without lawyers signing off.
This is Oracle telling quite a lot of customers and partners of one of their most significant products that it doesn't trust AI code to be safe. Oracle, the company that is more exposed to the bubble bursting than basically anyone else apart from Coreweave.
This message could have been a lot shorter, could have said they were pausing accepting AI submissions until the intellectual property situation was clarified, but no — they said AI code can be unsafe and insecure and it's too risky to accept it. So a good question (given that Oracle are fucked if OpenAI even stumbles) is why?
That is a heck of a message to send, and it is visible enough. That is why I think developers (by which I mean individuals and their companies) whose focus is AI-generated code, which is almost everyone in public, should pay a bit of attention.
Now slowly, the Empire strikes back - not just Oracle, but more and more resist the tyranny of AI skynet slop.
I am upset that these corporations drove up the RAM prices still. They need to compensate the rest of mankind for this - after all the chip market is a de-facto monopoly. They should all be sued into nothingness, then new laws must enforce healthy and fair competition, without unfair players driving up the prices willy-nilly style. Absolute AI mafia here.
https://openjdk.org/legal/ai
That Oracle's policies over its internal code base are different is irrelevant.
Also, Oracle knows that it will be stronger with strong IP laws. Other companies will realize that fact soon.
I'm shocked.
I'm not only shocked: I also see there a delicious irony in the countless of LLMish sloppy-pasta code that's now running and going to be run on man-made JVMs.
Don’t worry, I think most LLMs, when starting a greenfield codebase, don’t reach for Java, so it may be a smaller amount of code affected than you feared.
Prompt: “Top language pick for an Android app? Respond with only the language.”
Responses (admittedly via the aichat CLI, not an agent harness; and temp=0):
Kimi K3: Kotlin
GPT 5.6 Sol: Kotlin
Claude Fable 5: Kotlin
DeepSeek v4 Flash 0731: Kotlin
Are there any other “inherently” heavily JVM-biased domains?
I think even in Minecraft game mods Kotlin is possible nowadays…
Probably won’t happen but clearly Oracle sees a potential for legal issues with LLM output.
And if I run out of tokens, well, that's OK too. K3 running on my own box will finish the job. I'll just have to wait another week, that's all.
Regardless, your timeframe on Oracle's death seems way too soon.
As we move forward it will be easier than ever to just maintain and keep your fork of software with the changes you want or need. No more approval, bureaucracy, or arguing. Just tell the AI agent want you want changed and you have it.
This will be used for huge things too. Like maybe you want a specific fork of Java that only supports for each iterators, goodby linters, hello compile time error.
Software as a list of requirements and that's it. The local LLM appliance everybody has taking in a document specifying hardware, interfaces, and requirements and spitting out software changeable locally via conversation with its users.
In the same way you have a cookbook with recipes to make dinner instead of ordering out.
For that, you'd want the list of requirements and hardware documentation to be written in a precise, formal language. That's no different than writing them in a programming language (though a declarative one, instead of the more common imperative ones).
I've in the past (way before LLMs existed) thought about automatically generating device drivers from hardware documentation. But besides the need for very precise documentation, hardware never works exactly as documented; a human-written device driver can avoid problematic areas (perhaps even by accident), while a computer-written device driver would end up exploiting every corner case of the documentation.
I don't imagine this is practical or desirable for all situations. Good software is built from being battle tested by many users in many environments. Even with the advancements in AI tools, I don't imagine they'll become omnipotent anytime soon.
> No more approval, bureaucracy, or arguing
For software that can kill people or substantively affect someone’s life in a negative way, the bureaucracy is there for good reason. I don't think anyone should want someone at Phillips to vibe code the control software for an X-Ray machine or an employee at CrowdStrike vibe coding the next update before pushing it out to millions of machines.
We are forced to endure low-quality software because there is little or no accountability. I can only imagine what you propose would make an already poor situation worse.
Then you'll have the same problem everyone who forks a piece of software ends up having, sooner or later: as the original evolves, keeping your fork up to date with the upstream changes becomes harder and harder. The bigger and more invasive the changes are, the harder synchronizing with newer releases become.
Can't picture a functioning world where every piece of software is custom and requires factorial amount of AI comparisons and reviews to patch the API to communicate. In fact, it's impossible! There's not enough compute to handle a factorial explosion.
I really doubt SaaS going anywhere.
The cherry on top is that OpenAI and Anthropic brainwashed your coworkers and your company's C-suite into uploading the entirety of the "proprietary" codebase onto their servers thousands of times per day over the last three years.
Even SaaS isn't safe. I don't even have to describe your product to my system, I just have to give it a harness with access to the interface and have it replicate it locally. Frankly you can probably already prompt for that.
The only thing holding this future back right now are pricing problems and code generation quality. Both of those barriers are constantly being knocked down. We might never arrive at that future, but it's definitely a higher probability than solving AGI's scaling issues, and would arrive much sooner for technical users.
Because SQLite has 10k requirements that wouldn't even cross your mind to write down, but 80% of which are useful to you.
This isn't anything new or particularly interesting. It's the entire basis upon which ILP demonstrated generality. A metatheory to synthesize 10 trillion rules isn't even scratching the surface of what you can reasonably do. The key was finding out the tractable semantics for actually computing it in reasonable amount of time, which right now is looking decidedly like informal semantics was the answer the whole time.
https://www.youtube.com/watch?v=V_qzqY1bb7I your sufficiently advanced code generator may generate you a high quality database system for some measure of quality, but it will not have SQLite's reliability over the extremely long tail of edge cases proven through its testing and use in real life
That's before we get into the entire non-linearity of agentic systems introducing massive decidability problems on this in the first place. A little bit of epistemic humility please.