AI Policy
AI tooling is increasingly part of the software development landscape, Buddies of Budgie being no exception. This document outlines our expectations for transparency, accountability, and quality when/if AI is involved in contributions.
Budgie Desktop is used by people around the world as their daily computing environment. Every change has the potential to affect the experience of countless users. We take that responsibility seriously, and contributors (whether using AI tools or not) must do the same.
We take great pride in our work. Writing software is pragmatic by nature. It has to work, be maintainable, and be easy to reason about (at least, as easy as one can reason about an entire desktop environment). But we also treat writing code as a craft. We would rather move deliberately than move fast and break things. That care and intentionality is something we want to preserve in every contribution.
Our Stance
Buddies of Budgie follows a human-centric development model. It is our position that only humans can be authors and ultimately be held accountable. People develop for and deliver the Budgie Desktop experience to other people, whereas "AI" / LLMs are merely tools used to facilitate our objectives.
We recognize that AI tools like Claude, Gemini, Copilot, opencode, and others can be valuable. They can help explore ideas, work with the author to draft or explore technical implementations, accelerate development, and improve the clarity of how we communicate, whether in blog posts, issues, or the changes described in pull requests.
This policy does not endorse any particular model or provider. Our policy intends to draw a clear line between two distinct categories of the Buddies of Budgie software projects.
Budgie 11
This section / category applies to any codebase built with the intent to be used for Budgie 11 and beyond. Any codebase built with Budgie 11 in mind that also serves Budgie 10 is also in this category.
A high-level summary of our policy section for this category: Use of AI / LLMs for code generation is forbidden and will be wholesale rejected. Any use of AI / LLMs for alternative use cases, such as for research purposes, is not endorsed by the project.
Throughout our development of Budgie 10.10.x, particularly after the release of Budgie 10.10, we have leveraged large language models (LLMs) in several areas: guided feature development (human as the software architect), improvements to code quality targeting long-term maintainability, debugging, and performance analysis. Therefore, we are the first to understand what value these tools can bring when used responsibly.
However, Budgie 11 represents a ground-up rewrite and re-architecture of Budgie Desktop in Qt, C++, and Rust. This not only provides the team the opportunity to properly learn the best practices for the tools and languages involved in its development, but also the opportunity to make mistakes (which is equally valuable in building a corpus of knowledge on how to iterate on Budgie 11).
By using LLMs, we would be:
- Potentially misguiding ourselves by taking what LLMs present at face value, when those models may be trained on outdated knowledge / practices (whereas at least with Budgie 10, we have a decade of experience with its codebase and can more easily identify bad practices)
- Taking shortcuts in its implementation but not in our learning, creating a body of work that may not be thoroughly understood
- Taking on licensing risk in a fresh codebase
Therefore, it is the policy of the Buddies of Budgie team that no components associated with Budgie 11 (including budgie-desktop-services, which is used for both Budgie 10.10.x and Budgie 11) shall include any code generated by "AI" / large-language models.
No codebase within this category has included code generated by an AI / LLM as of the updating of this policy on October 17th, 2026, and none will going forward. Budgie 11 should be considered "AI-free", at least when it comes to first-party codebases.
While we cannot control how one uses these tools beyond code generation, we will not encourage using them for research purposes either. Rather, it would be preferable to build out a comprehensive list of suggested readings and authoritative sources of documentation that can / should be used for reference instead, as well as leveraging or building out tooling ourselves to facilitate various use cases (such as performance analysis, isolated development environments, etc).
We do not impose, nor do we wish to impose, our requirement for "AI-free" code on any software projects we leverage. We understand and respect that other developers may make different choices or, like us, be conflicted on the subject. As such, given the prolific nature of AI tooling, it is certain that Budgie 11 already uses, or will use, software (e.g. toolkits or libraries) built with such tooling. Neither the organization nor Budgie 11 should be viewed as "anti-AI". It is simply that for our specific desired objectives with Budgie 11 and the way we wish to develop it, we have decided to draw a clearer line in the sand on its use (or rather lack thereof).
As we cannot predict the future and how these types of tools will evolve, we feel the need to add the disclaimer that while this restriction is not likely to be revisited, we are willing to re-evaluate it if and when, at minimum, all of the defined criteria are fulfilled:
- Budgie 11 has seen its first stable release
- Copyright law (or cases influencing it) in all jurisdictions of the members of the "Best Buds" clearly establishes that code generated by LLMs may be correctly licensed under the project's intended license(s)
- Such tooling or models can be trained and implemented in an ethical manner that guarantees the copyrights and licenses of all involved parties are respected and satisfied, preferably in a local-first implementation
Non-"Budgie 11"
This section / category applies to the following. Unless otherwise communicated, anything not listed below should be considered under the scope of "Budgie 11":
- Any codebase or project designed with the intent to be used strictly for Budgie 10 (budgie-backgrounds, budgie-desktop, budgie-control-center, budgie-desktop-view 10.10.x, budgie-session)
- Our documentation center
- Our website
A high-level summary of our policy section for this category: Use of AI / LLMs for code generation is permitted, so long as it:
- Is thoroughly validated and tested before submission per our Testing Requirements
- Is appropriately attributed per our Attribution guidelines
- Involves a human in the loop and is audited. Simply saying "keep me in the loop" does not count. You must have an understanding of the proposed fix, collaborate on architectural decisions (or make them fully yourself), and not simply leave critical decisions up to the model
- Would not otherwise be viewed as "slop" by the respective reviewers (subject to change or vary based on the reviewer or at review time)
- Meets our standards for code quality, practices, and balanced documentation
In this specific category, contributors are generally free to make their own informed choices about which tools they use; however, end-to-end agentic workflows are soundly rejected, as they would violate our human-centric development model and "human-in-the-loop" requirement.
A codebase such as the documentation center or website may be subject to being moved to the Budgie 11 category, should they be fully expunged of any generated code by an LLM. In practice, this would mean a full black-box rewrite.
Code Contributions
Testing Requirements
All contributions must be tested before submission. When AI tools are involved, this is especially important as AI-generated code can be subtly wrong in ways that look correct at first glance.
- Non-trivial AI-assisted code must be built, installed, and tested by the contributor
- Substantial changes (refactors, new features, behavioral changes) require rigorous, thorough testing
- The contributor must verify the changes work as intended in a running Budgie Desktop session where applicable
"Trivial" is intentionally loosely defined. Typo fixes, documentation corrections, and comment updates are considered trivial. If you're unsure whether your change qualifies, err on the side of testing it. When in doubt, build and install.
Attribution
When AI tools assisted with code changes (writing, modifying, or generating code), add an Assisted-by trailer to the commit message with the tool and model identifier. This is in addition to the requirements outlined in our Contributing documentation:
feat(panel): add workspace indicator tooltip
Implement hover tooltips showing workspace names in the workspace
indicator applet.
Assisted-by: Claude:claude-opus-5-5 (1M)
Signed-off-by: Your Name <your.email@example.com>
Format
Assisted-by: <Tool>:<model-id>
Examples
| Tool | Trailer |
|---|---|
| Claude | Assisted-by: Claude:claude-opus-5-5 (1M) |
| Gemini | Assisted-by: Gemini:gemini-2.5-pro |
| GitHub Copilot | Assisted-by: Copilot:gpt-4o |
| ChatGPT | Assisted-by: ChatGPT:gpt-4o |
When Attribution Is Required
- AI wrote or generated code that ended up in the commit
- AI substantially modified or refactored existing code
- AI generated an implementation that the contributor then adapted
When Attribution Is NOT Required
- AI was used for research only - asking questions, understanding APIs, exploring approaches - but the human wrote all the code
- AI performed purely mechanical tasks like formatting, running commands, or committing (e.g. using any
commitskill we may have) - AI was used to help write documentation for issues or pull requests (not committed code)
The distinction is about code in the repository. If you used AI to understand how GTK layer shell works and then wrote the implementation yourself, no trailer is needed. If AI generated the implementation and you reviewed/adapted it, include the trailer.
Pull Request Guidance
When submitting a pull request that includes AI-assisted code:
- Ensure all relevant commits include the
Assisted-bytrailer and align with our Contributing documentation - Ensure an Assisted-by trailer is included at the end of any summary section of the work (before any section for tests / test plan)
- Your test plan should reflect that you actually built, installed, and verified the changes
- Supplemental comments on the PR with AI prompt/planning information are welcome and encouraged for research and learnings, but not mandatory
If you used an AI agent for planning or implementation, sharing that context as a PR comment can be valuable for reviewers and for the project's collective learning. However, AI planning documents should not be committed to the source repository. Share them as PR comments instead.
Blog Posts and Written Content
The attribution requirements in this policy are specific to source code contributions. Blog posts and other written content are a different matter. Writing is inherently a process of drafting, editing, and refining, and AI tools can be a natural part of that workflow.
AI tools may be used to assist with writing blog posts, release announcements, and other project communications. No Assisted-by attribution is required for written content. The author is still expected to review, refine, and stand behind what is published; the final voice should be theirs.
Content that is wholly generated by AI tooling without meaningful human involvement is never acceptable. Readers should never expect that a blog post or any form of written content by Buddies of Budgie was produced entirely by AI. There is always a human involved in the process of shaping the narrative, ensuring accuracy, and making it their own.
Enforcement
Intentional obfuscation of AI tooling usage is grounds for rejection and may result in being blocked from future contributions.
The goal of these LLM-related enforcements is to enable us to have honest, transparent collaboration.
The enforcement happens when an AI Policy violation is discovered (at the time of contribution or later):
- On the first violation you will be provided a warning unless the violation is deemed severe enough by a member of "Best Buds" (for example, en masse PR submissions or clearly fully agentic submissions)
- After one warning, any future violations will result in you being blocked from future contributions
- When a violation occurs, your contribution can be rejected, reverted, or rewritten
This enforcement is not subject to debate. At the end of the day, we are all volunteers who must review the contribution, take into consideration existing and future users or use cases, and more.
This Policy Applies Equally
This policy is tool-agnostic. It applies to Claude, Gemini, Copilot, ChatGPT, locally hosted models, and any other current or future models. The expectations are the same regardless of which tool you use.
Living Document
This policy is subject to change as the AI landscape and our own experience with these tools evolve. Contributors are expected to be mindful of updates to this policy and to periodically revisit it to ensure their practices remain in alignment.