Compiler development is in crisis. The pool of contributors has been shrinking for years while the C++ standard accelerates. The gap between what is standardized and what is implemented continues to widen.
In January 2026, eighteen major compiler implementers published P3962, "Implementation reality of WG21 standardization." Their assessment is stark:
"Many implementers are volunteers or are only partially funded for standardisation work, and there is often no dedicated staffing to implement all standardized features."
"Full conformance to recent standards remains difficult in practice, with some implementations still working toward C++20 conformance with limited capacity to adopt newer standards."
"Adding new features to the standard necessarily displaces other work, including bug fixes, conformance improvements, performance tuning, and various high-value library enhancements."
The implementers themselves are calling for help. Traditional workflows cannot scale. Human bandwidth is the bottleneck, and that bottleneck is tightening.
Accelerate Clang's implementation of C++ standard features so that new standards become usable faster than on any other platform.
Not by replacing compiler engineers with AI, but by giving them leverage. AI handles the production work—synthesizing patches, generating tests, drafting documentation. Humans provide the judgment that makes the output correct, maintainable, and upstream-ready.
We aim to meaningfully increase Clang's overall throughput for feature implementation and bug fixes—contributing upstream-ready patches that benefit the entire community.
- Upstream is the mission — why we exist
- Human expertise is the foundation — how we ensure quality
- Honest workflow earning trust — how we operate
- We own the verification burden — our responsibility
- Every decision is traceable — accountability
Everything we produce aims for acceptance by the official Clang project; Clang's success is our success. Experts decide, AI assists—no code reaches upstream without human approval. Our process is transparent about AI involvement and earns trust through integrity, especially given that compilers sit at the root of software security. We bear the verification burden so upstream reviewers don't waste time on unpolished output; the world sees finished work, not our iteration. All knowledge flows through issues, PRs, and review threads—nothing happens off the record.
A human-agentic workflow is structured collaboration between humans and AI systems:
- AI agents perform well-defined production tasks: code generation, test synthesis, patch formatting, documentation drafts
- Human experts provide judgment, domain knowledge, and approval at every decision point
- All outputs are versioned, traceable, and auditable through standard GitHub mechanisms
The AI handles volume. Humans own quality. Every line of code that reaches upstream has passed through the judgment of engineers who understand C++, compilers, and Clang's architecture.
We maintain a dedicated collaboration space on GitHub where our engineers and AI work together to produce upstream-ready Clang contributions. A cloud service monitors this workspace, connected to AI APIs through a GitHub App. The infrastructure is invisible to contributors—what they see is GitHub.
The entire interaction happens through familiar GitHub primitives: issues, pull requests, branches, comments. The AI behaves like another GitHub contributor. No special tools. No new interfaces to learn.
1. Issue Creation
Team members open issues describing bugs or features to address, referencing upstream Clang issues where applicable. Standard GitHub workflow—describe the problem, link the upstream tracker, provide reproduction steps.
2. AI Response
The GitHub App observes the issue and responds:
- Comments on the issue with analysis, questions, or clarification—like a contributor trying to understand the problem
- Opens a pull request with a candidate fix—like a contributor submitting code for review
3. Human Review
Reviewers interact with the AI exactly as they would with any contributor:
- Request changes via PR comments
- Ask questions, get answers
- Push back on the approach, propose alternatives
- The AI responds in the thread, revises commits, updates the branch
This is not a black box. It is a conversation. The reviewer drives; the AI responds.
4. Human Approval
Standard GitHub approval flow. When the code meets human standards—correct semantics, clean architecture, upstream-acceptable style—reviewers click Approve. Not before.
5. Upstream Submission
The polished, human-approved patch is submitted to official upstream Clang. It is simply good code, ready for review by the LLVM community.
6. Upstream Review
The patch goes through LLVM's standard review process. If upstream reviewers request changes, the cycle continues until the contribution is accepted.
Every AI output passes through human judgment. This is not a constraint we tolerate—it is the design.
Our reviewers are subject matter experts with deep understanding of C++, compilers, and Clang's internals. They evaluate correctness against the standard. They assess compatibility with Clang's architecture. They predict what upstream maintainers will accept.
AI accelerates production. Humans own decisions. The workflow amplifies expertise; it does not replace it.
Our workflow, once proven, could benefit the entire Clang community:
- AI-assisted code review for upstream pull requests—analysis performed privately, reviewed by our experts, posted only when it adds value
- Faster triage of bug reports and feature requests
- Documentation generation for complex changes
We aim to make all Clang contributors more effective, not just our own team. The goal is to help Clang win.
- CI/CD: Cloud instance with continuous Clang builds
- Build Speed: Near-instant feedback on upstream changes and PR submissions
- AI Integration: Backend service monitoring issues and generating patches via GitHub App
- Krystian Staziowski — Compiler initiative lead
- Matheus Izvekov — Reviewer
- Vlad Serebrennikov — Reviewer
- Coordination:
#cppa-clangSlack channel