Entwicklerausbildung und -bewertung im Zeitalter der Agenten

Entwicklerausbildung und -bewertung im Zeitalter der Agenten

Diese Analyse spiegelt die Landschaft der Ausbildung und Zertifizierung vom 26. Juli 2026 wider.

Einleitung

Autonome Coding-Agenten verändern die Softwareentwicklung von einer Aufgabe, die sich auf das Schreiben von Code konzentriert, zu einer, die sich auf das Spezifizieren von Aufgaben, das Delegieren von Tätigkeiten, die Überwachung der Ausführung und die Überprüfung der Ergebnisse konzentriert.

Moderne Coding-Agenten können ein Repository überprüfen, einen Implementierungsplan entwickeln, mehrere Dateien ändern, Tests ausführen, auf Fehler reagieren und einen Pull Request zur menschlichen Überprüfung öffnen. Die aktuelle Dokumentation von GitHub beschreibt Workflows, in denen Entwickler Agenten Aufgaben zuweisen, deren Arbeit überwachen, Code-Reviews anfordern, Feedback geben und das Ergebnis genehmigen oder ablehnen. (docs.github.com)

Dies wirft eine schwierige Frage für die Ausbildung auf:

Wenn ein Student einen Agenten bitten kann, ein funktionierendes Programm zu erstellen, was sollte der Student dann verstehen müssen?

Die Antwort ist nicht, die Grundlagen der Programmierung aufzugeben. Es geht darum, wofür diese Grundlagen verwendet werden.

Studenten müssen immer noch Datenstrukturen, Algorithmen, Programmiersprachen, Systemdesign, Sicherheit, Tests und Debugging verstehen. Dieses Wissen müssen sie jedoch zunehmend anwenden, um:

• Mehrdeutige Probleme in überschaubare Aufgaben zu zerlegen
• Präzise Spezifikationen und Akzeptanzkriterien zu schreiben
• Nützlichen Kontext für Coding-Agenten bereitzustellen
• Beurteilen, ob generierter Code korrekt und wartbar ist
• Tests zu entwerfen, die versteckte Fehler aufdecken
• Sicherheits-, Datenschutz-, Performance- und Architekturrisiken zu überprüfen
• Mehrere Agenten oder Tools zu koordinieren, ohne die Kontrolle zu verlieren
• Technische Entscheidungen zu erklären und zu verteidigen

Die nächste Generation der Entwicklerausbildung wird daher weniger die Fähigkeit des Studenten beurteilen, große Mengen an Code zu produzieren, sondern mehr die Fähigkeit des Studenten, Softwaresysteme zu verstehen, zu leiten, zu verifizieren und zu verbessern.

Die zentrale Verschiebung: Von der Code-Produktion zum technischen Urteilsvermögen

Coding-Agenten sind nicht einfach nur eine schnellere Autovervollständigung

Traditionelle Coding-Assistenten schlagen eine Zeile, Funktion oder einen kleinen Codeblock vor. Autonome Coding-Agenten arbeiten in einem größeren Maßstab. Sie können dateiübergreifend arbeiten, Entwicklungstools aufrufen, Tests ausführen, Dokumentationen prüfen und mehrere Schritte durchlaufen.

Das verändert die Arbeitseinheit. Der Workflow des Entwicklers sieht zunehmend so aus:

1. Das Benutzer- oder Geschäftsproblem verstehen.
2. Das gewünschte Verhalten definieren.
3. Die Arbeit in kleinere Aufgaben zerlegen.
4. Eine geeignete Aufgabe einem Agenten zuweisen.
5. Den Plan des Agenten überprüfen.
6. Den Agenten in einer kontrollierten Umgebung implementieren lassen.
7. Tests und Sicherheitsüberprüfungen durchführen.
8. Das Ergebnis überprüfen.
9. Änderungen anfordern oder das Design überarbeiten.
10. Die Software genehmigen, zusammenführen und überwachen.

Die Person, die die Planungs- und Überprüfungsphasen überspringt, kann immer noch Code produzieren, aber kein zuverlässiges, vertrauenswürdiges Produkt erstellen.

Die Grenzen der reinen Code-Ausgabe

Die reine Code-Produktion wird zu einem schwächeren Maßstab für Fähigkeiten, da ein Agent schnell eine große Menge plausiblen Codes generieren kann. Gleichzeitig haben Agenten weiterhin Schwierigkeiten mit der langfristigen Softwareentwicklung, dateiübergreifenden Änderungen, unklaren Anforderungen und der Aufrechterhaltung des Verhaltens über wiederholte Änderungen hinweg. Eine Benchmark-Studie aus dem Jahr 2025 stellte eine erhebliche Lücke zwischen der Agentenleistung bei der isolierten Problembehebung und komplexeren, langfristigen Softwareentwicklungsaufgaben fest. (arxiv.org)

Dies schafft eine wichtige pädagogische Unterscheidung:

• Ein Student, der Code generieren kann, versteht ihn möglicherweise nicht.
• Ein Student, der Code erklären, testen, hinterfragen und reparieren kann, beweist tiefere Kompetenz.

Das Bildungsziel sollte daher ein validiertes Software-Urteilsvermögen sein, nicht bloß eine erfolgreiche Codegenerierung.

Wie sich Lehrpläne anpassen

Universitätslehrpläne bewegen sich hin zu Verständnis und Verifikation

Der Bericht „Computer Science Curricula 2023“ der ACM, des Institute of Electrical and Electronics Engineers Computer Society und der Association for the Advancement of Artificial Intelligence ging davon aus, dass generative künstliche Intelligenz die Programmierausbildung verändern würde. Seine Empfehlungen legen nahe, dass Studenten einen stärkeren Schwerpunkt auf das Lesen, Verstehen, Verifizieren, Bearbeiten, Modifizieren, Anpassen und Testen von Code legen müssen. Er identifiziert auch die Problemzerlegung als einen Bereich, der voraussichtlich an Bedeutung gewinnen wird. (csed.acm.org)

Dieselbe Leitlinie weist auf einen entscheidenden Punkt hin: Auch wenn ein Agent das Programm schreibt, bleibt der Mensch dafür verantwortlich, zu bestimmen, ob das Programm korrekt ist. Das bedeutet, dass die Programmierausbildung nicht auf das Schreiben von Prompts reduziert werden kann. Studenten benötigen ausreichend technisches Verständnis, um die Ausgabe bewerten zu können.

Der Bericht prognostiziert auch Änderungen in der Software-Engineering-Ausbildung, einschließlich einer stärkeren Nutzung von künstlicher Intelligenz für Codegenerierung, Debugging, statische Analyse und Code-Reviews. Eine effektive Nutzung dieser Tools erfordert stärkere, nicht schwächere Design- und Code-Verständnisfähigkeiten. (csed.acm.org)

Akkreditierung beginnt, breitere Ingenieurleistungen zu belohnen

Die aktuellen Akkreditierungskriterien für Informatikprogramme des Accreditation Board for Engineering and Technology (ABET) betonen bereits:

• Analyse komplexer Computerprobleme
• Entwurf und Bewertung von Computerlösungen
• Professionelle Kommunikation
• Rechtliche und ethische Verantwortung
• Sicherheit und Datenschutz
• Soziale Auswirkungen des Computereinsatzes
• Ein umfassendes Projekt oder eine erfahrungsbezogene Komponente (abet.org)

Diese Ergebnisse eignen sich gut für eine agentenbasierte Entwicklungsumgebung, da sie Urteilsvermögen und Verantwortung statt Tastenanschläge messen.

Stand 26. Juli 2026 umfassen die vorgeschlagenen Änderungen des Accreditation Board for Engineering and Technology für den Zyklus 2026–2027 zusätzliche Kriterien für KI-Programme und die Anforderung, dass Absolventen in der Lage sein müssen, Theorien, Modelle und Techniken der künstlichen Intelligenz auf komplexe Probleme anzuwenden. Die vorgeschlagenen Änderungen warteten noch auf die endgültige Verabschiedung und sollten nach der Herbstsitzung 2026 in Kraft treten, mit der ersten Anwendung während des Überprüfungszyklus 2027–2028. (abet.org)

Die wahrscheinliche Richtung ist klar: Programme müssen zeigen, dass Studenten Systeme bauen und bewerten können, nicht nur isolierte Programmierübungen abschließen.

Neue Kurse lehren den Agenteneinsatz als Ingenieurdisziplin

Mehrere aktuelle Universitätskurse illustrieren das aufkommende Muster.

Der Kurs der University of Maryland aus dem Jahr 2025 zum effektiven Einsatz von KI-Coding-Assistenten und Agenten behandelte Tools, die Build-Systeme aufrufen, Tests ausführen und Fehler beheben können. Er befasste sich auch mit Wartbarkeit, Architektur, API-Design, Effizienz, Skalierbarkeit, Sicherheit, Continuous Integration, Code-Reviews, asynchronen Agenten und automatisierten Code-Reviews. (cs.umd.edu)

Die University of Pennsylvania hat einen Informatik-Kurs auf Sophomore-Niveau vorgeschlagen, der sich auf KI-gesteuerte Softwareentwicklung konzentriert. Zu den vorgeschlagenen Themen gehören die Delegation von Coding-Aufgaben, modularer Entwurf, skalierbares Testen, Risikomanagement, Reproduzierbarkeit, Zusammenarbeit und Ethik. (seas.upenn.edu)

Der Kurs der University of Michigan vom Herbst 2026, Applied Agentic Software Engineering, ist noch expliziter. Er ist in drei Phasen gegliedert:

1. Coding-Agenten effektiv nutzen
2. Einen Agenten mit einer Large Language Model API bauen
3. Einen Agenten-Orchestrator entwerfen, evaluieren und bereitstellen

Der Kurs verwendet Projekte, Labore, Demonstrationen und Checkoffs anstelle traditioneller Prüfungen. Er besagt, dass die Benotung das Verständnis über die Ausgabe belohnt und verlangt von den Studenten, zu erklären, warum ein Agent versagt hat und wie das umgebende System repariert werden kann. (eecs498-aase.github.io)

Dies ist eine signifikante Designänderung. Der Kurs lehrt die Studenten nicht, Code schneller zu produzieren. Er lehrt sie, technische Vorgesetzte von Systemen zu werden, die Code produzieren.

Wie sich Bootcamps verändern

Bootcamps passen sich schneller an als viele traditionelle Programme, da ihre Lehrpläne eng an die Arbeitsanforderungen gekoppelt sind. Die Qualität der Anpassung variiert jedoch.

Das dedizierte Modell des KI-Softwareentwicklungs-Bootcamps

Le Wagons aktuelles Artificial Intelligence Software Development Bootcamp kombiniert Full-Stack-Entwicklung mit KI-Integration. Sein veröffentlichter Lehrplan umfasst KI-unterstütztes Coding, Large Language Model-Integration, Produktionsbereitstellung, Retrieval-Augmented Generation und autonome KI-Agenten. (lewagon.com)

Dieses Modell behandelt künstliche Intelligenz als einen roten Faden, der sich durch das Programm zieht, anstatt als eine einzelne optionale Lektion. Von den Studenten wird erwartet, dass sie beides lernen:

• Wie konventionelle Softwaresysteme funktionieren
• Wie man KI-Tools verwendet, um diese Systeme zu bauen und zu betreiben

Diese Kombination ist wichtig. Ein Lernender, der nur weiß, wie man einen Agenten bedient, ist möglicherweise nicht in der Lage, eine fehlerhafte Architektur zu erkennen. Ein Lernender, der nur die konventionelle Programmierung kennt, ist möglicherweise nicht auf moderne Entwicklungs-Workflows vorbereitet.

Das Modell „eine KI-Einheit hinzufügen“

Springboards Software-Engineering-Bootcamp behält ein konventionelles Fundament in Webentwicklung, APIs, Frontend-Entwicklung, Backend-Entwicklung und Full-Stack-Projekten bei und fügt eine KI-Einheit hinzu, die sich auf Prompt Engineering und die Zusammenarbeit mit generativen Tools konzentriert. (springboard.com)

Dieses Modell ist nützlich für Lernende, die zunächst starke Programmiergrundlagen benötigen. Es spiegelt auch eine praktische Realität wider: Viele Studenten sollten nicht damit beginnen, autonome Agenten zu entwickeln. Sie sollten zuerst lernen, wie Software funktioniert, wie man Versionskontrolle verwendet, wie man Fehlermeldungen liest und wie man ein Programm testet.

Die Schwäche ist, dass ein kurzes Prompt-Engineering-Modul zu oberflächlich werden kann. Ein ernsthaftes Curriculum für die Agenten-Ära sollte mehr lehren, als nur nach Code zu fragen. Es sollte lehren:

• Wie man eine Repository-Kontextdatei erstellt
• Wie man eine technische Spezifikation schreibt
• Wie man Aufgabengrenzen definiert
• Wie man die Berechtigungen eines Agenten einschränkt
• Wie man Agentenpläne überprüft
• Wie man generierte Tests bewertet
• Wie man Sicherheitsprobleme erkennt
• Wie man alternative Designs vergleicht
• Wie man die Beteiligung von Agenten dokumentiert

Worauf Bootcamp-Studenten achten sollten

Angehende Studenten sollten fragen, ob ein Programm Folgendes bewertet:

• Können Studenten Code erklären, den sie nicht persönlich eingegeben haben?
• Überprüfen und reparieren Studenten fehlerhafte Agenten-Ausgaben?
• Werden Tests, Sicherheit und Wartbarkeit bewertet?
• Gibt es eine Live-Demonstration oder eine technische Verteidigung?
• Pflegen Studenten eine versionskontrollierte Projekthistorie?
• Werden Studenten gelehrt, bei Bedarf ohne Agenten zu arbeiten?
• Lehrt das Programm Produktsuche und Anforderungsanalyse?
• Werden werkzeugspezifische Fähigkeiten mit dauerhaften Ingenieurprinzipien in Einklang gebracht?

Ein Programm, das „eine Anwendung in einer Woche mit künstlicher Intelligenz erstellen“ bewirbt, mag hervorragend für schnelles Prototyping sein, aber das ist nicht dasselbe, wie jemanden auf professionelles Software-Engineering vorzubereiten.

Wie sich Zertifizierungen anpassen

Zertifizierungsanbieter entwickeln drei breite Arten von Qualifikationen.

Werkzeugspezifische Wissenszertifizierungen

Die GitHub Copilot-Zertifizierung von Microsoft bewertet den verantwortungsvollen Einsatz, Copilot-Funktionen, Datenarchitektur, Kontext- und Prompt-Erstellung, Entwicklerproduktivität, Datenschutz, Inhaltsausschlüsse und Schutzmaßnahmen. Die Prüfung ist beaufsichtigt, dauert hundert Minuten und kann interaktive Komponenten enthalten. (learn.microsoft.com)

Diese Qualifikation erkennt nützliches Arbeitsplatzwissen an. Sie kann zeigen, dass eine Person versteht, wie eine bestimmte Entwicklungsplattform verantwortungsvoll genutzt wird.

Ihre Einschränkung besteht darin, dass sie stark an ein Produkt gebunden ist. Ein Fachmann, der GitHub Copilot bedienen kann, verfügt möglicherweise immer noch nicht über die Fähigkeit, eine komplexe Produktanforderung zu zerlegen, eine architektonische Entscheidung in Frage zu stellen oder eine sicherheitsempfindliche Änderung zu überprüfen.

Plattformbasierte KI-Entwicklungszertifizierungen

Die AWS Certified Generative AI Developer – Professional Zertifizierung ist breiter gefächert. Ihr Prüfungsleitfaden umfasst die Integration von Basismodellen, Datenmanagement, Compliance, Implementierung, agentenbasierte KI-Lösungen, Sicherheit, Governance, Tests, Fehlerbehebung, Überwachung und Optimierung. (docs.aws.amazon.com)

Die Prüfung ist jedoch primär Multiple-Choice und Multiple-Response. Sie ist ein umfangreicher Wissenstest, aber sie demonstriert nicht vollständig, ob ein Kandidat ein funktionierendes System bauen, überprüfen oder verteidigen kann. (aws.amazon.com)

Dies veranschaulicht ein größeres Problem: Wissenstests sind leichter zu skalieren als Leistungstests. Zertifizierungsorganisationen können Terminologie und Designprinzipien effizient testen, aber praktische Kompetenz erfordert eine Umgebung, in der Kandidaten Entscheidungen treffen und mit Fehlern umgehen müssen.

Laborbasierte und projektbasierte Qualifikationen

Microsoft Applied Skills-Qualifikationen bieten ein vielversprechenderes Modell. Sie erfordern von den Lernenden die Bearbeitung interaktiver Aufgaben, die auf reale Arbeiten abgestimmt sind, in einer laborbasierten Bewertung. Microsoft positioniert diese Qualifikationen als Beweis dafür, dass ein Kandidat echte Cloud- und KI-Herausforderungen lösen kann, anstatt lediglich Informationen abzurufen. (learn.microsoft.com)

Das Executive Education Agentic Artificial Intelligence Program der Carnegie Mellon University kombiniert Live-Unterricht, geführte Laborübungen, Aufgaben, Multi-Agenten-Workflows, Evaluierung, Schutzmechanismen, Logging, Observability und ein Abschlussprojekt. (execonline.cs.cmu.edu)

Diese Programme sind nicht identisch mit unabhängigen professionellen Zertifizierungen, aber sie zeigen die Richtung auf, die Qualifikationen wahrscheinlich einschlagen werden:

• Kürzere praktische Bewertungen
• Sandbox-Entwicklungsumgebungen
• Realistische Repositories
• Bewertungs- und Observability-Aufgaben
• Abschlusssysteme
• Mündliche oder aufgezeichnete technische Erklärungen
• Nachweis des verantwortungsvollen Werkzeugeinsatzes

Bewertungstechniken, die das Verständnis messen

Die beste Bewertungsstrategie verbietet Agenten nicht bei jeder Aufgabe. Sie setzt Agenten dort ein, wo sie die professionelle Praxis widerspiegeln, und behält einige Aktivitäten der Messung des unabhängigen Verständnisses vor.

1. Spezifikations- und Zerlegungsdokumente

Bevor Sie Code schreiben, fordern Sie von den Studenten die Einreichung von:

• Das Benutzerproblem
• Funktionale Anforderungen
• Nicht-funktionale Anforderungen
• Annahmen
• Einschränkungen
• Datenstrukturen
• Schnittstellen
• Akzeptanzkriterien
• Eine Aufgabenaufteilung
• Bekannte Risiken

Das Dokument sollte erklären, warum das Problem in bestimmte Aufgaben unterteilt wurde.

Dies misst, ob der Student das Problem versteht, bevor er einen Agenten bittet, es zu implementieren.

2. Agentenplanungs-Checkpoints

Fordern Sie von den Studenten, den vorgeschlagenen Plan des Agenten vor Beginn der Implementierung zu zeigen. Der Student muss Folgendes identifizieren:

• Welche Teile des Plans akzeptabel sind
• Welche Teile unvollständig sind
• Welche Annahmen unsicher sind
• Welche Aufgaben menschliche Genehmigung erfordern
• Welche Tests hinzugefügt werden sollten

Die Abschlussnote sollte die Qualität des Urteilsvermögens des Studenten belohnen, nicht die Länge des Agentenplans.

3. Code-Review-Bewertungen

Geben Sie den Studenten ein von einem Agenten generiertes Repository, das absichtliche Mängel enthält. Die Mängel können umfassen:

• Falsche Behandlung von Grenzfällen
• Unsichere Authentifizierung
• Schlechte Fehlerbehandlung
• Versteckte Performance-Probleme
• Duplizierte Logik
• Unklare Schnittstellen
• Unzureichende Tests
• Datenschutzverletzungen
• Abhängigkeitsrisiken

Bitten Sie die Studenten, eine Überprüfung mit Schweregraden, Nachweisen, vorgeschlagenen Korrekturen und Regressionstests zu erstellen.

Dies ist der professionellen Softwarearbeit näher als die Bitte an Studenten, eine weitere kleine Anwendung von Grund auf neu zu erstellen.

4. Erläuterungs- und mündliche Verteidigung

Ein Student sollte in der Lage sein zu erklären:

• Was das System tut
• Warum die Architektur gewählt wurde
• Welche Teile generiert wurden
• Welche Annahmen der Agent getroffen hat
• Wie die Tests die Korrektheit beweisen
• Was immer noch fehlschlagen könnte
• Welche Kompromisse akzeptiert wurden

Eine kurze mündliche Verteidigung kann einzeln oder in kleinen Gruppen durchgeführt werden. Sie muss nicht einschüchternd sein. Fünf bis zehn gezielte Fragen reichen oft aus, um zu zeigen, ob ein Student die Einreichung versteht.

5. Transferaufgaben

Nachdem ein Student ein agentengestütztes Projekt abgeschlossen hat, stellen Sie eine neue Anforderung bereit, die nicht durch einfaches Wiederholen des ursprünglichen Prompts gelöst werden kann.

Zum Beispiel:

• Eine neue Datenquelle hinzufügen
• Das Performance-Ziel ändern
• Ein unerwartetes Eingabeformat unterstützen
• Eine Abhängigkeit entfernen
• Zugriffskontrollen hinzufügen
• Einen fehlschlagenden Test erklären
• Ein Modul refaktorisieren, ohne sein Verhalten zu ändern

Der Student darf einen Agenten verwenden, muss aber den Plan erklären, die Änderungen verifizieren und das Ergebnis verteidigen.

Transferaufgaben messen, ob der Student eine allgemeine Methode gelernt hat, anstatt eine erfolgreiche Interaktion auswendig zu lernen.

6. Testdesign und Adversarial Testing

Studenten sollten für die Qualität ihrer Tests benotet werden, nicht nur dafür, ob der generierte Code die bereitgestellten Tests besteht.

Nützliche Anforderungen umfassen:

• Grenztests schreiben
• Negative Tests erstellen
• Ungültige Eingaben testen
• Fehlerbehebung testen
• Performance-Annahmen überprüfen
• Property-based Tests verwenden, wo angemessen
• Sicherheitsempfindliches Verhalten testen
• Erklären, was ungetestet bleibt

Die Schlüsselfrage ist nicht „Hat der Code bestanden?“, sondern „Wusste der Student, was getestet werden musste?“

7. Versionshistorie und Prozessportfolios

Ein Projektportfolio kann umfassen:

• Ursprüngliche Spezifikation
• Aufgabenzerlegung
• Agentenpläne
• Wichtige Prompts oder Anweisungen
• Commits
• Testergebnisse
• Review-Kommentare
• Fehlgeschlagene Ansätze
• Designänderungen
• Abschließende Reflexion

Ein Prozessportfolio sollte nicht zur Anforderung werden, jede Zeile privater Konversation einzureichen. Eine repräsentative Aufzeichnung ist oft nützlicher als ein riesiges Transkript.

Prinztons Programmierkurs aus dem Jahr 2025 erlaubte beispielsweise generative KI-Tools, verlangte jedoch von den Studenten, deren Verwendung in einer Readme-Datei durch eine repräsentative Zusammenfassung statt eines ausführlichen Transkripts zu beschreiben. (cs.princeton.edu)

8. Strukturierte Peer-Review

Peer-Review verwandelt Studenten von reinen Code-Produzenten in Code-Kritiker. Erste Forschungsergebnisse deuten darauf hin, dass eine rubrikbasierte Peer-Bewertung die Dozentenbewertung mit moderater Genauigkeit annähern kann, während sie gleichzeitig evaluatives Denken und Engagement fördert. (arxiv.org)

Studenten sollten aufgefordert werden, ihre Kommentare mit Beweisen zu begründen. „Dieser Code ist schlecht“ ist keine Überprüfung. „Diese Funktion führt eine Datenbankabfrage innerhalb einer Schleife aus, was bei zunehmender Sammlung wahrscheinlich zu einem Performance-Problem führt“ ist eine Überprüfung.

9. Prompt- und Spezifikationsprobleme

Prompt Problems sind Programmierübungen, bei denen Studenten natürlichsprachliche Anweisungen schreiben, die ein KI-System dazu veranlassen, Code zu generieren, der eine Spezifikation erfüllt. Der Ansatz lehrt Studenten explizit, Rechenanforderungen an codegenerierende Systeme zu kommunizieren. (arxiv.org)

Dies kann nützlich sein, sollte aber nicht die einzige Bewertungsmethode sein. Eine Studie aus dem Jahr 2026 mit über neunhundert Studenten ergab, dass häufige Fehler das Weglassen wichtiger Details aus Prompts waren. Wenn generierter Code fehlschlug, konzentrierten sich die Studenten oft darauf, ihre Absicht zu klären, anstatt den Code zu verfolgen oder Testfälle zu untersuchen. (arxiv.org)

Prompting kann daher Zerlegungs- und Kommunikationsfähigkeiten offenbaren, muss aber mit Code-Lesen, Testen, Debugging und Überprüfung kombiniert werden.

Eine Beispiel-Bewertungsstruktur

Ein praktisches Projekt könnte die folgende Gewichtung verwenden:

Diese Struktur belohnt immer noch ein funktionierendes Produkt, verhindert aber, dass ein Student eine hohe Note erhält, nur weil ein Agent eine große Codebasis produziert hat.

Akademische Integrität in agentengestützten Studienleistungen

Pauschalverbote und uneingeschränkte Nutzung sind beide unzureichend

Ein Pauschalverbot kann für eine spezifische grundlegende Bewertung angemessen sein, insbesondere wenn das Lernziel die unabhängige Programmierpraxis ist. Ein universelles Verbot ist jedoch zunehmend schwierig durchzusetzen und kann Studenten daran hindern, Werkzeuge zu erlernen, denen sie in ihrer beruflichen Praxis begegnen werden.

Auch eine uneingeschränkte Nutzung ist unzureichend. Wenn Studenten von Agenten erstellte Arbeiten ohne Erklärung einreichen können, misst die Bewertung möglicherweise den Zugang zu einem Werkzeug und nicht das Lernen.

Der stärkste Ansatz ist eine explizite, auf die Aufgabe bezogene Richtlinie.

Drei nützliche Richtlinienmodi

Modus eins: Agent verboten

Verwenden Sie dies für:

• Prüfungen
• Grundlegende Programmierübungen
• Individuelle Debugging-Demonstrationen
• Kern-Algorithmus-Übungen
• Bewertungen, die darauf abzielen, ununterstützte Abrufe oder Implementierungen zu messen

Der Kurs „Principles of Imperative Computation“ der Carnegie Mellon University verbietet KI-Tools für jeden Teil benoteter Arbeiten, einschließlich der Generierung von Lösungen, der Erklärung von Lösungen, der Code-Formatierung und der Generierung von Testfällen. (cs.cmu.edu)

Modus zwei: Agent eingeschränkt

Verwenden Sie dies, wenn Studenten nach Folgendem fragen dürfen:

• Konzepterklärungen
• Dokumentationshilfe
• Interpretation von Fehlermeldungen
• Klärung von Bibliotheken oder APIs
• Brainstorming
• Kritik an einem von Studenten erstellten Design
• Kleinere Refaktorierungen

Carnegie Mellon Systemkurse erlauben KI-Tools zum Verständnis von APIs, Bibliotheken, Frameworks, bereitgestelltem Code und Fehlermeldungen, verbieten jedoch Anfragen nach teilweisen oder vollständigen Aufgabenlösungen. (cs.cmu.edu)

Modus drei: Agent erlaubt mit Offenlegung

Verwenden Sie dies für realistische Software-Engineering-Projekte. Verlangen Sie von den Studenten, Folgendes offenzulegen:

• Welche Tools verwendet wurden
• Welche Aufgaben delegiert wurden
• Ob generierter Code kopiert, geändert oder neu geschrieben wurde
• Wie die Ausgabe getestet wurde
• Was der Student gelernt hat
• Welche Teile des Designs in der Verantwortung des Studenten bleiben

Prinztons Leitlinie zur wissenschaftlichen Integrität besagt, dass eine erlaubte Nutzung von künstlicher Intelligenz dennoch offengelegt werden muss und dass die Darstellung generierter Ausgaben als eigene oder das Versäumnis, deren Nutzung offenzulegen, einen Integritätsverstoß darstellen kann. (scholarlyintegrity.princeton.edu)

Die Harvard Graduate School of Education erlaubt ebenfalls Verwendungen wie Klärung, Brainstorming und Erkundung, verbietet den Studenten jedoch, KI-generierte Studienleistungen als ihre eigenen einzureichen. Sie verlangt auch die Dokumentation der erlaubten Nutzung und warnt, dass die Studenten für Genauigkeit, Datenschutz, Urheberrecht und Voreingenommenheit verantwortlich bleiben. (registrar.gse.harvard.edu)

Eine praktische Offenlegungserklärung

Ein Kurs kann eine einfache Vorlage bereitstellen:

Ich habe [Toolname] für [Planung, Debugging, Codegenerierung, Testen, Dokumentation oder Überprüfung] verwendet. Ich habe [spezifische Aufgaben] delegiert. Ich habe die Ausgabe überprüft und geändert, das resultierende System getestet und bleibe für die Genauigkeit, Sicherheit und Originalität der Einreichung verantwortlich.

Studenten sollten nicht verpflichtet sein, gewöhnliche Rechtschreibkorrekturen in derselben Weise offenzulegen wie delegierte Implementierungen. Richtlinien sollten zwischen geringfügiger Unterstützung und wesentlichem kognitiven oder technischen Beitrag unterscheiden.

Datenschutz und Chancengleichheit

Institutionen sollten zugelassene Tools oder Alternativen bereitstellen. Studenten sollten nicht verpflichtet werden, vertrauliche Kursarbeiten, persönliche Informationen, unveröffentlichte Forschung oder proprietären Code in öffentliche Systeme hochzuladen.

Die UNESCO-Leitlinie fordert einen menschenzentrierten Ansatz, der Datenschutz, Sicherheit, Gerechtigkeit, Inklusion und institutionelle Bereitschaft berücksichtigt. (unesco.org)

Kurse sollten auch Studenten berücksichtigen, die sich keine mehreren kostenpflichtigen Tools leisten können. Ein fairer Kurs kann:

• Ein gemeinsames institutionelles Tool bereitstellen
• Eine lokale oder Open-Source-Alternative anbieten
• Aufgaben so gestalten, dass sie nicht von einem einzigen Anbieter abhängen
• Das Denken und nicht den Zugang zum leistungsstärksten Modell benoten
• Nicht-Agenten-Pfade für jedes wesentliche Lernziel zulassen

Praktische Methoden zur produktiven Integration von Agenten

Ein kontrolliertes Repository verwenden

Geben Sie den Studenten ein Repository, das Folgendes enthält:

• Eine klare Readme-Datei
• Eine kleine, aber realistische Codebasis
• Automatisierte Tests
• Einen Continuous-Integration-Workflow
• Eine Liste bekannter Probleme
• Einen Styleguide
• Eine Sicherheits-Checkliste
• Ein Änderungslog

Dies macht den Agenteneinsatz beobachtbar und gibt den Studenten etwas Realistischeres als eine leere Coding-Übung.

Vor der Implementierung einen Plan verlangen

Studenten sollten nicht damit beginnen, einen Agenten zu bitten, „die gesamte Anwendung zu bauen“. Verlangen Sie eine Abfolge:

1. Bitten Sie den Agenten, das Repository zu überprüfen.
2. Bitten Sie um eine Zusammenfassung der Architektur.
3. Fragen Sie nach Risiken und fehlenden Informationen.
4. Schreiben Sie den eigenen Aufgabenplan des Studenten.
5. Genehmigen Sie eine kleine Implementierungsaufgabe.
6. Überprüfen Sie die resultierenden Änderungen.
7. Führen Sie Tests durch, bevor Sie fortfahren.

Dies lehrt kontrollierte Delegation statt blinder Delegation.

Ein Agententeam mit klaren Rollen einsetzen

Ein einfaches Orchestrierungsmuster kann umfassen:

• Planer: schlägt die Aufgabenzerlegung vor
• Implementierer: modifiziert den Code
• Tester: erstellt und führt Tests aus
• Rezensent: sucht nach Mängeln und Risiken
• Menschlicher Evaluator: genehmigt oder lehnt Änderungen ab

Studenten sollten lernen, dass das Hinzufügen weiterer Agenten die Qualität nicht automatisch verbessert. Mehr Agenten können widersprüchliche Anweisungen, doppelten Aufwand, erhöhte Kosten und unklare Verantwortlichkeiten schaffen.

Das Bildungsziel ist nicht, das größte Multi-Agenten-System zu bauen. Es geht darum, den einfachsten Workflow zu wählen, der vertrauenswürdige Ergebnisse liefert.

Menschliche Genehmigungsschranken einbauen

Verlangen Sie eine explizite Genehmigung, bevor ein Agent Folgendes tun kann:

• Authentifizierung ändern
• Datenschemata modifizieren
• Abhängigkeiten hinzufügen
• Zugriff auf Produktionssysteme
• Bereitstellungskonfiguration ändern
• Dateien löschen
• Einen Pull Request zusammenführen

Dies lehrt die Studenten, dass Autonomie durch Berechtigungen und Überprüfung begrenzt sein muss.

Fehler bewusst benoten

Agenten sind am lehrreichsten, wenn sie auf informative Weise versagen. Lehrende sollten Folgendes einbeziehen:

• Mehrdeutige Anforderungen
• Widersprüchliche Einschränkungen
• Unvollständige Tests
• Sicherheitsempfindliche Operationen
• Irreführende Dokumentation
• Instabile Tests
• Leistungsgrenzen
• Eine Änderung, die korrekt erscheint, aber eine andere Funktion unterbricht

Die Aufgabe des Studenten ist es, den Fehler zu diagnostizieren und den Prozess zu verbessern.

Ein Kompetenzrahmen für 2026 bis 2031

Der folgende Rahmen ist so konzipiert, dass er auch bei sich ändernden spezifischen Tools nützlich bleibt.

Bereich eins: Technische Grundlagen und Code-Kompetenz

Ein kompetenter Entwickler kann:

• Unbekannten Code lesen
• Kontrollfluss und Datenfluss erklären
• Schnittstellen und Abhängigkeiten verstehen
• Algorithmische Komplexität analysieren
• Versionskontrolle verwenden
• Debuggen, ohne sich vollständig auf einen Agenten zu verlassen

Nachweis: Code-Erklärung, manuelle Debugging-Aufgabe, Designkritik und individuelle Transferübung.

Bereich zwei: Problemformulierung und Zerlegung

Ein kompetenter Entwickler kann:

• Benutzerziele klären
• Einschränkungen und Annahmen identifizieren
• Wesentliches von optionalen Anforderungen trennen
• Arbeit in unabhängig testbare Aufgaben zerlegen
• Akzeptanzkriterien definieren
• Erkennen, wann eine Aufgabe zu breit für eine zuverlässige Delegation ist

Nachweis: Spezifikation, Aufgabengraph, Risikoregister und Erklärung der Zerlegungsentscheidungen.

Bereich drei: Agentensteuerung und Kontext-Engineering

Ein kompetenter Entwickler kann:

• Relevanten Repository-Kontext bereitstellen
• Präzise Anweisungen geben
• Grenzen und Berechtigungen definieren
• Entscheiden, wann ein Agent zu verwenden ist und wann nicht
• Alternative Pläne vergleichen
• Sich erholen, wenn der Agent der falschen Interpretation folgt

Nachweis: Planungs-Checkpoints, repräsentative Interaktionsaufzeichnungen und eine Live-Revisionsaufgabe.

Bereich vier: Verifikation und Überprüfung

Ein kompetenter Entwickler kann:

• Generierten Code überprüfen
• Sinnvolle Tests entwerfen
• Versteckte Annahmen identifizieren
• Sicherheits- und Datenschutzrisiken überprüfen
• Wartbarkeit bewerten
• Erklären, was die Tests nicht beweisen

Nachweis: Code-Review, Adversarial Tests, Fehlerfindungsübung und mündliche Verteidigung.

Bereich fünf: Orchestrierung und Betrieb

Ein kompetenter Entwickler kann:

• Planung, Implementierung, Tests und Review-Tools koordinieren
• Checkpoints und menschliche Genehmigungsschranken verwenden
• Kosten, Zeit und Tool-Verhalten verfolgen
• Reproduzierbare Workflows aufrechterhalten
• Fehler beobachten und das System verbessern
• Entscheiden, ob mehrere Agenten einen Mehrwert bieten

Nachweis: Funktionierender Orchestrierungs-Workflow, Logs, Evaluierungsbericht und Kosten- oder Performance-Analyse.

Bereich sechs: Produkt- und Systemdesign

Ein kompetenter Entwickler kann:

• Ein angemessenes Maß an Automatisierung wählen
• Modulare Systeme entwerfen
• Geschwindigkeit, Qualität, Kosten und Risiko ausgleichen
• Technische Entscheidungen mit Benutzerergebnissen verbinden
• Erkennen, wann eine einfache Nicht-Agenten-Lösung besser ist

Nachweis: Produktbriefing, Architekturentscheidungsdokument, Prototyp und benutzerzentrierte Demonstration.

Bereich sieben: Verantwortungsbewusste berufliche Praxis

Ein kompetenter Entwickler kann:

• KI-Unterstützung offenlegen
• Private und proprietäre Informationen schützen
• Urheberrechts- und Lizenzpflichten respektieren
• Bias- und Zuverlässigkeitsrisiken identifizieren
• Unsicherheiten kommunizieren
• Verantwortung für das Endsystem übernehmen

Nachweis: Offenlegungserklärung, Risikobewertung, Datenschutzprüfung und professionelle Präsentation.

Vorgeschlagene Kompetenzniveaus

Bis 2031 sollte eine professionelle Qualifikation die Bewegung durch diese Niveaus demonstrieren und nicht nur die Vertrautheit mit einem bestimmten Software-Tool bestätigen.

Empfehlungen für verschiedene Stakeholder

Universitäten

• Fügen Sie agentenbewusste Software-Engineering-Module zu bestehenden Kursen hinzu.
• Bewahren Sie die grundlegende Programmierung und Algorithmen.
• Ersetzen Sie einige Code-Generierungsaufgaben durch Review- und Transferaufgaben.
• Verlangen Sie von den Studenten, wichtige Arbeiten zu erklären und zu verteidigen.
• Schulen Sie Dozenten in Agenten-Tools, Evaluierungsdesign, Datenschutz und Integritätsrichtlinien.
• Erstellen Sie gemeinsame Repositories und Sandbox-Umgebungen.

Bootcamps

• Lehren Sie konventionelle Entwicklung und agentengestützte Entwicklung zusammen.
• Machen Sie Tests, Architektur und Sicherheit zu zentralen Bestandteilen des Lehrplans.
• Verlangen Sie Portfolio-Projekte mit Prozessaufzeichnungen.
• Fügen Sie Live-Demonstrationen hinzu.
• Lehren Sie Produkterkennung und Anforderungserstellung.
• Vermeiden Sie das Versprechen, dass allein das Prompting berufsfähige Ingenieure hervorbringt.

Zertifizierungsanbieter

• Erhöhen Sie den Einsatz von laborbasierten Bewertungen.
• Beziehen Sie Code-Review, Tests, Debugging und Bedrohungsanalyse mit ein.
• Verwenden Sie realistische Repositories anstelle isolierter Multiple-Choice-Fragen.
• Testen Sie toolunabhängiges Urteilsvermögen.
• Fügen Sie kurze mündliche Erklärungen oder aufgezeichnete Demonstrationen hinzu.
• Aktualisieren Sie Inhalte häufig, ohne die Qualifikation von der Schnittstelle eines Anbieters abhängig zu machen.

Lehrende

• Geben Sie für jede Bewertung genau an, was erlaubt ist.
• Gestalten Sie Aufgaben passend zum beabsichtigten Lernziel.
• Stellen Sie den Studenten zugelassene Tools oder gleichwertige Alternativen zur Verfügung.
• Bewerten Sie den Prozess, die Argumentation und die Verifikation.
• Verwenden Sie Protokolle als Nachweis, nicht als einzigen Beweis.
• Verlassen Sie sich nicht auf KI-Erkennungssoftware als primären Integritätsmechanismus.

Lernende und Produktentwickler

• Lernen Sie genügend konventionelle Programmierung, um generierten Code lesen und hinterfragen zu können.
• Beginnen Sie mit einem kleinen Produkt statt einer vagen, großen Anwendung.
• Schreiben Sie die Spezifikation, bevor Sie einen Agenten öffnen.
• Delegieren Sie jeweils eine Aufgabe.
• Überprüfen Sie jede Änderung und testen Sie jede Annahme.
• Führen Sie eine Aufzeichnung wichtiger Entscheidungen.
• Behandeln Sie den Agenten als schnellen Junior-Mitarbeiter, nicht als unbestreitbaren Experten.

Der erste nächste Schritt

Für jemanden, der eine Produktentwicklungsreise beginnt, ist der nützlichste erste Schritt:

Wählen Sie ein kleines Benutzerproblem und schreiben Sie eine einseitige Spezifikation, bevor Sie einen Agenten bitten, Code zu schreiben.

Fügen Sie Folgendes hinzu:

• Wer der Benutzer ist
• Welches Problem er hat
• Was die erste Version tun muss
• Was sie nicht tun darf
• Drei Akzeptanztests
• Ein wichtiges Sicherheits- oder Datenschutzbedenken
• Drei kleine Implementierungsaufgaben

Bitten Sie dann den Agenten, die Spezifikation zu überprüfen und fehlende Anforderungen zu identifizieren, anstatt das gesamte Produkt zu entwickeln.

Nach Korrektur der Spezifikation delegieren Sie nur die erste Aufgabe. Überprüfen Sie den vorgeschlagenen Plan, prüfen Sie die Änderungen, führen Sie die Tests aus und notieren Sie, was der Agent falsch gemacht hat.

Diese einzige Übung lehrt die wichtigste Lektion des Agentenzeitalters: Die Qualität des Ergebnisses hängt weniger davon ab, wie viel Code der Agent produzieren kann, als davon, wie klar der Mensch die Arbeit definiert, überwacht und bewertet.

Fazit

Die Entwicklerausbildung bewegt sich auf ein neues Gleichgewicht zu.

Studenten müssen immer noch Code schreiben, insbesondere beim Erlernen grundlegender Konzepte. Doch die berufliche Kompetenz wird zunehmend durch Problemzerlegung, Spezifikation, Codeverständnis, Überprüfung, Testen, Orchestrierung, Produktbeurteilung und den verantwortungsvollen Einsatz autonomer Systeme unter Beweis gestellt werden.

Die stärksten Lehrpläne werden Coding-Agenten weder als Betrugsmaschinen noch als magische Tutoren behandeln. Sie werden sie als leistungsstarke, aber fehlbare Engineering-Tools betrachten. Studenten werden lernen, wann sie diese einsetzen, wie sie sie einschränken, wie sie ihre Ausgabe bewerten und wie sie die Verantwortung für das Endsystem übernehmen.

Der belastbarste Entwickler der nächsten fünf Jahre wird nicht die Person sein, die den meisten Code von Hand produzieren oder den längsten Prompt generieren kann. Es wird die Person sein, die ein unklares Ziel in einen zuverlässigen Prozess umwandeln, mehrere Tools auf dieses Ziel hin steuern, Fehler frühzeitig erkennen und erklären kann, warum die resultierende Software Vertrauen verdient.