Winters urges shift from coding to design and verification in CS education
Titus Winters argues that computer science curricula must abandon manual implementation exercises in favor of high-level design and AI output validation. He advocates for deterministic tools over direct AI inference for large-scale refactoring to ensure accuracy and auditability.
Titus Winters, former Google engineer and lead author of 'Software Engineering at Google,' contends that undergraduate computer science curricula have remained largely unchanged since 2000 and rely on tradition rather than current relevance. Serving on the ACM and IEEE steering committee, Winters advocates for eliminating traditional requirements such as implementing linked lists, arguing that AI can now complete these assignments, rendering them obsolete. Instead, he proposes a focus on design, specification, and the precision of prompts and tests used to validate AI-generated code. Winters suggests that software engineering programs may become more relevant than traditional CS degrees, citing the University of Waterloo's co-op model as a practical alternative. He emphasizes that new graduates must develop resilience against simply copying tickets into AI prompts and must be able to stand up for the code they merge, as AI tools are not accountable. To ensure learning occurs, he recommends grading the process, including prompts and tests, rather than just the outcome.
In the context of large-scale engineering, Winters describes the Abseil project at Google, which involved refactoring 250 million lines of C++ code with 10,000 engineers making edits monthly. The team used compiler-assisted, semi-automatic refactoring via AST transformations in Clang and LLVM to generate deterministic edits, rather than relying on non-deterministic AI. Winters notes that while AI is capable of such tasks, deterministic tools like OpenRewrite or BrontoSource are more accurate, auditable, and cheaper on token consumption. He advocates for a 'zero token architecture' where AI is used to generate the configuration or recipes for deterministic tools, rather than performing the inference-heavy refactoring itself. This pattern allows teams to codify architectural rules and learn from mistakes once, applying them consistently via linting and static analysis, reserving human attention for complex design decisions.