KI schreibt Python-Code, aber es ist immer noch Ihre Aufgabe, ihn zu pflegen

Bild vom Autor

# Einführung

KI-Codierungstools werden beeindruckend intestine darin, funktionierenden Python-Code zu schreiben. Sie können in wenigen Minuten komplette Anwendungen erstellen und komplexe Algorithmen implementieren. Allerdings ist die Wartung des von der KI generierten Codes oft mühsam.

Wenn Sie Instruments wie verwenden Claude Code, GitHub-Copilotoder Cursors Im Agentenmodus haben Sie das wahrscheinlich schon erlebt. Die KI hilft Ihnen, funktionierenden Code schnell zu liefern, aber die Kosten zeigen sich erst später. Sie haben wahrscheinlich eine aufgeblähte Funktion umgestaltet, nur um zu verstehen, wie sie Wochen nach ihrer Generierung funktioniert.

Das Downside besteht nicht darin, dass KI schlechten Code schreibt – obwohl dies manchmal der Fall ist –, sondern darin, dass KI darauf optimiert, „jetzt zu arbeiten“ und die Anforderungen in Ihrer Eingabeaufforderung zu erfüllen, während Sie Code benötigen, der langfristig lesbar und wartbar ist. Dieser Artikel zeigt Ihnen, wie Sie diese Lücke schließen können, indem Sie sich auf Python-spezifische Strategien konzentrieren.

# Vermeiden Sie die leere Leinwand-Falle

Der größte Fehler, den Entwickler machen, besteht darin, die KI zu bitten, bei Null anzufangen. KI-Agenten arbeiten am besten mit Einschränkungen und Richtlinien.

Bevor Sie Ihre erste Eingabeaufforderung schreiben, Richten Sie die Grundlagen des Projekts selbst ein. Das bedeutet, dass Sie Ihre Projektstruktur – Set up Ihrer Kernbibliotheken und Implementierung einiger Arbeitsbeispiele – so wählen, dass sie den Ton angibt. Das magazine kontraproduktiv erscheinen, hilft aber dabei, die KI dazu zu bringen, Code zu schreiben, der besser zu den Anforderungen Ihrer Anwendung passt.

Beginnen Sie mit der manuellen Erstellung einiger Funktionen. Wenn Sie eine API erstellen, implementieren Sie selbst einen vollständigen Endpunkt mit allen gewünschten Mustern: Abhängigkeitsinjektion, ordnungsgemäße Fehlerbehandlung, Datenbankzugriff und Validierung. Dies wird zur Referenzimplementierung.

Angenommen, Sie schreiben diesen ersten Endpunkt manuell:

from fastapi import APIRouter, Relies upon, HTTPException
from sqlalchemy.orm import Session

router = APIRouter()

# Assume get_db and Person mannequin are outlined elsewhere
async def get_user(user_id: int, db: Session = Relies upon(get_db)):
    person = db.question(Person).filter(Person.id == user_id).first()
    if not person:
        elevate HTTPException(status_code=404, element="Person not discovered")
    return person

Wenn die KI dieses Muster erkennt, versteht sie, wie wir mit Abhängigkeiten umgehen, wie wir Datenbanken abfragen und wie wir mit fehlenden Datensätzen umgehen.

Gleiches gilt auch für Ihre Projektstruktur. Erstellen Sie Ihre Verzeichnisse, richten Sie Ihre Importe ein und konfigurieren Sie Ihr Take a look at-Framework. KI sollte diese Architekturentscheidungen nicht treffen.

# Das Typsystem von Python zur Hauptaufgabe machen

Die dynamische Typisierung von Python ist flexibel, aber diese Flexibilität wird zu einer Belastung, wenn KI Ihren Code schreibt. Machen Sie Typhinweise zu wesentlichen Leitplanken und nicht zu einem „nice-to-have“ in Ihrem Anwendungscode.

Durch striktes Tippen werden KI-Fehler erkannt, bevor sie in die Produktion gelangen. Wenn Sie Typhinweise zu jeder Funktionssignatur und Ausführung benötigen mypy Im strengen Modus kann die KI keine Abkürzungen nehmen. Es kann keine mehrdeutigen Typen zurückgeben oder Parameter akzeptieren, bei denen es sich möglicherweise um Zeichenfolgen oder Hear handelt.

Noch wichtiger ist, dass strenge Typen ein besseres Design erzwingen. Zum Beispiel ein KI-Agent, der versucht, eine Funktion zu schreiben, die akzeptiert knowledge: dict kann viele Annahmen darüber treffen, was in diesem Wörterbuch steht. Allerdings schreibt ein KI-Agent eine Funktion, die akzeptiert knowledge: UserCreateRequest Wo UserCreateRequest ist ein Pydantisch Modell hat genau eine Interpretation.

# This constrains AI to jot down right code
from pydantic import BaseModel, EmailStr

class UserCreateRequest(BaseModel):
    title: str
    electronic mail: EmailStr
    age: int

class UserResponse(BaseModel):
    id: int
    title: str
    electronic mail: EmailStr

def process_user(knowledge: UserCreateRequest) -> UserResponse:
    go

# Reasonably than this
def process_user(knowledge: dict) -> dict:
    go

Verwenden Sie Bibliotheken, die Verträge durchsetzen: SQLAlchemy 2.0 mit typgeprüften Modellen und FastAPI mit Antwortmodellen sind eine ausgezeichnete Wahl. Dabei handelt es sich nicht nur um gute Praktiken; Es sind Einschränkungen, die die KI auf Kurs halten.

Setzen Sie mypy auf den strikten Modus und machen Sie das Bestehen von Typprüfungen nicht verhandelbar. Wenn KI Code generiert, der die Typprüfung nicht besteht, wird er iteriert, bis er erfolgreich ist. Diese automatische Rückkopplungsschleife erzeugt besseren Code als jede noch so große Menge an promptem Engineering.

# Erstellen einer Dokumentation zur Führung der KI

Die meisten Projekte verfügen über Dokumentation, die von Entwicklern ignoriert wird. Für KI-Agenten benötigen Sie eine Dokumentation, die sie tatsächlich verwenden – wie z README.md Datei mit Richtlinien. Das bedeutet eine einzige Datei mit klaren, spezifischen Regeln.

Erstellen Sie eine CLAUDE.md oder AGENTEN.md Datei im Stammverzeichnis Ihres Projekts. Machen Sie es nicht zu lang. Konzentrieren Sie sich auf das Einzigartige an Ihrem Projekt und nicht auf allgemeine Python-Finest Practices.

Ihre KI-Richtlinien sollten Folgendes angeben:

• Projektstruktur und wo verschiedene Arten von Code hingehören
• Welche Bibliotheken für allgemeine Aufgaben verwendet werden sollen
• Spezifische Muster, denen Sie folgen sollten (auf Beispieldateien verweisen)
• Explizite verbotene Muster
• Prüfanforderungen

Hier ist ein Beispiel AGENTEN.md Datei:

# Challenge Pointers

## Construction
/src/api - FastAPI routers
/src/providers - enterprise logic
/src/fashions - SQLAlchemy fashions
/src/schemas - Pydantic fashions

## Patterns
- All providers inherit from BaseService (see src/providers/base.py)
- All database entry goes via repository sample (see src/repositories/)
- Use dependency injection for all exterior dependencies

## Requirements
- Sort hints on all capabilities
- Docstrings utilizing Google fashion
- Capabilities beneath 50 strains
- Run `mypy --strict` and `ruff test` earlier than committing

## By no means
- No naked besides clauses
- No kind: ignore feedback
- No mutable default arguments
- No world state

Der Schlüssel liegt darin, spezifisch zu sein. Sagen Sie nicht einfach „Befolgen Sie Finest Practices“. Zeigen Sie auf die genaue Datei, die das Muster veranschaulicht. Sagen Sie nicht nur: „Gehen Sie mit Fehlern richtig um.“ Zeigen Sie das gewünschte Fehlerbehandlungsmuster an.

# Schreiben von Eingabeaufforderungen, die auf Beispiele verweisen

Generische Eingabeaufforderungen erzeugen generischen Code. Spezifische Eingabeaufforderungen, die auf Ihre vorhandene Codebasis verweisen, führen zu besser wartbarem Code.

Anstatt die KI zu bitten, „Authentifizierung hinzuzufügen“, führen Sie sie mit Verweisen auf Ihre Muster durch die Implementierung. Hier ist ein Beispiel für eine solche Eingabeaufforderung, die auf Beispiele verweist:

Implementieren Sie die JWT-Authentifizierung in src/providers/auth_service.py. Folgen Sie der gleichen Struktur wie UserService in src/providers/user_service.py. Verwenden Sie bcrypt für das Passwort-Hashing (bereits in „necessities.txt“).
Fügen Sie die Authentifizierungsabhängigkeit in src/api/dependencies.py nach dem Muster von get_db hinzu.
Erstellen Sie Pydantic-Schemas in src/schemas/auth.py ähnlich wie person.py.
Fügen Sie Pytest-Assessments in assessments/test_auth_service.py hinzu, indem Sie Fixtures aus conftest.py verwenden.

Beachten Sie, dass jede Anweisung auf eine vorhandene Datei oder ein vorhandenes Muster verweist. Sie fordern die KI nicht auf, eine Architektur zu entwickeln; Sie fordern es auf, das, was Sie benötigen, auf eine neue Funktion anzuwenden.

Wenn die KI Code generiert, überprüfen Sie ihn anhand Ihrer Muster. Verwendet es denselben Dependency-Injection-Ansatz? Folgt es der gleichen Fehlerbehandlung? Organisiert es Importe auf die gleiche Weise? Wenn nicht, weisen Sie auf die Diskrepanz hin und bitten Sie sie, sie mit dem bestehenden Muster in Einklang zu bringen.

# Planung vor der Implementierung

KI-Agenten können sich schnell bewegen, was sie gelegentlich weniger nützlich machen kann, wenn Geschwindigkeit auf Kosten der Struktur geht. Verwenden Sie den Planmodus oder fordern Sie einen Implementierungsplan an, bevor Code geschrieben wird.

Ein Planungsschritt zwingt die KI dazu, Abhängigkeiten und Strukturen zu durchdenken. Es gibt Ihnen auch die Möglichkeit, Architekturprobleme – wie z. B. zirkuläre Abhängigkeiten oder redundante Dienste – zu erkennen, bevor sie implementiert werden.

Fordern Sie einen Plan an, der Folgendes festlegt:

• Welche Dateien werden erstellt oder geändert
• Welche Abhängigkeiten bestehen zwischen Komponenten?
• Welche bestehenden Muster werden befolgt
• Welche Assessments sind erforderlich

Überprüfen Sie diesen Plan wie ein Entwurfsdokument. Überprüfen Sie, ob die KI Ihre Projektstruktur versteht. Stellen Sie sicher, dass die richtigen Bibliotheken verwendet werden, und stellen Sie sicher, dass nichts bereits Vorhandenes neu erfunden wird.

Wenn der Plan intestine aussieht, lassen Sie ihn von der KI ausführen. Wenn nicht, korrigieren Sie den Plan, bevor Code geschrieben wird. Es ist einfacher, einen schlechten Plan zu reparieren, als schlechten Code zu reparieren.

# KI bitten, Assessments zu schreiben, die tatsächlich testen

KI ist großartig und superschnell beim Schreiben von Assessments. Allerdings ist KI beim Schreiben nützlicher Assessments nicht effizient, es sei denn, Sie wissen genau, was „nützlich“ bedeutet.

Das standardmäßige KI-Testverhalten besteht darin, den glücklichen Weg zu testen und nichts anderes. Sie erhalten Assessments, die überprüfen, ob der Code funktioniert, wenn alles richtig läuft, additionally genau dann, wenn Sie keine Assessments benötigen.

Geben Sie Ihre Testanforderungen explizit an. Für jede Funktion ist Folgendes erforderlich:

• Glücklicher Pfadtest
• Validierungsfehlertests, um zu überprüfen, was mit ungültigen Eingaben passiert
• Randfalltests für leere Werte, Keine, Randbedingungen und mehr
• Fehlerbehandlungstests für Datenbankausfälle, Ausfälle externer Dienste und dergleichen

Verweisen Sie AI als Beispiele auf Ihre vorhandenen Testdateien. Wenn Sie bereits über gute Testmuster verfügen, schreibt die KI auch nützliche Assessments. Wenn Sie noch keine guten Assessments haben, schreiben Sie zunächst selbst ein paar.

# Ausgabe systematisch validieren

Nachdem die KI Code generiert hat, prüfen Sie nicht nur, ob er ausgeführt wird. Gehen Sie eine Checkliste durch.

Ihre Validierungscheckliste sollte Fragen wie die folgenden enthalten:

• Besteht es den strengen Mypy-Modus?
• Folgt es Mustern aus vorhandenem Code?
• Sind alle Funktionen unter 50 Zeilen
• Decken Assessments Randfälle und Fehler ab?
• Gibt es zu allen Funktionen Typhinweise?
• Werden die angegebenen Bibliotheken korrekt verwendet?

Automatisieren Sie, was Sie können. Aufstellen vorab festlegen Haken, die mypy ausführen, Halskrauseund Pytest. Wenn KI-generierter Code diese Prüfungen nicht besteht, wird er nicht festgeschrieben.

Bei dem, was Sie nicht automatisieren können, werden Sie gängige Anti-Patterns erkennen, nachdem Sie genügend KI-Code überprüft haben – etwa Funktionen, die zu viel tun, Fehlerbehandlung, die Ausnahmen verschluckt, oder mit Geschäftslogik vermischte Validierungslogik.

# Implementierung eines praktischen Arbeitsablaufs

Fassen wir nun alles zusammen, was wir bisher besprochen haben.

Sie starten ein neues Projekt. Sie verbringen Zeit damit, die Struktur einzurichten, Bibliotheken auszuwählen und zu installieren und einige Beispielfunktionen zu schreiben. Du erschaffst CLAUDE.md mit Ihren Richtlinien und schreiben Sie spezifische Pydantic-Modelle.

Jetzt bitten Sie die KI, eine neue Funktion zu implementieren. Sie schreiben eine ausführliche Eingabeaufforderung, die auf Ihre Beispiele verweist. KI erstellt einen Plan. Sie überprüfen und genehmigen es. KI schreibt den Code. Sie führen Typprüfungen und Assessments durch. Alles vergeht. Sie überprüfen den Code anhand Ihrer Muster. Es passt. Sie verpflichten sich.

Die Gesamtzeit von der Eingabeaufforderung bis zum Commit beträgt möglicherweise nur etwa 15 Minuten für eine Funktion, für deren manuelles Schreiben eine Stunde gedauert hätte. Aber was noch wichtiger ist: Der Code, den Sie erhalten, ist einfacher zu warten – er folgt den von Ihnen festgelegten Mustern.

Die nächste Funktion geht schneller, weil die KI mehr Beispiele hat, aus denen sie lernen kann. Der Code wird mit der Zeit konsistenter, da jedes neue Characteristic die bestehenden Muster verstärkt.

# Zusammenfassung

Da sich KI-Codierungstools als äußerst nützlich erweisen, verändert sich Ihr Job als Entwickler oder Datenexperte. Sie verbringen jetzt weniger Zeit mit dem Schreiben von Code und haben mehr Zeit mit:

• Entwerfen von Systemen und Auswählen von Architekturen
• Erstellen von Referenzimplementierungen von Mustern
• Schreibbeschränkungen und Richtlinien
• Überprüfung der KI-Ausgabe und Aufrechterhaltung der Qualitätsgrenze

Die Fähigkeit, die am wichtigsten ist, besteht nicht darin, Code schneller zu schreiben. Vielmehr geht es darum, Systeme zu entwerfen, die die KI dazu zwingen, wartbaren Code zu schreiben. Es geht darum zu wissen, welche Praktiken sich skalieren und welche technische Schulden verursachen. Ich hoffe, dass Sie diesen Artikel hilfreich fanden, auch wenn Sie Python nicht als Programmiersprache Ihrer Wahl verwenden. Teilen Sie uns mit, was wir Ihrer Meinung nach sonst noch tun können, um die Wartbarkeit des KI-generierten Python-Codes zu gewährleisten. Entdecken Sie weiter!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.