In den letzten Jahren hat sich der Einsatz von Künstlicher Intelligenz (KI) in der Softwareentwicklung von einer interessanten Idee zu einem unverzichtbaren Werkzeug gewandelt. Ob durch automatisierte Code-Vervollständigungen, Debugging-Empfehlungen oder gar das Schreiben ganzer Code-Blöcke – KI-gestützte Tools wie ChatGPT und GitHub Copilot helfen Entwicklern, effizienter und produktiver zu arbeiten. Insbesondere für kleinere Software-Teams und mittelständische Unternehmen bietet der Einsatz von KI enorme Vorteile: Routineaufgaben werden schneller erledigt, die Code-Qualität verbessert sich und das Team kann sich stärker auf kreative und strategische Aspekte der Entwicklung konzentrieren.

Doch wie setzt man KI in der Programmierung sinnvoll und strukturiert ein? Die Herausforderung besteht darin, die AI nicht einfach „drauflos“ arbeiten zu lassen, sondern gezielt für einzelne Programmieraufgaben zu nutzen – sei es beim Brainstorming für Lösungswege, der schrittweisen Ausarbeitung von Konzepten oder der Umsetzung des Codes selbst. Genau hier setzt unser Schritt-für-Schritt-Ansatz an.

In diesem Beitrag lernst du, wie du eine Code-Aufgabe mithilfe von KI in handliche Schritte zerlegst und AI-Tools gezielt für jeden Schritt einsetzt. Von der Ideenfindung bis zur finalen Implementierung zeigen wir dir einen praxiserprobten Workflow, der nicht nur die Effizienz steigert, sondern dir auch hilft, den Überblick zu behalten und sauberen, wartbaren Code zu produzieren. Unser Ziel: Dir einen klaren und nachvollziehbaren Prozess an die Hand zu geben, der dich bei deinen nächsten Programmierprojekten unterstützt und den Einstieg in die AI-gestützte Entwicklung erleichtert.

Schritt 1: Brainstorming für Lösungswege

Verwendung von ChatGPT o1-mini

Der erste Schritt in einem KI-gestützten Programmier-Workflow ist das Brainstorming möglicher Lösungsansätze. Hierfür bietet sich ChatGPT o1-mini an – eine schnellere, weniger ressourcenintensive Version, die sich ideal für die Ideensammlung eignet. Gerade zu Beginn eines Projekts, wenn noch verschiedene Lösungswege in Betracht gezogen werden, kann dieser Schritt enorm wertvoll sein: o1-mini liefert rasch erste Ideen und mögliche Herangehensweisen, ohne allzu tief ins Detail zu gehen. Damit eignet es sich besonders gut, um Optionen abzuwägen und eine grobe Richtung für das Projekt festzulegen.

Warum o1-mini statt einer umfangreicheren Version wie o1-preview? Die Antwort ist einfach: Geschwindigkeit. In dieser Phase brauchen wir nicht die detailliertesten Anweisungen, sondern einen Überblick über verschiedene mögliche Lösungen. Außerdem tendiert das größere Modell o1 zu “overthinking”, also die Dinge zu detailliert auszuplanen, was am Anfang erstmal kontraproduktiv ist. Wenn bereits ein klarer Lösungsweg existiert oder das Team sich auf eine spezifische Methode geeinigt hat, kannst du den Brainstorming-Schritt überspringen und direkt zu Schritt 2 übergehen. So vermeidest du, unnötige Zeit mit Optionen zu verbringen, die am Ende ohnehin nicht zum Einsatz kommen.

Praktische Tipps für das Brainstorming

Um den Brainstorming-Prozess mit ChatGPT o1-mini so effizient wie möglich zu gestalten, helfen präzise und gut formulierte Fragen. Anstatt allgemein nach einem Lösungsansatz zu fragen, solltest du das Ziel klar definieren und den Kontext kurz umreißen. Hier sind einige Beispiele für effektive Brainstorming-Fragen, für meinen Anwendungsfall (Entwicklung einer lokalen Mock Datenbank in Python, für Intranet Daten aus dem Unternehmens Sharepoint):

• „Welche Framework eignen sich für die Implementierung einer Mock-Datenbank in Python?“
• „Welche Ansätze gibt es, um die Microsoft Graph API lokal zu simulieren?“
• „Wie kann ich eine API so strukturieren, dass später einfach zwischen Live-Daten und Mock-Daten gewechselt werden kann?“

Solche Fragen geben dem KI-Modell klare Anhaltspunkte und liefern dir strukturierte Antworten, die weiterverwendet werden können. Vermeide dabei zu detaillierte und spezialisierte Fragen – in dieser Phase geht es eher darum, Ideen zu sammeln, statt konkrete Code-Snippets zu generieren.

Ein weiterer Tipp: Halte die Informationen knapp und vermeide Überflüssiges. Je präziser und schlanker deine Anfrage, desto klarer und relevanter werden die Antworten. Zu viele Details oder irrelevante Kontextinformationen können das Modell verwirren und führen häufig zu weniger hilfreichen Ergebnissen. Das Ziel des Brainstormings ist es, eine grobe Richtung für die Lösung zu finden – alles Weitere kannst du in den nachfolgenden Schritten vertiefen.

Schritt 2: Lösungsweg ausformulieren und planen

Einsatz von o1-preview

Nachdem du im ersten Schritt mögliche Lösungsansätze gebrainstormt hast, geht es nun darum, den ausgewählten Lösungsweg detailliert auszuarbeiten. Hierfür eignet sich die Version ChatGPT o1 (bzw. o1-preview zum aktuellen Stand, auch chatGPT strawberry genannt), da sie detailliertere und genauere Anweisungen liefern kann. Während o1-mini gut für schnelle Ideensammlungen ist, bietet o1-preview eine tiefere Analyse und ermöglicht es dir, eine präzise Schritt-für-Schritt-Anleitung zu erstellen, die du direkt in deinem Projekt umsetzen kannst.

Ein klarer, gut strukturierter Plan ist das Fundament für eine erfolgreiche Umsetzung – insbesondere bei komplexen Programmieraufgaben. o1-preview unterstützt dich dabei, den Lösungsweg so zu formulieren, dass alle notwendigen Schritte und Zwischenziele berücksichtigt werden. Anstatt einfach „drauflos“ zu programmieren, erstellst du eine systematische Anleitung, die dir und deinem Team eine zuverlässige Orientierung bietet.

Schrittweise Herangehensweise

In dieser Phase empfiehlt es sich, komplexe Aufgaben in maximal fünf überschaubare Schritte zu unterteilen. Warum maximal fünf? Komplexe Anweisungen mit zu vielen Schritten erhöhen das Risiko, dass wichtige Details übersehen oder missverstanden werden. Mit einer klaren Unterteilung behältst du die Übersicht und kannst jeden Schritt gezielt abarbeiten.

Hier ein Beispiel für eine strukturierte Aufteilung:

1. Erstellen einer Interface-Klasse: Definiere die Methoden, die später sowohl vom realen als auch vom Mock-Client implementiert werden sollen.
2. Implementierung des echten SDK-Clients: Binde den bestehenden SDK-Client ein und abstrahiere ihn in eine eigene Klasse.
3. Erstellung des Mock-Clients: Entwickle eine Mock-Variante des Clients, die lokale JSON-Dateien nutzt und Daten in einem identischen Format zurückgibt.
4. Einrichten der Abhängigkeitsinjektion: Implementiere eine Factory oder einen Dependency-Injection-Mechanismus, um zwischen realem und Mock-Client zu wechseln.
5. Konfiguration des CLI-Switches: Füge einen Parameter hinzu, der zwischen produktiver API und Mock-API umschaltet.

Wenn diese Schritte festgelegt sind, kannst du sie in o1 als Ausgangspunkt für die detaillierte Planung verwenden. Falls einer dieser Schritte selbst zu umfangreich oder komplex ist, empfiehlt es sich, ihn weiter zu unterteilen. In diesem Fall gehst du einfach erneut zu Schritt 1 zurück und startest den Brainstorming-Prozess für die spezifische Unteraufgabe.

Wiederholung bei Bedarf

Gerade bei komplexeren Projekten kommt es häufig vor, dass eine Aufgabe noch weiter aufgesplittet werden muss. In solchen Fällen kannst du den gesamten Prozess einfach erneut durchlaufen. Starte ein Brainstorming für die Unteraufgabe, kläre verschiedene Ansätze und formuliere dann mit chatGPT-o1 eine detaillierte Anleitung für die spezifischen Schritte. Durch diese iterative Vorgehensweise baust du deinen Lösungsweg Schritt für Schritt auf, ohne den Überblick zu verlieren.

Mit dieser strukturierten Herangehensweise schaffst du eine solide Grundlage für den eigentlichen Programmierprozess. Sobald der Plan steht und alle Schritte klar definiert sind, bist du bereit, in der Entwicklungsumgebung die Umsetzung zu starten – Schritt für Schritt, ohne dabei auf Details verzichten zu müssen.

Schritt 3: Nutzung der IDE und KI-Chat

Integration in die Entwicklungsumgebung

Sobald der Lösungsweg geplant ist, geht es an die praktische Umsetzung in der Entwicklungsumgebung. Für diesen Schritt nutzen wir KI-gestützte Tools, die sich direkt in die IDE (Integrated Development Environment) integrieren lassen. Hierfür stehen dir verschiedene Optionen zur Verfügung: Cursor (Pro Version mit Claude 3.5-Sonnet) oder GitHub Copilot. Diese Tools bieten nicht nur Code-Vervollständigungen, sondern können auch komplexe Aufgaben wie Refactoring und Schritt-für-Schritt-Anweisungen unterstützen.

Die Integration eines KI-Tools in die IDE sorgt für einen nahtlosen Workflow: Du kannst Fragen stellen, Feedback zu Code-Snippets erhalten und dir neue Vorschläge für die Umsetzung anzeigen lassen, ohne die Entwicklungsumgebung verlassen zu müssen. Dadurch wird dein Arbeitsfluss nicht unterbrochen, was besonders bei anspruchsvollen Projekten wertvolle Zeit spart.

Erstellung des Prompts

Eine effektive Zusammenarbeit mit der KI hängt maßgeblich von der Struktur und Präzision deines Prompts ab. Ein guter Prompt sorgt dafür, dass die KI genau versteht, was du erreichen möchtest, und dir gezielte Unterstützung bieten kann. Um Klarheit und Struktur zu gewährleisten, empfehlen wir die folgenden vier Teile für deinen Prompt:

1. Ziel oder Aufgabe: Beschreibe kurz und präzise, welches Ziel du erreichen möchtest. Beispiel: „Implementiere eine Mock-API für die Microsoft Graph SDK, die lokale JSON-Daten verwendet.“
2. Alle einzelnen Schritte: Liste die zuvor ausgearbeiteten Schritte auf, die die KI zur Umsetzung berücksichtigen soll.Beispiel:
3. Interface für Methoden get_sites() und get_sitepage_webparts() definieren
4. Realen SDK-Client abstrahieren und in eigene Klasse auslagern.
5. Mock-Client erstellen, der Daten aus JSON-Dateien liefert.
6. Hinweis zur schrittweisen Ausführung: Füge eine klare Anweisung hinzu, dass die KI jeden Schritt einzeln durchführen soll und nur zum nächsten übergeht, wenn der aktuelle Schritt abgeschlossen ist. Dies hilft, den Prozess kontrolliert und übersichtlich zu gestalten.Beispiel: „Führe jeden Schritt einzeln aus und gehe erst zum nächsten Schritt über, wenn ich dies explizit bestätige.“
7. Notwendige Dateien, Ordner, Bilder oder Dokumentationen: Gib an, welche Dateien oder Ressourcen benötigt werden oder verändert werden sollen. Nenne nur die wirklich relevanten Dateien, um die KI nicht mit unnötigen Informationen zu überladen. Beispiel: „Im Unterordner ms-graph im dataVerzeichnis befinden sich alle Mock-Daten im JSON-Format.“ oder tagge einfach direkt die Dateien (mit @filename.py).

Dieser strukturierte Aufbau hilft der KI, sich in den Anforderungen besser zurechtzufinden, und führt zu präziseren und relevanteren Ergebnissen.

Best Practices

Um den KI-Chat optimal zu nutzen, solltest du darauf achten, deine Prompts so klar und präzise wie möglich zu formulieren. Hier einige bewährte Tipps und Beispiele für effektive Prompts:

• Sei spezifisch: Anstatt eine allgemeine Anweisung wie „Baue eine Mock-API“ zu geben, beschreibe genau, welche Funktionen die API haben soll und welche Schritte erforderlich sind.
• Verwende einfache Sprache: Vermeide komplexe Satzstrukturen und Fachjargon, der für die KI schwer verständlich sein könnte. Klare, einfache Anweisungen führen oft zu besseren Ergebnissen.
• Baue Rückfragen ein: Falls du dir bei einem bestimmten Schritt unsicher bist, gib der KI Raum, Rückfragen zu stellen. Beispiel: „Falls eine Abstraktion des SDK-Clients nötig ist, bitte kurz erklären.“

Beispiele für effektive Prompts

• Prompt für die Erstellung eines Mock-Clients:
• „Ich möchte eine Mock-API für die Microsoft Graph SDK erstellen, die lokale JSON-Daten verwendet. Schritte: 1. Definiere ein Interface mit den Methoden get_sites() und get_sitepage_webparts(). 2. Abstrahiere den existierenden SDK-Client in eine eigene Klasse. 3. Erstelle einen Mock-Client, der die Daten aus JSON-Dateien liest. Führe jeden Schritt einzeln aus und warte auf meine Bestätigung, bevor du fortfährst.“
• Prompt für das Hinzufügen einer Dependency Injection:
• „Implementiere eine Dependency Injection für den Microsoft Graph Client, sodass zwischen dem realen und dem Mock-Client gewechselt werden kann. Schritte: 1. Erstelle eine Factory-Klasse, die basierend auf einer Konfiguration den realen oder den Mock-Client zurückgibt. 2. Füge eine Option in der CLI hinzu, die den Wechsel zwischen produktiver API und Mock-API ermöglicht. Führe die Schritte nacheinander aus und warte auf meine Bestätigung, bevor du fortfährst.“

Mit diesen Best Practices und einer klaren Struktur deiner Prompts kannst du das Potenzial der KI in deiner Entwicklungsumgebung optimal ausschöpfen. Die KI unterstützt dich so gezielt und präzise, ohne dass du durch unklare oder irrelevante Vorschläge abgelenkt wirst.

Schritt 4: Schritt-für-Schritt Umsetzung der Code-Vorschläge

Implementierung nach Schrittanweisungen

Jetzt beginnt der eigentliche Programmierprozess: Die Umsetzung des detaillierten Lösungswegs in Code. An diesem Punkt hast du bereits alle nötigen Schritte in deiner Entwicklungsumgebung vorbereitet und die KI liefert dir schrittweise Code-Vorschläge. Der Schlüssel zu einer erfolgreichen Umsetzung liegt nun darin, die Vorschläge der KI Schritt für Schritt zu implementieren, ohne Abkürzungen zu nehmen oder mehrere Schritte auf einmal auszuführen.

Durch diese sequenzielle Herangehensweise vermeidest du Fehler und verlierst nicht den Überblick – insbesondere bei komplexen Aufgaben, die mehrere aufeinander aufbauende Schritte erfordern. Arbeite dich systematisch durch jeden Schritt und führe die vorgeschlagenen Änderungen in deinem Code ein. Nachdem ein Schritt umgesetzt ist, prüfe kurz, ob das Ergebnis wie erwartet funktioniert, bevor du zum nächsten übergehst.

Qualitätssicherung

Bei der Nutzung von KI-generiertem Code ist es besonders wichtig, die Qualität der Vorschläge aktiv zu überprüfen. KI-Modelle wie OpenAI ChatGPT-4o oder Antrophic Claude 3.5 Sonnet können zwar oft präzise und nützliche Lösungen liefern, dennoch solltest du sicherstellen, dass der Code clean und korrekt ist.

Falls dir ein Vorschlag unklar ist oder nicht den Clean-Code-Prinzipien entspricht, zögere nicht, die KI um Klärung oder alternative Ansätze zu bitten. Beispielsweise kannst du nach einer verbesserten, lesbareren Version fragen oder darum bitten, spezifische Namenskonventionen einzuhalten. Außerdem kann es sinnvoll sein, die KI explizit um die Verwendung bestimmter Design-Patterns oder Best Practices zu bitten, wenn du merkst, dass der generierte Code nicht deinen Standards entspricht.

Beispiel: Wenn die KI eine zu verschachtelte Funktion vorschlägt, könntest du nach einer modulareren Version fragen: „Könntest du diese Funktion in kleinere, klar abgegrenzte Funktionen aufteilen, um die Lesbarkeit zu verbessern?“ Diese Art von Rückfragen hilft dir, die Codequalität auf einem hohen Niveau zu halten und den Code besser nachvollziehen zu können.

Fortschrittskontrolle

Ein weiterer wichtiger Aspekt der schrittweisen Umsetzung ist die konsequente Fortschrittskontrolle. Arbeite nur dann am nächsten Schritt weiter, wenn der vorherige vollständig und erfolgreich umgesetzt ist. Diese Herangehensweise stellt sicher, dass du mögliche Fehler sofort entdeckst und beheben kannst, bevor sie sich auf spätere Schritte auswirken. Indem du den Prozess in kontrollierten, abgeschlossenen Einheiten durchführst, minimierst du die Gefahr von Code-Konflikten und schwer auffindbaren Bugs.

Ein bewährtes Vorgehen für die Fortschrittskontrolle besteht darin, nach jedem Schritt eine kleine manuelle oder automatische Testüberprüfung durchzuführen. So kannst du sicherstellen, dass die Implementierung nicht nur technisch funktioniert, sondern auch die geplante Funktionalität abdeckt. Für umfangreichere Änderungen empfiehlt es sich, bei jedem erfolgreichen Schritt den Code in der Versionskontrolle (z. B. Git) zu sichern. Dadurch schaffst du Wiederherstellungspunkte, falls in späteren Schritten Probleme auftreten.

Zusammengefasst

Die schrittweise Umsetzung der Code-Vorschläge ermöglicht eine präzise und kontrollierte Entwicklung. Durch die Kombination aus klar strukturierten Anweisungen, regelmäßiger Qualitätssicherung und konsequenter Fortschrittskontrolle erzielst du nicht nur schnellere Ergebnisse, sondern stellst auch sicher, dass dein Code qualitativ hochwertig und wartbar bleibt.

Beispielprompt

Ein gut durchdachter Prompt ist der Schlüssel zu erfolgreichen Ergebnissen generativen AI-Coding Tools wie Cursor AI oder GitHub Copilot. Im Folgenden zeigen wir dir ein Beispiel für einen detaillierten Prompt, mit dem du eine Mock-API zur lokalen Simulation der Microsoft Graph API umsetzen kannst. Der Prompt ist so aufgebaut, dass er der KI klare, handhabbare Schritte vorgibt, was die Genauigkeit und Verwendbarkeit der generierten Ergebnisse erhöht.

Detaillierter Prompt

Hier ein Beispiel für einen Prompt, der die Implementierung einer Mock-API anleitet:

„Let's implement a mock API for testing the SDK with local data. Let's do this step-by-step.

1. Define an Interface or Abstract Base Class

Create an interface (using abstract base classes) that defines the methods you need from the Microsoft Graph SDK.

I only need to get site pages and site page webparts. So define the methods get_sites() and get_sitepage_webparts().

2. Implement the Real SDK Client

It is already implemented, so please abstract it to its own class.

3. Implement the Mock Client

Create a mock client that reads data from JSON files and returns it in the same format as the real SDK client.

4. Use Dependency Injection

Create a factory or use dependency injection to switch between the real and mock clients based on a configuration setting.

Are you ready? Let's start with Step 1 and only Step 1. I will let you know when we can proceed with the next step. In the sub-folder ms-graph of the data folder are all the mock data JSON files.”

Dieser Prompt ist so aufgebaut, dass er die KI schrittweise durch den gesamten Prozess führt. Jeder Schritt ist klar definiert und gibt der KI eine spezifische Aufgabe, bevor zum nächsten Schritt übergegangen wird. Dadurch wird die Wahrscheinlichkeit von Missverständnissen und Fehlern reduziert.

Analyse und Erklärung

Lass uns die einzelnen Schritte im Prompt genauer betrachten und erklären, warum sie so formuliert sind:

1. Definiere das Interface oder die Abstract Base Class
2. Der erste Schritt ist entscheidend, um die Architektur der Mock-API zu gestalten. Indem wir eine Interface-Klasse mit den benötigten Methoden (get_sites() und get_sitepage_webparts()) definieren, stellen wir sicher, dass sowohl der reale als auch der Mock-Client auf die gleiche Weise angesprochen werden können. Dieser Schritt legt die Grundlage für ein flexibles und wartbares Design.
3. Implementiere den realen SDK-Client
4. Da der reale SDK-Client bereits implementiert ist, soll die KI ihn nur abstrahieren und in eine eigene Klasse auslagern. So wird sichergestellt, dass sowohl der reale als auch der Mock-Client dieselbe Schnittstelle verwenden. Die KI muss hier keine neuen Funktionalitäten entwickeln, sondern lediglich die bestehende Implementierung umstrukturieren.
5. Erstelle den Mock-Client
6. Hier soll die KI einen Mock-Client implementieren, der Daten aus JSON-Dateien liest. Das sorgt dafür, dass der Mock-Client die gleichen Datenstrukturen wie der reale Client verwendet und sich identisch verhält. Damit können Entwickler die API lokal testen, ohne auf die echte Microsoft Graph API zugreifen zu müssen, was bei mir aufgrund fehlender Rechte nur teilweise funktioniert.
7. Nutze Dependency Injection
8. Dependency Injection (DI) erlaubt es uns, dynamisch zwischen dem echten und dem Mock-Client zu wechseln. Durch die Verwendung einer Factory oder DI-Konstruktion wird der Code flexibler und lässt sich einfacher testen und erweitern. Dieser Schritt ist entscheidend für eine saubere Architektur und zeigt, wie wichtig es ist, der KI spezifische Design-Patterns oder Methoden zu nennen.

Anmerkung zur schrittweisen Ausführung:

Am Ende des Prompts haben wir eine klare Anweisung hinzugefügt, dass die KI jeden Schritt einzeln durchführen soll und erst nach einer Bestätigung zum nächsten Schritt übergeht. Dies fördert eine kontrollierte Implementierung und vermeidet, dass die KI versucht, alles auf einmal zu erledigen – was häufig zu unsauberem Code führt.

Tipps für den effektiven Einsatz von AI in der Programmierung

Generische Fragestellungen

Besonders in den ersten Schritten solltest du dich auf generische Fragestellungen konzentrieren, ohne allzu tief in spezifische Projektdetails einzutauchen. Eine allgemeine Frage wie „Welche Ansätze gibt es für eine Mock-API in Python?“ kann wertvolle Vorschläge liefern, ohne die KI von Anfang an auf eine spezifische Lösung festzulegen. Erst wenn du eine grobe Richtung festgelegt hast, solltest du detaillierter werden.

Minimalismus

Weniger ist oft mehr – besonders bei der Verwendung von KI. Vermeide überflüssige Informationen oder Kontext, die für die eigentliche Aufgabe nicht notwendig sind. Zu viele Details können die KI verwirren und dazu führen, dass sie irrelevante Informationen einbezieht oder Fehlinterpretationen entstehen. Fokussiere dich auf das Wesentliche und stelle sicher, dass der Prompt nur die absolut notwendigen Informationen enthält.

Anpassung und Überarbeitung

Auch wenn die AI hilfreiche Vorschläge macht, ist es wichtig, dass du die generierten Schritte oder Code-Snippets an deine spezifischen Anforderungen anpasst und überarbeitest. Einfaches Copy&Paste kann schnell zu unübersichtlichem Code führen, besonders wenn du die zugrunde liegende Logik nicht vollständig verstehst. Nimm dir die Zeit, die einzelnen Schritte zu überprüfen und anzupassen, damit der Code sauber und verständlich bleibt.

Beispielsweise könntest du nach der Generierung eines Vorschlags für eine Funktion nochmal nachfragen: „Könntest du diese Funktion gemäß dem Clean-Code-Prinzip Single responsibity principle (SRP) umstrukturieren?“ oder „Könntest du auf mögliche Optimierungen für besser Lesbaren und übersichtlicheren Code hinweisen?“ So stellst du sicher, dass der Code nicht nur technisch korrekt ist, sondern auch wartbar und effizient.

Mit diesen Tipps und dem strukturierten Prompt-Ansatz kannst du die KI gezielt in deinen Programmierworkflow integrieren und das volle Potenzial der Unterstützung nutzen, ohne dabei die Code-Qualität oder Übersichtlichkeit zu gefährden.

Fazit

Die Nutzung von KI in der Programmierung eröffnet neue Möglichkeiten, die Entwicklungsprozesse zu beschleunigen und die Effizienz zu steigern. In diesem Beitrag haben wir einen praxiserprobten Schritt-für-Schritt-Ansatz vorgestellt, der dir zeigt, wie du AI-Tools systematisch in deinen Programmierworkflow integrieren kannst:

1. Brainstorming für Lösungswege: Mithilfe von ChatGPT o1-mini generierst du schnell Ideen und mögliche Lösungsansätze.
2. Lösungsweg ausformulieren und planen: Mit OpenAI’s o1 Modell (aka GPT-strawberry) erstellst du einen detaillierten Plan, der dir eine klare Schritt-für-Schritt-Anleitung für die Umsetzung liefert.
3. Nutzung der IDE und KI-Chat: Durch die Integration in die Entwicklungsumgebung mit GitHub Copilot oder CursorAI und gezielten, gut strukturierten Prompts lässt du dir Schritt-für-Schritt von der AI beim Coding assistieren.
4. Schrittweise Umsetzung der Code-Vorschläge: Du implementierst die KI-Vorschläge nach und nach, überprüfst die Codequalität und kontrollierst deinen Fortschritt.

Dieser strukturierte Ansatz ermöglicht es dir, KI gezielt einzusetzen und ihre Stärken optimal zu nutzen, ohne die Übersicht zu verlieren oder die Codequalität zu gefährden. Durch die konsequente Kontrolle und Anpassung der KI-generierten Vorschläge stellst du sicher, dass der Code sowohl funktional als auch wartbar bleibt.

Ausblick

Die Entwicklung von KI-Technologien schreitet rasant voran, und die Möglichkeiten im Bereich der Programmierung werden kontinuierlich ausgebaut. Zukünftige KI-Modelle könnten noch präziser auf spezifische Anforderungen eingehen, komplexere Aufgaben eigenständig umsetzen und tiefer in die Software-Architektur eingebunden werden. Möglicherweise werden in naher Zukunft spezialisierte Modelle verfügbar sein, die gezielt auf bestimmte Programmiersprachen oder Frameworks trainiert sind und dadurch noch gezielter unterstützen können. Für Softwareentwickler und Unternehmen bedeutet dies: Die Bereitschaft zur Integration von KI wird immer mehr zum Wettbewerbsvorteil.

DIY

Falls du das Ergebnis des beschriebenen Ansatz selbst sehen möchtest, kannst du auch unser Open-Source-Projekt auf GitHub klonen oder forken: genericdeAG/intranet-rag-ready. Dieses Python-Tool wurde entwickelt, um Intranet-Daten aus SharePoint-Seiten zu extrahieren und in ein RAG-ready Format zu bringen. Es ist ein hervorragendes Beispiel dafür, wie KI in die Praxis integriert werden kann und lädt dazu ein, den beschriebenen Schritt-für-Schritt-Ansatz selbst anzuwenden.

‍

The AI Software Company unterstützt kleine und mittelständische Softwarefirmen in der DACH-Region dabei, ihre Entwicklungsprozesse mit KI effizienter, schneller und zukunftssicher zu gestalten.

Neugierig, wie du KI in deinem Software Team sinnvoll einsetzt? Melde dich für unseren Newsletter an und erhalte wertvolle Tipps, Einblicke und Updates!

‍