Lecture 38 — Programming: How AI is Changing Software Development

Part 1 (20 minutes): Fundamental Understanding — Analogy and Overview

Time: ~20 minutes

In recent years, large language models that were also trained on program code have produced tools that directly assist programmers while they write. Two widely known examples are GitHub Copilot, a convenient editor plugin that offers code completions, and OpenAI's Codex, which provides the model basis for many automatic code functions. These offerings are often described in technical debates as "intelligent autocompletion" or as a "virtual pair programmer" [2], [1]. DeepMind's AlphaCode has further shown that large models can, in some cases, generate complete solution approaches for algorithmically defined tasks [3].

A useful analogy is: AI-assisted development tools today are like much more powerful versions of autocompletion in text applications. A conventional autocomplete suggests single words; modern systems attempt to provide entire functions, comments, or tests. Unlike a compiler, which formally verifies the behavior of already written code, the AI often provides suggestions based on patterns it learned from training data. The result is a mix of assistance and uncertainty: the suggestions can be very helpful, but also incomplete or incorrect.

Practical examples: Developers can get a function formulated from a short natural-language description, translate an existing function into another programming language, or receive suggestions for unit tests. Tools for automated test generation already existed before LLMs; one research example is EvoSuite, which automatically generates tests for Java classes and shows that automated test production is not an entirely new topic, although it is expanded by modern AI [5].

It is important that these tools do not autonomously take responsibility for planning and operating complete software systems. They provide suggestions and automate subtasks, but responsibility for system architecture, requirements, integration, security, and legal issues remains with humans. In the following sections we go into more detail about which tasks AI can take on today, which skills remain central for people, and how the programmer's profession is concretely changing.

Part 2 (20 minutes): Technical Terms, Mechanics and Effects on Development Tasks

Time: ~20 minutes

To contextualize the changes in practice, we introduce some terms relevant to software development and explain their meaning in the context of AI-assisted tools. "Program synthesis" denotes the automatic generation of program code from a description; modern LLM-based offerings are practical forms of this idea, but not formal specification-based synthesizers in the classical sense. "Code completion" refers to adaptive suggestions while typing; "code translation" denotes transforming existing implementations into another programming language. "Test automation" includes tools that generate or execute test cases, and can be driven either by classical search-based methods or by data-driven models [5].

Additionally, two distinctions are important: first, the separation between "generative" and "analytical" tasks. Generative tasks include producing code or comments; analytical tasks include static analysis, linting, performance diagnosis, and the like. Modern AI tools are often stronger at generative tasks, while established tools continue to play an important role in formal analysis and performance measurement. Second, the trade-off between a "local" and a "global" view is relevant. Many AI suggestions are created based on a limited code snippet; global aspects such as architectural decisions, system boundaries, and long-term maintainability require human insight and often additional tools for holistic analysis (e.g., architecture dashboards, CI/CD pipelines, monitoring).

How do concrete tasks in projects change? In practice, the following patterns can be observed and are supported by evidence:

- Assistance with writing routines and boilerplate code: AI provides recurring constructs faster and can thus reduce routine work. GitHub Copilot is marketed and integrated into developer workflows precisely in this context [2].
- Help with problem localization and code comprehension: AI models can generate comments, explanations, and summaries that facilitate onboarding and understanding; however, the quality of these explanations is variable and requires validation by humans [1].
- Automatic creation of simple tests or test scaffolding: Tools for test generation exist both as research-driven solutions like EvoSuite and as new AI-based services; they reduce repetitive test work but do not replace developers' review of test coverage and quality [5].
- Support for programming contests or algorithmic tasks: AlphaCode demonstrated that large models can produce competitive code in some structured problem contexts; however, this is a special niche with clearly defined inputs and expected outputs [3].

From these changes arise requirements for human competencies: domain knowledge in software architecture, requirements analysis, problem domains, security, and legal frameworks remains central. These areas are described in established compilations of our professional knowledge, such as the Guide to the Software Engineering Body of Knowledge (SWEBOK), which systematizes software-engineering skills and responsibilities [4]. There, topics like requirements engineering, architecture design, quality assurance, and maintainability are anchored as core competencies — areas that AI today addresses at best in a supportive manner.

Technical skills alone are not sufficient: additional skills include prompt-based interaction with models, evaluation and validation of automatically generated artifacts, and knowledge of safe deployment (e.g., recognizing faulty or insecure suggestions). Moreover, tasks in tool integration grow: embedding AI services into CI/CD pipelines, monitoring AI outputs, and managing training or usage data are now part of modern development processes.

Part 3 (10 minutes): Concrete Applications, Limits and Three Small Thought Exercises

Time: ~10 minutes

Applications that are widely discussed or used in practice today include automated code completion in IDEs, generation of boilerplate, rapid prototype creation, code refactoring suggestions, proposals for unit tests, and assistance in translating APIs or languages. Industry examples are GitHub Copilot as an editor integration [2], OpenAI's Codex as a basis for code APIs [1], and research results showing that models can offer relevant solutions in structured contest environments (AlphaCode) [3].

Limits and risks are well documented and must be considered in deployment decisions. Models often produce faulty or insecure code; they offer suggestions based on probabilities, not on formal correctness. Additionally, licensing and copyright issues can arise if training data includes public code repositories; discussions around this are active and technically as well as legally complex. Furthermore, scale effects and production readiness are different levels: an intelligent completion is not the same as a fully tested, robust production module.

To consolidate what was learned, three short thought exercises for the seminar group:

1) Use and verification: You receive a suggested implementation of a sorting function from an AI tool. Describe in three steps how you would check the suggestion's quality before the code is merged into the main repository. Expected answer: test with edge cases, static analysis/code review, verification of performance and stability assumptions.

2) Responsibility: An AI tool suggests code that later leads to a security vulnerability. Which roles and processes in a typical software engineering team must be present to minimize such incidents? Expected answer: roles (maintainer, security reviewer), processes (code review, security scanning, CI tests), logging and post-mortem.

3) Cost-benefit trade-off: In which project phase is using an AI code tool most effective — prototyping, feature development, maintenance — and why? Expected answer: prototyping and boilerplate often offer high benefit at low risk; caution is advised for safety-critical production paths.

In conclusion: AI changes developers' daily tools and automates parts of routine work. Core responsibility for system design, requirements, quality, and security remains largely human. Institutional knowledge, methodological discipline, and the ability to critically assess AI outputs will become central skills in the profession. Perceptions and attitudes toward the technology continue to evolve; initial surveys show broad interest in such tools within the developer community, while there are clear expectations regarding control and responsibility [6].