Home

Introduction to Modern Software Engineering in the Age of Generative AI

October 2025 (1386 Words, 8 Minutes)

software-engineering ai automation github vscode python astral tools

Software Engineering Course

Getting to Know Each Other

Before we dive into the course content, we’d like to understand your current experience with software development. This helps us tailor the lectures to your needs and track our collective learning progress throughout the semester.

Please take 5 minutes to complete this anonymous survey:

đź“‹ Take the Software Development Skills Survey

Your responses are completely anonymous and will help us understand the class’s baseline knowledge in areas like version control, programming languages, development tools, and AI-assisted coding.

Introduction

The following ideas are adapted from the textbook Software Engineering at Google (O’Reilly).
They highlight how Google frames the distinction between programming and software engineering,
and introduce key principles for thinking about software as something that must endure and evolve over time.

Programming vs. Software Engineering

In everyday language, people often use programming and software engineering as if they mean the same thing. But there’s an important difference:

The “real thing” software engineers create isn’t a bridge or an airplane, but rather software systems that people depend on. While less tangible, these systems still require the same disciplined approach and responsibility that other engineering professions demand.

Software Engineering as Programming Over Time

Software engineering is more than just writing code—it’s about everything an organization does to build, maintain, and evolve that code over time. Writing the first version of a program is often the easy part. The real challenge comes later: keeping it useful, sustainable, and adaptable as technology and requirements change.

A helpful way to think about software engineering is as “programming integrated over time.” This perspective reminds us that software has a life cycle: from its first conception, through active use and maintenance, and eventually to retirement. The central question becomes: What practices allow software to survive and stay valuable throughout that cycle?

Three guiding principles help shape this mindset:

By focusing on these principles, software engineering becomes less about quick fixes and more about creating systems that are robust, adaptable, and maintainable in the long run.

The New Paradigm: AI-Assisted Development

Welcome to our first lecture on modern software engineering! Today we’ll explore how the landscape of software development has been transformed by generative AI and automation tools, fundamentally changing how we build, test, and deploy software.

The software engineering field has experienced a revolutionary shift with the advent of generative AI. We’re no longer just writing code; we’re orchestrating intelligent systems that help us think, design, and implement solutions more effectively.

Key Principles of Modern Software Engineering

  1. AI-Human Collaboration: Leveraging AI as a coding partner, not a replacement
  2. Automation-First Mindset: Automating repetitive tasks from day one
  3. Rapid Iteration: Faster feedback cycles through intelligent tooling
  4. Quality Assurance: AI-powered testing and code review
  5. Continuous Learning: Tools that adapt and improve with usage

Essential Modern Tools Ecosystem

Version Control & Collaboration: GitHub

GitHub has evolved far beyond simple version control:

# Example GitHub Action for Python project
name: CI/CD Pipeline
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up uv
        uses: astral-sh/setup-uv@v4
        with:
          enable-cache: true
      - name: Set up Python
        run: uv python install 3.12
      - name: Install dependencies
        run: uv sync
      - name: Run tests
        run: uv run pytest

Development Environment: VS Code + Extensions

Visual Studio Code has become the de facto standard, enhanced by:

Python Development: The Astral Revolution

The Python ecosystem has been revolutionized by Astral’s tools:

uv - Ultra-fast Python Package Manager

# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create new project
uv init my-project
cd my-project

# Add dependencies
uv add requests pandas numpy

# Run scripts
uv run main.py

Ruff - Lightning-fast Python Linter and Formatter

# pyproject.toml
[tool.ruff]
line-length = 88
target-version = "py311"

[tool.ruff.lint]
select = ["E", "F", "UP", "B", "SIM", "I"]

Key Benefits of Astral Tools

Modern Development Workflow

flowchart TD A[Idea] --> B[GitHub Issue] B --> C[VS Code + Copilot] C --> D[Local Development] D --> E[Ruff Linting] E --> F[Git Commit] F --> G[GitHub Push] G --> H[GitHub Actions] H --> I[Testing] I --> J[Deployment]

Automation Examples in Practice

Automated Code Quality

# .github/workflows/quality.yml
name: Code Quality
on: [push, pull_request]
jobs:
  quality:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up uv
        uses: astral-sh/setup-uv@v4
        with:
          enable-cache: true
      - name: Lint with Ruff
        run: uv run ruff check .
      - name: Format check
        run: uv run ruff format --check .
      - name: Type check with Pyright
        run: uv run pyright

Automated Documentation

# Using AI to generate docstrings
def calculate_performance_metrics(data: pd.DataFrame) -> dict:
    """
    Calculate key performance metrics from time series data.
    
    Args:
        data: DataFrame containing timestamp and value columns
        
    Returns:
        Dictionary containing calculated metrics including mean, std, etc.
    """
    # Implementation with Copilot assistance
    pass

The AI-First Development Process

  1. Problem Definition: Use AI to refine requirements and user stories
  2. Architecture Design: Leverage AI for system design suggestions
  3. Code Generation: Copilot assists with implementation
  4. Testing: AI-generated test cases and edge case identification
  5. Documentation: Automated documentation generation
  6. Deployment: AI-optimized CI/CD pipelines
  7. Monitoring: Intelligent alerting and performance analysis

Best Practices for AI-Assisted Development

Prompt Engineering for Developers

Tool Integration Strategy

# Modern Python project setup
uv init software-engineering-demo
cd software-engineering-demo

# Add development dependencies
uv add --dev pytest pyright ruff

# Configure VS Code settings
echo '{"python.defaultInterpreterPath": ".venv/bin/python"}' > .vscode/settings.json

Automation Checklist

Practical Exercise

For next class, set up a modern Python development environment:

  1. Install uv and set up a new project
  2. Configure VS Code with GitHub Copilot
  3. Set up a GitHub repository with Actions
  4. Create a simple Python application with automated testing
  5. Use Ruff for code formatting and linting

Summary

Modern software engineering is characterized by:

The tools we’ve discussed—GitHub, VS Code, Copilot, and Astral’s Python toolchain—represent the new standard for professional software development. Mastering these tools and understanding how to leverage AI assistance effectively will be crucial for your success as a modern software engineer.

© 2026 Dominik Mueller   •  Powered by Soopr   •  Theme  Moonwalk