Last weekend at Stanford, something remarkable happened. About 200 students walked out during Google CEO Sundar Pichai’s commencement speech. They weren’t upset about AI hype or worried about their job prospects. They were protesting Google’s defense contracts, specifically Project Nimbus, a $1.2 billion deal with the Israeli military. The signs said things like “GENOCIDE RUNS ON GOOGLE” and “ICE SPIES WITH GOOGLE AI.” That’s a far cry from the usual commencement day optics.
Here’s what got me thinking: this isn’t just about Pichai or Google. This is about us, the people who actually write the code.
The Nimbus Problem Isn’t New, But It’s Getting Louder
Project Nimbus is a cloud and artificial intelligence services contract that Google and Amazon jointly won to provide infrastructure to the Israeli military. If you’ve been paying attention to tech news, you’ve probably seen the protests both inside and outside Google. In 2024, Google fired 28 workers for protesting this very contract. The Electronic Frontier Foundation has criticized Google and other companies for “choosing to look the other way” on how their services are used.
What strikes me as a developer is the parallel to what happened in the early days of facial recognition technology. Companies built powerful tools, sold them to governments, and only faced serious backlash years later when the misuse became impossible to ignore. Now we’re seeing the same pattern with AI systems being deployed in conflict zones, often with developers having no visibility into how their contributions are being used.
The students weren’t protesting the existence of AI. They were protesting the specific deployment of that technology by a company that employs thousands of engineers, many of whom probably had no idea their work would end up in this context.
The Developer Accountability Gap
Let me be honest with you. Most of us in software don’t really know where our code goes once it leaves our laptops. You write a feature, it gets merged, deployed, and becomes part of some larger system that you might never see in production. That’s just how modern development works. We specialize, we abstract, we trust the pipeline.
But here’s the uncomfortable truth: that abstraction is becoming harder to maintain, especially when you work at a company like Google, Amazon, or Microsoft. When you’re building foundational cloud infrastructure or foundational models, you’re by definition building something that could be used for almost anything. The question is no longer “can we control what this does?” but rather “do we even get a say in what this is used for?”
The Google walkouts suggest that many employees feel they don’t have that say. And the students at Stanford are essentially saying: if you won’t hold yourselves accountable, we will hold you accountable publicly.
What This Means for the Industry
Vinod Khosla, the venture capitalist, called the protesters “biased, idiotic, short-sighted” and argued they were ignoring “the bottom 3 billion people on the planet that could benefit from AI.” That’s one perspective. But there’s another way to look at it: maybe the students understand something that tech leaders don’t want to admit. Namely, that building powerful technology without ethical boundaries isn’t neutral. It’s a choice. And right now, the people making those choices are executives and sales teams, not the engineers who built the systems.
The broader pattern here is that commencement speakers at colleges are facing more pushback when they try to get graduating students excited about AI. That’s not just about defense contracts. That’s about a generation looking at the tech industry and seeing something more complicated than “innovation for good.” They see surveillance, displacement, environmental costs, and now military applications. And they want to know: what exactly are you building, and who is it for?
Where Do We Go From Here?
I’m not going to pretend I have all the answers here. What I do know is that the old model of “build it and hope the ethics team sorts it out later” is failing. The protest at Stanford is a symptom of a deeper problem: the people who write code have less and less control over where that code is deployed, while the public increasingly holds them accountable anyway.
For developers, this raises real questions. Do you know what your company is building? Do you have visibility into who the customers are? Is there a path to raise concerns without risking your job? These aren’t just philosophical questions anymore. They’re career questions. They’re also, increasingly, questions that the next generation of engineers will demand answers to before they even accept a job offer.
The students walked out because they refuse to glorify corporations that fuel violence. Maybe the rest of us should be asking whether we have anything to glorify at all.