I did a little bit of research into the OpenJDK policies for generative AI after the ban I received yesterday from /r/java. I had assumed that code inside Oracle and specifically inside OpenJDK must be incorporating generative AI in 2026, since Oracle has been such a big proponent of AI.

To my surprise, however, the current OpenJDK contribution policy explicitly disallows code produced by LLMs. It still allows the use of generative AI for performing research and review. But the actual code must be written by humans.

Contributions in the OpenJDK Community must not include content generated, in part or in full, by large language models, diffusion models, or similar deep-learning systems. Content, in this context, includes but is not limited to source code, text, and images in OpenJDK Git repositories, GitHub pull requests, e-mail messages, wiki pages, and JBS issues.

Contributors in the OpenJDK Community may use generative AI tools privately to help comprehend, debug, and review OpenJDK code and other content, and to do research related to OpenJDK Projects, so long as they do not contribute content generated by such tools.

I suspect that this is mostly to do with Copyright - the fact that the courts have ruled that AI-generated works cannot be copyrighted; but more importantly that the question of whether code generated by an LLM might infringe copyright is not yet settled, so the risk to Oracle would be substantial. If Oracle started accepting contributions that included AI-written code, and courts later ruled that it infringed copyright, they would be a ripe target for lawsuits.

I suppose this shouldn’t have been a surprise to me. Maybe I’ve been living in a bit of a bubble, as, at my workplace, the use of AI coding agents is certainly encouraged, and borderline required. And for my side projects the increased productivity realized from the use of coding agents makes me feel foolish for NOT using them. In a way, this glimpse of a world where we put restraints on the use of AI is encouraging, as it provides a space to still practice the skills that we know and love.

The current development process that I have settled on in 2026 leans heavily on the use of AI. I even created a custom Swing-based IDE to complement this process. In this process I generally don’t modify any code myself. I just add annotations and comments to the parts of the code that I want the coding agent to change. This allows me to focus on higher level details like the architectural patterns, and let the coding agent do what it is good at: coding.

My current 2026 development process: write a specification with AI consultation, a coding agent implements it, I review the diffs and add comments to guide fixes (looping back to the agent), then I rigorously verify the result with manual tests, automated tests, and code-quality tools.

This process would appear to be completely incompatible with contributing to OpenJDK - and the rationale behind the OpenJDK restrictions makes some sense. For example, so if I care about “copyright” (I’m not sure that I do, but let’s say that I do), then maybe adding AI-assisted code into my open source projects that I’ve spent 25 years building up is not a good idea. And if I want to contribute to projects that care about this, then this development process just won’t work.

But the OpenJDK policy doesn’t say “you must return to the way you developed software in 2025” - it does give freedom to use these powerful new tools. Just not for the finished code. So, for example, I could develop a prototype for a feature request or bug fix in one branch using a coding agent, and then just use that as reference for a separate branch where I implement it myself. Largely following the strategy, but where each letter is typed by me, and where it isn’t a verbatim copy.

I could even take this approach a step further by getting the AI to convert the working prototype back into a higher level implementation plan - that I could use as reference, instead of the code itself.

My proposed development process: in a prototype branch I run the full 2026 process to produce a working prototype, then have the AI distill a high-level implementation plan from it; in a separate implementation branch I write the code by hand and verify it, producing a hand-written, copyright-clean contribution, with the prototype and plan used as references only and never copied verbatim.

I think I’ll experiment with this constraint to see what I can come up with.

Disclosure: The full content of this post was written by me without the help of AI, except for spelling and minor grammar corrections. The diagram SVGs, however, were generated with AI assistance.