logo
QCon San Francisco 2025

Fundamentals of Software Engineering in the Age of AI

•1:00 PM PST
3 hours
Seacliff CD, Hyatt Regency San Francisco
5 Embarcadero Center, San Francisco, CA 94111
Register for Workshop

About This Workshop

This intensive workshop bridges fundamental programming skills with the expertise needed to work alongside AI tools. Participants engage in a balanced mix of conceptual teaching and hands-on exercises combining traditional and AI-assisted approaches to reinforce practical software engineering principles.

Learn to transition from programmer to software engineer, create maintainable code, and master AI code assistance while critically evaluating outputs. Through hands-on mini-workshops, you'll gain practical experience with modern development workflows and build a professional growth roadmap in the AI era.

What You'll Learn

  • Transition from programmer to software engineer mindset

  • Create maintainable, readable code communicating clear intent

  • Apply effective legacy codebase management techniques

  • Master AI code assistance while critically evaluating outputs

  • Apply architecture patterns appropriately

  • Build professional growth roadmap in the AI era

Prerequisites

To get the most out of this workshop, please ensure you have:

  • Working knowledge of at least one programming language

  • Basic understanding of software development concepts

  • Laptop with code editor and Git installed

  • Optional: Access to an AI coding assistant (Claude Code, GitHub Copilot, ChatGPT, or similar) for the AI-Assisted Feature Development mini workshop

Mini Workshops

This workshop is structured as a series of focused, hands-on mini-workshops, each exploring a different aspect of modern software engineering.

Reading Code & Exploring Unfamiliar Codebases

15 minutes

In this hands-on exercise, you'll explore the Spring PetClinic application, a real-world codebase that may be in a language you've never used before. This is intentional! We'll practice the fundamental skill of reading and understanding unfamiliar code, a critical ability for every software engineer.

Repository

https://github.com/spring-projects/spring-petclinic

Clone the repository:

git clone https://github.com/spring-projects/spring-petclinic

Important: No AI Tools for This Exercise

Please do not use AI assistants (ChatGPT, GitHub Copilot, etc.) for this exercise. We want to develop the fundamental skill of reading code and exploring unfamiliar codebases first. Once you've built this foundation, you'll be able to use AI to amplify this skill effectively.

Initial Orientation

  • •Identify the tech stack: Without running the app, what technologies/frameworks can you identify from project files (pom.xml, package structure)?
  • •Find the entry point: Locate the main application class. What annotations do you see?
  • •Map the architecture: Based on folder structure alone, what architectural pattern does this app follow?

Code Navigation

  • •Follow a user journey: Pick one entity (like "Owner" or "Pet") and trace it through the codebase - find its model, repository, service, and controller
  • •Understand the data model: Without looking at documentation, can you sketch the database schema based on the entity classes?
  • •Find the database configuration: Where and how is the database configured?

Pattern Recognition

  • •Identify design patterns: Find examples of patterns being used (Repository, MVC, dependency injection)
  • •Spot the conventions: What naming conventions do you notice for classes, methods, and packages?
  • •Mystery endpoint: Given a URL like /owners/{ownerId}/pets/new, trace what happens when someone submits the form

Reflection

  • •What made this codebase easier or harder to understand?
  • •What strategies did you use to navigate the code?
  • •How long did it take to understand the basic flow?
  • •What could you apply to your own projects?

Building a Personal Technology Radar

10 minutes

Learn to create your own technology radar, a powerful tool for tracking and categorizing technologies, tools, and frameworks to guide your learning journey and career development. Discover how to organize your technical landscape into actionable categories and build a roadmap for continuous skill growth.

The Four Rings

  • •Adopt: Technologies you're currently using and mastering, your core competencies
  • •Trial: Technologies you're actively learning or experimenting with - in active development
  • •Assess: Technologies you're researching but haven't started learning - on your radar
  • •Hold: Technologies you've decided not to pursue right now - documented decisions

Exploring Thoughtworks Tech Radar

  • •Visit the official Thoughtworks Technology Radar: https://www.thoughtworks.com/radar
  • •Notice how technologies move between rings over time as they mature or decline
  • •Pay attention to technologies in your domain or areas of interest
  • •Reflection: What patterns do you notice? What technologies appear in "Adopt" vs "Hold"?

Building Your Own Radar (Hands-On)

  • •Important: There are no wrong answers here! This is YOUR personal technology radar - it should reflect your unique interests, goals, and current skill level.
  • •List 5-10 technologies you know or want to learn. You can use a spreadsheet, paper, or any format that works for you
  • •For each technology, capture: Name, Ring (Adopt/Trial/Assess/Hold), Quadrant, and a brief description
  • •Example entries: React (Adopt, Languages & Frameworks), Docker (Trial, Tools), Rust (Assess, Languages & Frameworks)
  • •Optional: Use the Thoughtworks Build Your Own Radar tool at https://radar.thoughtworks.com to create an interactive visualization
  • •The visualization tool requires a CSV or Google Sheet with columns: name, ring, quadrant, isNew, description

Tips for Success

  • •Start small: 5-10 technologies is perfect for your first radar
  • •Be honest: Place technologies where YOU are with them, not where the industry is
  • •Mix categories: Use different quadrants to show breadth across your skill set
  • •Mark new discoveries: Use isNew=TRUE for technologies you recently discovered
  • •Review quarterly: Set a reminder to update your radar as your interests and skills evolve
  • •Combine with your career roadmap: Use your radar to guide learning priorities
  • •Share with mentors: Your radar can spark valuable discussions about your career path

Helpful Resources

AI-Assisted Feature Development

10 minutes

Transform how you approach new features by leveraging AI as a collaborative partner, not just a code generator. This hands-on session teaches you to think systematically about feature development while using AI tools effectively.

Repository

https://github.com/spring-projects/spring-petclinic

Clone the repository:

git clone https://github.com/spring-projects/spring-petclinic

Prerequisites

  • •Access to an AI coding assistant (Claude Code, GitHub Copilot, ChatGPT, or similar)
  • •Git and your preferred code editor installed
  • •Basic familiarity with web applications (any language/framework)
  • •Clone the Spring Pet Clinic repository: git clone https://github.com/spring-projects/spring-petclinic

Part 1: Exploring the Unknown

  • •Using your AI assistant, ask strategic questions to understand the Spring Pet Clinic codebase
  • •What types of questions help you understand architecture vs. implementation details?
  • •Practice asking: "How is data persistence handled?" vs. "Show me the Owner entity"
  • •Experiment with different question styles: high-level overview vs. specific code locations
  • •Compare AI-assisted exploration with your manual exploration from the previous workshop
  • •Reflection: What did AI help you discover faster? What did manual exploration teach you better?

Part 2: Planning Mode - Weight Tracking Feature

  • •Start with this prompt: "Add an optional weight field (in kg) to pets so we can track their health over time"
  • •Evaluate the AI's initial plan - what assumptions did it make?
  • •Iterate on requirements: "What edge cases should we consider for weight tracking?"
  • •Ask architectural questions: "Should we maintain weight history or just current weight?"
  • •Explore data modeling: "Should weight be nullable for existing pets?"
  • •Consider API impact: "How does this affect our API contracts?"
  • •Discuss implementation strategy: "What's the migration order for existing data?"
  • •Risk assessment: "What could break with this change? How do we ensure backward compatibility?"

Part 3: Critical Evaluation & Iteration

  • •Review the AI's suggested implementation plan with a critical eye
  • •Challenge assumptions: Does the proposed solution handle all edge cases?
  • •Ask follow-up questions to refine the approach
  • •Request alternative approaches: "What are other ways to implement weight history?"
  • •Discuss testing strategy: "How should we test this feature?"
  • •Consider user experience: "How should the UI handle weight entry and display?"
  • •Reflection: How did asking strategic questions improve the final plan?
  • •Key takeaway: AI is most valuable when you guide it with thoughtful questions

Resources

Here are some helpful resources to prepare for the workshop and continue learning afterward:

Fundamentals of Software Engineering Book

Workshop Slides (PDF)

Fundamentals of Software Engineering GitHub Organization

QCon Workshop Registration

Ready to Level Up Your Skills?

Join us for this hands-on workshop and discover how to apply software engineering fundamentals in the age of AI.

Register Now