Google pays to acquire Android developers’ private code to feed Gemini

Google Starts Paying for Code

In the past two days, 404 Media exposed an email that Google sent to Android developers. The content is straightforward: we want to pay for access to your private repositories that are running in production, to train Gemini and improve Antigravity 2.0 and other developer tools.

The email made it clear—developers keep 100% of their intellectual property, authorization is non-exclusive, the app is still yours, you can still list it on the Play Store and sell it to others. Google only wants a "read right."

At first glance, it might seem minor, but a closer look reveals a strong signal. Google, long seen as a company that never lacks data, is now emailing individual developers for authorization. That means high-quality, publicly crawlable code has been largely exhausted.

Why “Production Code”

Anyone with several years of engineering experience knows: the open-source code you can find on GitHub and the code actually running in a company’s production environment are completely different species.

Public repositories are generally “clean” — sample projects, tutorials, personal toys, and lots of demos uploaded for résumé-building. They typically:

• Have simple business logic, often covering only one happy path
• Have no historical baggage, no random if branches left behind by a PM five years ago
• Handle errors either too perfectly or not at all
• Rarely deal with the messy parts — permissions, billing, compliance

Now, what does the code of a real Android app on the Play Store with hundreds of thousands of DAUs look like? It’s full of A/B test switches, gray release config, hacks for certain Chinese ROMs, payment flows that were patched to pass audits three years ago, and those “don’t touch this or it’ll crash” legacy if-elses.

That’s the reality developers face every day. If Google wants to train an AI coding assistant that can actually help with real work, it has to feed these into the model. The line in the email saying “to understand complex logic, used for development code evaluation and benchmarking” basically means: our current benchmarks have been completely mastered by the models, but the models still perform poorly on real-world engineering, so we need new data.

The Pressure on Antigravity 2.0

Speaking of Antigravity—it’s the agent-based development platform Google launched last year alongside Gemini 3 Pro. It’s positioned as “a task management layer above the IDE” — you no longer prompt line-by-line for completions, but hand over entire tasks to a group of agents that plan, execute, and verify in the editor, terminal, and browser.

Sounds great in theory. But after launch, developer feedback was very mixed. On Reddit’s Brazil developer forum, one viral complaint said roughly: if Google wants to charge for this as a professional solution bundled into the AI Pro subscription, it needs to be stable enough to keep pace with real-world workflows. As it stands, the current limitations, instability, and context loss make serious use difficult.

That’s the situation for Antigravity 2.0. It’s facing two very different competitors:

• GitHub Copilot — the de facto standard in real-time completion, deeply integrated into VS Code and JetBrains, fast and stable at generating boilerplate code;
• Anthropic’s Claude Code — the representative of agentic programming, capable of digesting an entire repository, editing across files, running tests, and debugging itself.

Google wants a place in between, but Gemini 3 Pro’s reliability in agent workflows still lags. No matter how smart the model is, without exposure to real engineering projects, when it encounters multi-file edits, cross-module dependencies, or implicit conventions, it easily goes off track.

So this code-buying move is, in essence, Google catching up.

Is This a Good Deal: Developer Perspective

For independent developers and small teams, this is a fresh opportunity window.

Previously, your code had only two monetization paths: make money from the app itself, or sell the whole company. Now there’s a third: rent out access to your code—the app stays yours, operations continue, and you gain an extra stream of revenue.

But what’s not in the email is what really matters:

1. Payment amount. Is it by lines of code? Repository size? Or a one-time license? That determines whether it’s worth it;
2. Participation threshold. Are they targeting top apps or casting a wide net? Are archived and active projects valued the same?
3. Data handling details. Once your code enters the training set, the model might later output snippets similar to your original—how is that “memory” handled legally?
4. Audit mechanisms. Non-exclusive sounds relaxed, but how can a developer be sure the code is only used as stated? Are there logs? Third-party audits?

Every Android developer knows that a production app’s code often mixes in third-party SDKs, paid components, or even non-disclosable hacks. Before granting Google access, one must clarify legal boundaries—especially since SDK license terms often don’t allow re-licensing integrated code for third-party AI training.

The Bigger Trend: Model Companies Becoming Data Buyers

Zooming out, Google’s move isn’t unique.

Over the past year, major model developers have all been doing the same thing—spending money to buy data. OpenAI signed deals with major news publishers, Anthropic is negotiating with book publishers, Reddit has resold its data multiple times. Code had been relatively quiet because everyone assumed GitHub’s public repos were enough. Google’s active entry shows that assumption no longer holds.

Several factors are converging:

• The marginal value of public code keeps dropping; scores on HumanEval and SWE-Bench have hit the ceiling, but user-perceived improvements are shrinking;
• Companies are tightening defenses against code scraping, and GitHub is limiting API access;
• Regulatory pressure on training data legitimacy is rising—signing licenses proactively is cheaper than lawsuits later;
• What really decides success in AI programming is agentic ability—learning the “trajectory of doing things,” not isolated “snippets.” And that data only exists in real engineering.

So it’s likely that not only Google, but also OpenAI, Anthropic, ByteDance, and Alibaba will soon reach out to developers for data. Paid access will become the norm.

Trust Is the Hard Part

At the end of the day, the hardest part isn’t the money—it’s trust.

Developers are already cautious about how AI companies handle data. GitHub Copilot was once sued for training on GPL code; Stack Overflow saw protests against unauthorized AI scraping; earlier this year, several independent developers sued companies for reproducing proprietary code snippets in completions.

Google’s email uses reassuring phrases like “non-exclusive” and “retain intellectual property,” but their legal protection is limited. Once code enters the training corpus, it becomes part of the model’s weights—there’s no way to “take it back.” Even if you later withdraw, what the model has learned won’t be unlearned—unless it’s retrained from scratch, which won’t happen for one developer’s regret.

That’s why these deals need transparency: which code feeds which model version, how long it’s retained, which downstream products it may appear in, whether it’s de-identified. If Google stays vague on these points, participation will likely come mostly from small developers less worried about risk—leaving Google without the complex, high-value production code it actually wants.

Final Thoughts

The most interesting part of this story is how it highlights a counterintuitive reality: in 2026, the scarcest resource isn’t compute power, model parameters, or novel architectures—it’s the “messy real-world code.”

Whoever gains access to it can train models that truly help engineers inside IDEs. Google is taking the paid procurement route; Anthropic leans on usage-driven feedback loops via Claude Code; Microsoft’s GitHub ecosystem gives it a built-in advantage. When these paths converge, the winner may not be the one with the smartest model, but the one that best understands what real software engineering looks like.

For developers, this marks a pivotal moment. The code you write might, from today, actually be something someone is willing to pay for. But before signing anything, read that email’s terms twice—what you understand before you take the money will matter far more than the amount itself.

Worth noting: OpenAI Hub already supports major models including Gemini 3 Pro. Developers can connect via a unified OpenAI-compatible API without needing a proxy for domestic access, making it easier to compare model performance on their own code scenarios before deciding whom to license to.

References

• ITHome: Google Eyes Real Repositories, Pays for Android App Source Access to Boost AI Coding — Domestic media summary of 404 Media’s report, covering main email points and licensing details
• linux.do: Google Wants to Pay Play Store Developers for Source Access to Train Its AI — Developer community thread with original report links and feedback
• Reddit: Complaints About Google Antigravity and Gemini Code Assist Limitations — Real developer feedback on Antigravity’s current limitations and stability issues