Software engineering at Google & CS education with Titus Winters

The podcast discusses significant shortcomings in current computer science education, advocating for a shift toward practical, software engineering-focused curricula that emphasize real-world problem-solving, teamwork, and design. With the rise of AI, traditional assignments like implementing data structures are becoming obsolete, and there's a growing need to assess students on their prompts, tests, and development process rather than just final code outputs. The discussion highlights the importance of project-based learning, early exposure to production software development, and integrating AI as a learning tool rather than a shortcut.

It also explores how AI is transforming software engineering practices, enabling rapid code generation and large-scale refactoring, but raising concerns about code quality, system sustainability, and the erosion of deep technical expertise. While AI can dramatically increase output, its real value lies in empowering engineers to tackle more ambitious problems rather than simply accelerating existing workflows. The conversation underscores the importance of maintaining deterministic, auditable tools for critical refactoring tasks and stresses that human judgment, psychological safety in teams, and strong educational foundations remain essential in an AI-augmented development landscape.

• What if you redesigned your solo development workflow to treat AI as a deterministic tool rather than a creative partner?

  • Move: Use AI to generate configurations for deterministic refactoring tools (e.g., OpenRewrite, Clang-Tidy) instead of writing code directly. Build reusable rule sets for common codebase improvements (e.g., logging standardization, error handling patterns).
  • Why Now?: AI-generated code is non-deterministic and costly to review; deterministic tools are auditable, faster, and scale better - especially for solo developers managing technical debt across multiple projects.
  • Expected Upside: Reduce long-term maintenance effort by 30 - 50% through automated enforcement of best practices, freeing time for higher-value feature work while improving code consistency and reliability.

• What if you shifted from measuring your progress by code output to evaluating the quality of your prompts, tests, and design decisions?

  • Move: For every feature or refactor, document your initial prompt to AI, the test cases you wrote, and the design trade-offs considered - then review this "development package" weekly to assess growth and decision-making.
  • Why Now?: Traditional metrics (commits, lines of code) are obsolete in the AI era; what matters now is judgment, specification, and validation - skills that compound over time and differentiate valuable solo operators.
  • Expected Upside: Develop stronger engineering taste and avoid AI-induced bloat; improve feature success rate by focusing on problem framing and validation, leading to more reliable, maintainable software with fewer regressions.

• What if you treated your personal codebase like Google's monorepo by implementing readability reviews and mandatory testing for all changes - even as a solo developer?

  • Move: Create a personal "readability checklist" for your stack (e.g., naming, error handling, comments) and enforce it via AI-powered lint rules. Automate test generation for every PR and block merges without passing tests.
  • Why Now?: Legacy code fear and technical debt scale with complexity; establishing sustainable habits early prevents future paralysis - especially as AI enables faster, riskier code generation.
  • Expected Upside: Achieve long-term codebase sustainability: safely evolve systems over years, reduce debugging time by 40%, and maintain confidence in making changes - turning your solo project into a durable, adaptable asset.

• Implement automated testing as a non-negotiable gate for all code changes to prevent regressions and enable safe refactoring.
• Adopt a readability or style review process for code contributions to enforce consistency, improve maintainability, and accelerate onboarding.
• Use deterministic refactoring tools (e.g., Clang/LLVM, OpenRewrite) with AST parsing to safely automate large-scale code changes instead of relying on manual edits.
• Shift focus from raw code output to high-value impact by measuring engineering success through strategic outcomes like feature value, efficiency gains, or innovation.
• Design projects and learning around real-world problems first, then teach underlying theory - avoid isolated, artificial exercises like reimplementing basic data structures.