Titus Winters on Google's Engineering at Scale and Why the CS Curriculum Should Be "Burned Down"

Open on YouTube ↗
Overview

Titus Winters spent more than a decade at Google. He led its readability program, helped build Abseil, and was lead author of Software Engineering at Google. In 2023 he was the only working software engineer on the steering committee that set the ACM/IEEE undergraduate computer science curriculum guidelines. He is now a Senior Principal Scientist at Adobe, focused on developer experience.

32 min read

In this conversation with Gergely Orosz on The Pragmatic Engineer podcast, Winters covers what Google learned about changing code safely at enormous scale and why teams and psychological safety still matter when AI writes much of the code. He also explains why he thinks today's productivity metrics miss AI's most important value. The thread running through it all is his argument that computer science education, which he describes as largely unchanged since around 2000, needs radical rebuilding.

From a QBasic Book to Google New York

Winters traces his start in programming to a Valentine's Day when he was about 11 or 12. Instead of buying candy, his father, who worked in carpentry and set design but sensed computers would matter, bought him a book on learning QBasic. Programming became his hobby for the next five or six years, self-taught in a pre-internet era "when you had to really fight for it." He later attended a magnet high school in Las Vegas with a computer science program, then Harvey Mudd College.

His graduate path was unusual. He did a PhD at UC Riverside in computer science education, working on applied AI and educational data mining, and published at some of the earliest CS education research conferences. His advisor was a long-serving department chair, so much of his graduate experience consisted of learning "all of the stories of how we got here" and teaching whatever classes needed covering. That background resurfaces later in the conversation.

After the PhD he did not get a professorship. He spent four years at a small consulting group of 30–50 people, mostly working indirectly for DirecTV on embedded set-top box software. In 2010 he interviewed at Google, which was then among the hardest places to get into. He recalls feeling he didn't do well: he flew up from San Diego the morning of the interview to save vacation days, which he now calls a bad plan. In one interview, on camera angles for a Mars rover, he wrote a placeholder function with the right inputs and outputs, said it would work "if I wasn't stupid this morning," and moved on to the interesting parts. He thinks the interviewer appreciated that. He got the offer and moved to Google's New York office, which already had a few thousand people.

Finding the Right Team

His first placement was a poor fit. Because he had a networking background, Google put him on a team monitoring traffic crossing the edge of Google's network, which he describes as really a databases problem, and databases were never his interest. Orosz pushed back: shouldn't a new hire at a hot company just dig in? Winters says he did what he could to learn, but there was also some interpersonal tension, and the fit felt wrong.

About two months in, an email went to New York engineers proposing a new team to maintain old C++ infrastructure code written by early employees "whose employee IDs are like two digits" and who had more important things to do than handle patch requests. Nine or ten people raised their hands. Winters was the only one who showed up to the second meeting, so he joined. He notes this was roughly the last year before Google became formal about headcount and team assignment, though he admits he may not have understood the internals then.

The work suited him. At DirecTV he had built an API for UPnP-style local network RPC, after seeing teams hand-assemble XML for every request. He likes this kind of infrastructure and API design work.

14:06

Why Google Made Testing Mandatory

Orosz pointed out that maintaining other people's C++ sounds like a lose-lose: break something and people are angry, do it well and nobody notices. Winters says the safety net was already in place, because Google had already gone through its "yes, you have to write tests" phase.

The story he relates is that around 2006–2007, Search lost the ability to release on a regular cadence. The goal was monthly releases, but they might get one per quarter because of persistent regressions. At the time, the architecture was not well separated, so a change to Gmail could still affect Search. Release engineers banded together and declared that changes without tests would not be merged, regardless of which VP asked or how important the feature was, and would be rolled back. Once that line was drawn, even the engineers who considered tests beneath them had to comply. In 2010, Winters notes, mandatory testing was not yet an obvious industry norm.

For his team, this meant that if they refactored a library and all tests passed, either the change worked or the test coverage had been insufficient. Either outcome was useful, since exposing missing coverage now beats discovering it later at twice the traffic.

Winters states a principle he says has been on the first pages of the book for ten years. A codebase is sustainable if, for any valuable change, you are capable of making that change safely. You may choose not to make it, for reasons of technical debt or priorities, but being incapable of change is a high-risk bet that change won't be needed. "Fear is not an acceptable basis for engineering," he says. He adds that security has gotten "real real bad" in the last few years, so there is nothing that won't need to change.

Why New Engineers Fear Mistakes

Orosz asked whether a new hire who is afraid to push code is working in a poorly engineered system. Winters says it is one or the other: either the system is bad, or onboarding and mentoring didn't happen.

He connects this to education. Undergraduate programs teach that there is a correct answer, and students are graded whenever anyone looks at their work. So new grads easily fall into fear of not knowing whether they "did it right," when in reality engineering is about trade-offs and choosing a point in the design space. Orosz shared his own experience: at his first job he finished work, heard nothing, and assumed he was about to be fired when called into a one-on-one with the CEO. Instead he was praised for onboarding quickly. Years of direct, graded feedback hadn't prepared him for silence.

Winters adds that for undergrads, the only time a human looks at your code is to judge you. Experienced engineers, by contrast, constantly ask for non-judgmental check-ins ("are we going in the right direction?"), and the more of that feedback you get, the more effective you are. He laments that "we've given all of the new grads and all the junior engineers exactly the wrong instinct."

20:44

Abseil and "the Largest Refactoring Task in Human History"

Abseil began about ten years ago, after Google's initial pivot to cloud and around the time Google became Alphabet. There was interest in externalizing Google's developer tools and sharing internal components across Alphabet companies that would no longer share one company or one monorepo. The multi-tenant developer-tools idea faded after a year or two. But the low-level piece remained: Abseil was "the layer of common C++ idiom," the vernacular everything at Google is written in, open-sourced as a common substrate. Since some of that vernacular was messy, the question was whether to clean it up before committing to it publicly forever. To Google's credit, Winters says, the answer was yes. Abseil is the public projection of what got cleaned up.

Winters calls that cleanup probably the largest refactoring task in human history, while acknowledging he can't prove it. The codebase was, by his account, 200–250 million lines of first-party, Googler-authored C++, not counting external dependencies. He believes it was the public number at the time. Roughly 10,000 engineers edited it in a given month. Ten to twelve people worked on it full-time. The team's joke: Google has new skyscraper foundation technology, "we're replacing the foundation under the Empire State Building, we're not allowed to close the building or block traffic, and we discovered nuclear waste in the basement."

Orosz offered scale comparisons. Pre-AI, Uber's iOS and Android apps were each about a million lines written by around 200 engineers over years. He rarely hears of pre-AI codebases over 3 million lines, so 250 million is about a hundred times larger than anything else he has encountered.

26:13

How the Refactoring Actually Worked

The approach depended on owning the low-level interfaces: caches, containers, string routines, command-line flags. Improving an API with 50,000 call sites or 100,000 required edits was the problem. Winters was friends with, and eventually an "org chart cousin" of, the compiler team working on Clang/LLVM, which was doing abstract syntax tree transformations.

The technique ran as a MapReduce over the codebase. Mappers parse every C++ translation unit and produce parse trees. You then match against those trees, not as a text search but with the guarantee that a specific function is called in a specific context, and run code to rewrite the match. This gave them compiler-assisted, semi-automated generation of text edits.

One surprising obstacle was whitespace: they could generate edits but not place whitespace correctly. "clang-format exists because I wished for it," Winters says. He literally could not accomplish the refactoring until someone built an auto-formatter for C++.

The second obstacle was size. Any codebase has a natural background rate of change, and an edit touching 10,000–20,000 files will never test and resync before something else changes underneath it. Halting a 10,000-person company's commits for an hour doesn't scale. So the technique was:

  1. Design the refactoring so the old and new APIs can coexist.
  2. Split the edits, for example by directory, and send them out in parallel batches.
  3. Once everything is migrated, race to prevent anyone from copy-pasting the old form.
  4. Delete the old API, make the new one the default, and move on.

"You just do that a few hundred times and your codebase is in much better shape." Initial reactions were often "why are you changing my code?" but quickly turned positive. Winters notes a side effect: when someone is constantly "janitoring" the codebase, copy-and-paste becomes the correct way to learn how to do something, because if a pattern were wrong, it would already have been fixed.

30:34

AI for Rewrites: Generate Deterministic Tools, Not Constant Inference

Orosz observed that AI-driven rewrites today feel "janky" compared with Google's deterministic approach, and asked whether that approach would spread. Winters says it already exists. In Java, tools like OpenRewrite let you declare a code pattern and its rewrite, then apply it across all source files. AI turns out to be very good at generating OpenRewrite recipes. That is far cheaper in tokens, more accurate, faster, and auditable. He recalls talks from, he thinks, Netflix and Uber (while saying he could be wrong) that reached the same conclusion: use a deterministic tool that declares the intent of the rewrite, and have the AI learn to produce configurations for it. In C++, friends of his have a startup called BrontoSource focused on high-level declarative rewrites.

He cites a recent Kelsey Hightower talk on "zero token architecture." The thesis, which Winters thinks everyone is converging on, is not to use AI for constant inference. Use it to generate the deterministic tool that does the work, and let AI fill the gaps that the tool can't solve or decide when to invoke it. An architecture built on token consumption forever is probably neither the cheapest nor the most effective.

Orosz described a head of engineering who runs expensive, slow AI code reviews only occasionally. When a review finds something, agents generate a new lint rule, which is cheap, repeatable, and deterministic. The idea was inspired by Uber's pre-AI culture of encoding every lesson, including architectural rules, as lint rules, which made Orosz's first week there painful. Winters agrees: learn hard lessons once, codify them deterministically, apply them fairly, and reserve code review for what humans actually need to do. He thinks not everyone invested enough in linting and static analysis before, and that it is equally true now.

39:02

Writing Software Engineering at Google

The book began near the tail end of the idea that Google might ship its developer tools externally. If it did, it would need to explain why those tools are the way they are; otherwise it would feel "like aliens came down" offering something that made no sense. The team's "hubris" to write it came from the refactoring work: having touched everything any engineer thought was a clever solution, Winters' "cadre of weirdos" had seen more "I can see how you thought that was a good idea, don't do that" cases than almost anyone. He stresses these were testing and local-code-design scars, not production scars. "My job ends at merge," he says. That is part of why the book doesn't cover operations, which would have doubled its length.

The book followed the model of the SRE books, gathering an expert on each topic. Winters, Hyrum Wright, and Tom Limoncelli are on the cover. Winters and Wright provided technical leadership; Wright had generated millions of edits that Winters, who had review permissions across nearly the entire codebase, reviewed. Limoncelli, long their tech-writer friend, handled editorial and structural work. Some contributed chapters were good from the start; many needed iteration. The project took almost two years at quarter- to half-time effort, and Winters didn't realize how much they had overshot until he saw the printed book: "Wow, that's huge."

42:59

Readability: Possibly the Largest Educational Program in Tech

At Google, every change requires that someone involved, author or reviewer, holds two permissions: ownership of the files, and readability certification in that language, meaning they are trusted to write idiomatic code in that codebase. The goal is consistency and common patterns, because consistency has strategic value.

Originally, employee number three, Craig, sat down with every new employee to walk them through their first change. When that stopped scaling, others acted as proxies, reviewing a big substantive change. But as most work shifted to small edits in existing products, finding a single change meaty enough to demonstrate full competence got hard, and the process felt like hazing. Over the years, starting, Winters believes, with Java, it became a mentoring program. After your team approves a change, a reviewer from a round-robin pool looks for anything substantive worth commenting on. On teams with strong standards there is little to say and you graduate quickly. If you choose not to learn, you graduate slowly, if ever.

Winters says the educational design was deliberate, at least in the parts he influenced. When he left Google almost three years ago, he was the overall owner of the program, and he argues it may have been the largest educational program in tech, or even the world, with tens of thousands of participants at any moment. Some people were "super pissy" about it, since participation wasn't voluntary. Orosz described a progression: addressing comments, wanting fewer, reaching zero, becoming a reviewer, giving feedback. Winters adds that reviewers saw other parts of the codebase and other teams' tech, making it "a huge, subtle, below-the-waterline information-sharing program."

47:27

Why Teams Still Matter With AI

Orosz read a passage from the book (a chapter Winters doesn't think he wrote) saying lone craftspeople are rare and great achievements come from heroic team efforts. With talk of "100x engineers" working alone with agents, does the team still hold up?

Winters says yes, regardless of how bullish one is on AI. If agents are the way forward, engineers are still managing a team of agents. He has heard more people say the problem now is turning every engineer into an engineering manager for agents without the training or background for it. If instead AI is a tool like an IDE, then it is still you working with a team of humans. Agents don't have feelings, he says, which changes social dynamics. But clear communication and getting ideas out of your head remain essential. "Software engineering is a team sport, period."

Orosz pointed to the AI labs themselves. Claude Code has a public face in Boris Cherny, but there is a team behind him that clearly gels and trusts each other enough that things keep happening when he is on holiday. Winters picks up on the word trust. He says the labs naturally have something much of the industry lacks: they are learning as they go. Across DORA and other research on productivity and team effectiveness, he says, it boils down to culture, psychological safety, and the permission to learn: admitting you don't know, learning from each other, sharing mistakes so the team only makes them once. Lint rules and SRE postmortem culture are examples. "Every effective structure and organization in tech is actually about information flow and learning." He recommends Cat Hicks's work, and mentions he may have written the education chapter for a forthcoming Platform Engineering at Google book, now in O'Reilly early release.

52:38

Psychological Safety as a Predictor

Playing devil's advocate, Orosz asked whether smart engineers really need psychological safety. Winters cites a figure he says has been hard to trace to its source but that he heard from people involved in DORA research: a 15-question assessment of team culture can explain about 30% of the variance in whether a team hits its goals. "Find me anything that's even remotely that powerful a predictor of success. It's a people problem, period."

He then critiques "The Surgical Team" chapter of Fred Brooks's The Mythical Man-Month, his least favorite in the book. It assumes a single project: the best person does the work and everyone else supports them hierarchically. That might make sense for a one-shot task. But engineering is an iterated game, iterated prisoner's dilemma rather than prisoner's dilemma, and that calls for a different strategy: give work to the most junior person who can do it with supervision, so they grow while the outcome remains decent, freeing senior people for problems nobody can yet solve. That requires people to admit what they don't know, which brings you back to psychological safety.

Orosz argued that AI labs get this partly for free. They are in hypergrowth with rising equity, so performance reviews matter less, and since nobody knows the new technology, saying "I don't know" is natural. At companies with flat growth, performance reviews, and annual cuts of, say, 6% of staff, people are incentivized to look smartest, hoard projects, and distrust teammates. Winters agrees. If people believe team outcomes drive their own success, they don't need the one shiny task, and "it might be my turn next." Individualism and competition within a team are "a recipe for stagnation."

58:28

Layoffs and Their Hidden Costs

Asked how layoffs change engineers' behavior, Winters describes weeks or months in which every one-on-one starts with "how are you coping?" before any work is discussed. He is very skeptical that executive accounting includes the lost productivity: people updating resumes in case they're next, one-on-ones turned into therapy instead of planning. Layoffs are demotivating because they drive home that the job is "just a business obligation," and if putting in extra doesn't buy safety, "what's the point?"

He praises Adobe on this point. Its long-time CEO, who recently stepped down, saw during the Great Recession how much layoffs hurt morale and productivity. The lesson was that what made numeric sense was "not good for the soul of the company." So, Winters says, Adobe didn't do sweeping layoffs in recent years, though there are local, group-by-group changes as priorities shift.

1:01:32

Measuring Developer Productivity and What AI Breaks

At Adobe, Winters works on developer experience, which he calls "a polite fiction": it is really the business of productivity, "we just know enough not to say that we can measure productivity." Engineering compensation is most companies' biggest expense, so improving tools and culture matters.

Since productivity has no obvious unit, he borrowed from economics: an index metric. Measure everything that might signal things are going well or badly (releases, test coverage, number of PRs, and so on), then weight them. His initial formulation used wisdom of the crowds: experienced engineers repeatedly choose between options like "one more release per week or X more tests," much like a "hot or not" game, to work out linear trade-offs. Remove duplicate stats, keep ones with non-linear relationships, and combine them into a unitless but directionally useful number you can track over time. Adobe is doing something along these lines, he says, slightly smarter than his first version.

But he has realized this won't capture everything after the AI boom. In a recent paper on develop/deploy/operate, he describes four forms of impact in tech:

  • Product success: revenue, net promoter score, adoption.
  • Compute efficiency: cloud spend, or the Android example of shaving a megabyte off an app download.
  • Engineering capacity: productivity gains that aren't dollar-fungible; you just get more engineering capacity.
  • Changing the game: strategic innovation. Research makes impossible things possible; security makes very bad things impossible.

AI's problem for metrics lies in the fourth category. Even a clever index can't capture a change in the value of a given piece of work. His example: you can now write a JPEG parser with whatever features you need in a couple of weeks, which would have been "insane" to say three years ago.

Orosz offered a story from a CTO friend at a mid-size niche engineering company. The CTO suspected the company could do the same work with half the staff and become cash-flow positive, but didn't want to make cuts. Weeks later, the company was heading toward cash-flow positive anyway. It had licensed a closed-source, high-performance component from a vendor for a revenue share of something like 5–15%; writing it in-house would have taken a team years. An engineer suggested feeding the AI the specs and the company's extensive test harness. The resulting component was faster and better, built with no prior domain knowledge. When the company considered open-sourcing it, the vendor offered to pay them not to and to take the implementation for re-licensing. Had layoffs happened, Orosz noted, that engineer might have been gone and nobody would have known the game could change.

Winters sees this as bridging a gap. He has not seen research showing post-AI productivity gains above roughly 20–30%, yet people describe 10x experiences, though he "super" doesn't think it's actually 10x. His explanation is that much of AI's value isn't doing the same thing faster but doing harder, more valuable things you wouldn't have attempted. If your metrics count widgets leaving the factory and you start producing deluxe gold-plated widgets, you can't see it. He quotes senior engineers who report being up 70% on code and up 30% on outages with the same number of features. The unknowable part is whether the value of those features went up.

1:11:42

A Curriculum Frozen in the 1990s

On computer science education, Winters establishes his credentials: after the book, he joined the ACM/IEEE/AAAI effort to define undergraduate CS degree requirements, served on the steering committee as its only working engineer, and mostly managed the software engineering requirements.

His blunt assessment, which he also gave in a pre-AI keynote, is that most of the CS curriculum hasn't substantially changed since around 2000, maybe earlier. The average topic is exactly what was needed to build a database or operating system in the '90s. He asks whether topics are taught because they're relevant or because of tradition. Orosz added "or because we know how to teach it." The oldest CS departments are only 50 to 70 years old, far too young to run on tradition. The curriculum has grown by accretion: add topics, cut depth on existing ones "by epsilon." Even before AI, he wanted more practice and drill toward fluent programming and algorithmic thinking rather than "trivia understanding of a million different topics."

Now, he says, a student can complete an entire degree without thinking by feeding assignments to an AI. So he is pushing to "get out of the code" and up-level substantially. Students must still read code, think as systems thinkers, and understand structure and execution. "But no one needs to implement a linked list," and perhaps linked lists shouldn't even be taught, since memory access makes them slow. The focus should shift to design, specification ("precision in saying what you want to happen"), and testing, validation, and verification. His prediction: CS enrollment may plummet while software engineering programs grow, because what matters for getting a job in the AI era is teamwork, communication, design, specification, testing, and validation.

1:16:13

Reps, LeetCode, Boot Camps, and Co-ops

Orosz described his own CS degree: lots of theory, one team-based project course in four years, and a sense of starting from scratch when he reached industry. He had the theory but not the reps. Winters argues LeetCode-style interviews exist because of this gap. They were a proxy for whether someone had spent enough time on task, as programming contest participants had, not because companies needed another breadth-first search.

Orosz noted that boot camps, strong around 2014–2017, took people with no background through three to six intensive months of building a full web application. Graduates arrived knowing version control, pull requests, databases, and browser dev tools, skills four-year grads might or might not have. Winters has done the math: the hours in a CS degree roughly equal 15 months of full-time work, including all the questionably relevant theory, compared to a six-month boot camp laser-focused on immediately relevant skills.

Orosz raised Waterloo, whose grads are common in Silicon Valley, attributing it to built-in placements: about four internships, roughly a year inside companies like Shopify and Meta. Winters says he is "incredibly jealous" of many Canadian programs' co-op structures, even though those degrees often run five years. Some lessons, he admits, were left out of the software engineering requirements because they can't be taught academically. He wants more projects, but worries that a single project course gives the wrong idea of teamwork, since no real team consists of people with identical backgrounds.

1:22:58

What New Grads Should Focus On

Winters calls "learn the basics" a loaded question because nobody agrees on what the basics are. He cites Kent Beck: everyone currently working grew up with a playbook, and now there isn't one.

His advice for juniors starts with resilience against pasting a ticket into an AI prompt and checking in the result: "you can be replaced with a very short off-the-shelf script." Use AI to widen your inputs and better yourself, not to immediately produce all your outputs. He invokes "Andrew's Axe," a metaphor from a think tank about a year ago: if you chop down a tree with an axe, you chopped down the tree, not the axe. He also quotes a 1979 IBM training manual: a computer can never be held accountable, so it should not make management decisions. AI labs won't indemnify you for AI mistakes, so you must stand behind every pull request with your name on it. That takes rigor and attention to detail, which he thinks is hard to train.

He relays what he hears from professors. The best students, B/B+ and above, are better than ever because they have an infinitely patient, always-available, well-read, "sometimes hallucinatory" tutor. The worst students are somewhat better because they can now produce slop instead of nothing. But the middle has collapsed: students who would rather party or play games slide into habitual copy-paste. Some professors at decent schools wonder whether students below a B understand how code works at all.

Banning AI is nonsense in his view, echoing old fears that high-level languages would prevent learning assembly. He co-published a piece in Communications of the ACM with academics, opening with a scenario in 2040: if schools treat all AI use as cheating and keep asking AI-native students to find palindromes or measure rainfall in a graph, they will learn nothing. The task is to assume AI use, define new learning objectives, and keep enough friction to force thinking, almost certainly at a higher level.

His simple fix is to stop grading only the outcome. Grade the process: the prompts used, the tests written, how the student verified the result. Across disciplines, he argues, we have used artifacts as proxies for struggle. "We don't need another essay on Catcher in the Rye... We don't need another linked list." Instead, ask for evidence that the student struggled and learned, and "turn in the whole package."

1:32:20

Titus's Ideal Curriculum

Pressed to be opinionated, while admitting "nobody knows, there is no playbook," Winters sketched his approach:

  • An unaided first semester. Students learn without AI until they can read code and follow control flow.
  • Well-scaffolded educational AI. AI deliberately designed not to hand over answers, paired with process-based assessment so that getting a full answer from ChatGPT isn't a threat.
  • A "CS zero" on interfaces for majors and non-majors alike. How to describe inputs, outputs, and interface design: checkbox versus radio button, when to use a button, command-line flags versus positional parameters. Even if it is the only class someone takes, their vibe-coded tools will have a more coherent design language. He cites his condo building's laundry app, which uses a menu where it should use a button.
  • Motivation before theory. Move into projects and teamwork, letting students hit problems that make them need to know how the web or a remote API call works. "You can't give people a solution to a problem they don't realize they have." Theory presented first is just disconnected trivia.
  • Projects without single correct answers, since that's not how industry, or mostly research, works.
  • Grading peer critique. Students review others' work and are graded on giving feedback without being a jerk, for the sake of psychological safety. AI could help with the workload, for example sentiment analysis to flag rudeness.

He worries this will happen in software engineering departments, not CS departments.

1:36:29

Advice for Breaking In

Winters says most of his own success came from not doing what everyone else was doing. Chasing the same hot topic as everyone else makes it nearly impossible to stand out. "To thine own self be true": find something you genuinely care about, especially if it's weirder than what others do, and put real time into it. That gives you a novel story for interviewers and makes you worth talking to when a startup founder is deciding whether to take a risk on you.

He closes with a worry and a prediction. With AI-assisted engineering, he thinks the emphasis on raw engineering skill is dropping, since you can get by with less depth. What replaces it is much deeper understanding of the problem domain. That might reduce mobility across the industry: identity shifts from "I'm a C++ engineer" or "I'm a back-end engineer" to "I'm an engineer in embedded audio," and that domain depth becomes the real advantage.

His book recommendation is Cat Hicks's The Psychology of Software Teams. He wishes a couple of its chapters could be downloaded into every leader's brain, calling its "brains in jars" analogy "haunting."