Eintritt in ein neues Unternehmen als Dateningenieur. Sie erben eine ganze Reihe von ETL-Pipelines und sind für deren Wartung verantwortlich. Was sind Ihrer Meinung nach die Herausforderungen Ihrer Arbeit?

Typischerweise können Sie mit den folgenden Problemen konfrontiert werden:

• Upstream-Schemaänderungen: Entwicklerteams können Felder hinzufügen oder löschen, Datentypen ändern oder Spalten umbenennen. Wenn sich ein Quellschema unerwartet ändert, können ETL-Aufträge abrupt fehlschlagen. Erschwerend kommt hinzu, dass die Pipeline unbemerkt beschädigte oder Nullwerte in nachgelagerte Tabellen lädt.
• Probleme mit der Datenqualität: Manchmal schlagen ETL-Jobs nicht sofort fehl, im Gegenteil, sie werden ausgeführt und mit einem Erfolgsstatus abgeschlossen. Die geladenen Daten sind jedoch völlig falsch und enthalten doppelte oder fehlende Datensätze.
• Mangelnde Dokumentation: Ältere Pipelines verfügen möglicherweise über wenige Dokumente oder die vorhandenen Dokumente sind möglicherweise veraltet. Sie sind sich additionally nicht sicher, ob sie der aktuellen Geschäftslogik entsprechen.
• Volumenwachstum und Leistungsspitzen: Das Datenvolumen steigt mit dem Wachstum des Unternehmens. Eine für einen kleineren historischen Datensatz optimierte ETL-Pipeline kann bei der Verarbeitung großer Mengen leicht langsam werden, ins Stocken geraten oder ausfallen.

Ein automatisierter Testworkflow kann Ihnen dabei helfen, die oben genannten Probleme zu lösen. Warum? Denn der strukturierte Workflow kann Ihnen dabei helfen, alle wichtigen Aspekte einer ETL-Pipeline schnell zu verstehen: die Geschäftslogik, die Algorithmen für die Datentransformation, die Datentypen und alle Datenprobleme, die die ETL-Pipelines lösen müssen. Die Testmuster sind wiederverwendbar – Sie müssen nicht jedes Mal einen neuen Workflow entwerfen, wenn Sie eine andere ETL-Pipeline erben.

Im heutigen Artikel konzentriere ich mich auf automatisierte Exams im Knowledge Engineering, einschließlich der Umgebungskonfiguration und eines praktischen Workflows. Am Ende werde ich auch diskutieren, wie KI-gestützter Code den Arbeitsablauf beschleunigen und die Produktivität verbessern kann.

Sorgen Sie dafür, dass die Umwelt funktioniert

Wenn Sie den automatisierten Testworkflow zum ersten Mal erstellen, kann die Einrichtung der Umgebung einige Zeit dauern. Es gibt verschiedene Instruments und Abläufe für Dateningenieure zum Einrichten der Testumgebung. Wenn Sie jedoch die folgenden Schritte befolgen, verläuft der Vorgang einfach und reibungslos.

Erstens müssen Sie nur drei Dinge installieren: Docker Desktop, VS Code und Dev Containers Extension.

In Ihrem Testworkflow erstellt Docker schlanke, isolierte und wiederholbare Testumgebungen. Es ermöglicht Ihnen, eine Scheindateninfrastruktur (z. B. Datenbanken, Datenpipelines und Orchestrierungs-Engines) direkt auf einem lokalen Pc oder innerhalb einer Steady Integration (CI)-Pipeline aufzubauen. Mit Docker können Sie Ihre Integrationstests und Datenvalidierungen auf allen Plattformen identisch ausführen, ohne lokale Betriebssysteme zu belasten.

Visible Studio Code (VS Code) ist eine zentralisierte Entwicklungsumgebung für die Skripterstellung, das Debuggen, die Implementierung und die Automatisierung von Datenpipeline-Exams. Als Dateningenieur haben Sie es möglicherweise für Ihre anderen Projekte verwendet. Möglicherweise sind Sie mit PyCharm oder IntelliJ IDEA besser vertraut. Aus Sicht der Benutzererfahrung wähle ich VS Code aufgrund seines schlanken Aufbaus, seines Erweiterungsökosystems und seines hybriden Pocket book-/Skript-Workflows. KI-native Editoren wie Cursor und Windsurf erfreuen sich bei Entwicklern immer größerer Beliebtheit, worauf ich im späteren Teil dieses Artikels näher eingehen werde.

Ich gehe davon aus, dass Sie Python, Poetry und Java bereits installiert haben. Sie können Ihr VS Code-Terminal öffnen, die folgenden Skripte eingeben, um deren Versionen zu überprüfen und sicherzustellen, dass sie aktualisiert sind. Sie können sie auch unter Ihrem Terminal installieren, falls Sie dies noch nicht getan haben.

python --version

java -version

poetry --version

Mit der Dev Container-Erweiterung können Sie einen Docker-Container als voll funktionsfähige, reproduzierbare Entwicklungsumgebung verwenden. Es standardisiert Umgebungen im gesamten Group und ermöglicht das lokale Testen der Datenerfassungslogik ohne den Verbrauch von Cloud-Ressourcen. Die Set up von Dev Container ist recht einfach. Sie müssen lediglich Erweiterungen in VS Code öffnen – Sie können Strg+Umschalt+X (Home windows/Linux) oder Befehl+Umschalt+X (Mac) drücken, dann in der Suchleiste nach „Dev Containers“ suchen und auf „Installieren“ klicken.

Die Dev Containers-Erweiterung weiß jedoch nicht, wie Sie Ihre spezifische Umgebung erstellen. Es braucht einen „Leitfaden“. Der Leitfaden ist der .devcontainer Ordner und die devcontainer.json Die Datei unter dem Ordner teilt der Dev-Container-Erweiterung Folgendes mit:

• Welches Docker-Picture heruntergeladen werden soll.
• Welche Ports weitergeleitet werden sollen.
• Welche VS-Code-Erweiterungen im Container installiert werden sollen.

Es gibt zwei Methoden, die Sie erhalten können .devcontainer Ordner. Wenn Sie mit diesen Instruments noch nicht vertraut sind, können Sie das automatisierte Software von VS Code verwenden. Wenn Sie eine Python- oder Knowledge Engineering-Vorlage auswählen, kann VS Code den Ordner automatisch generieren. Wenn Sie mehr Erfahrung mit solchen Projekten haben, können Sie es auch von Grund auf manuell schreiben, um den Testanforderungen Ihres Groups gerecht zu werden. Der .devcontainer Der Ordner kann zusammen mit Ihrem Quellcode und Ihren Quelldaten, die Sie zum Testen vorbereiten, festgeschrieben und an Git übertragen werden.

Um Ihnen das Leben zu erleichtern, können Sie das Git-Repository klonen und diesen Ordner mit VS Code öffnen.

git clone https://github.com/firm/data-ingestion-transformation.git

Der letzte Schritt der Konfiguration besteht darin, den Container erneut zu öffnen. Warum ist es wichtig? Denn wenn Sie auf „Im Container erneut öffnen“ klicken, startet VS Code seine Backend-Engine neu. Es startet den Docker-Container und hängt Ihren lokalen Projektordner direkt in diesem Container an. Ihr Quellcode und Ihre Quelldaten in dieser ETL-Pipeline sind für die Docker-Umgebung zugänglich. Sie können Ihre Exams sicher in einer isolierten Sandbox ausführen. Klingt cool? Ja, jetzt haben Sie Ihre Umgebung bereits eingerichtet und können mit dem Testen Ihrer ETL-Pipelines beginnen.

Lassen Sie sich durch die Exams sagen, was das System tut

Wenn ich eine unbekannte ETL-Pipeline erbe, lautet meine erste Frage nicht: „Wie funktioniert der Code?“ Stattdessen frage ich: „Welches Verhalten soll das System hervorrufen?“ Exams beantworten diese Frage normalerweise schneller als Quellcode.

Stellen Sie sich vor, das Unternehmen, dem Sie beitreten, verwendet LLMs wie GPT-5.5, Claude 4.6 und Gemini 3 Professional und das Finanzteam möchte die KI-Ausgaben teamübergreifend verfolgen.

Die obige Tabelle zeigt einen Teil der zu speichernden Daten im CSV-Format. Die Spaltennamen müssen standardisiert werden, indem Leerzeichen durch Unterstriche ersetzt werden, damit nachgelagerte Systeme konsistent auf Felder verweisen können. Zum Beispiel. „Modellname“ sollte zu „Modellname“ werden. Du hast es gefunden ingest.py die Funktionen zur Spaltenstandardisierung und Datenaufnahme zu definieren und ai_cost_ingest.py um diese Funktionen im Ordner aufzurufen.

import logging
from typing import Record

from pyspark.sql import SparkSession


def sanitize_columns(columns: Record(str)) -> Record(str):
    return (column.exchange(" ", "_") for column in columns)


def run(spark: SparkSession, ingest_path: str, transformation_path: str) -> None:
    logging.information("Studying textual content file from: %s", ingest_path)

    input_df = (
        spark.learn.format("org.apache.spark.csv")
        .possibility("header", True)
        .csv(ingest_path)
    )

    renamed_columns = sanitize_columns(input_df.columns)

    ref_df = input_df.toDF(*renamed_columns)

    ref_df.write.parquet(transformation_path)

import logging
import sys

from pyspark.sql import SparkSession

from data_ingestions.ai_cost import ingest

LOG_FILENAME = "mission.log"
APP_NAME = "AI_Cost Pipeline: Ingest"

if __name__ == "__main__":
    logging.basicConfig(filename=LOG_FILENAME, stage=logging.INFO)
    logging.information(sys.argv)

    if len(sys.argv) != 3:
        logging.warning("Enter supply and output path are required")
        sys.exit(1)

    spark = SparkSession.builder.appName(APP_NAME).getOrCreate()
    sc = spark.sparkContext
    app_name = sc.appName
    logging.information("Utility Initialized: " + app_name)
    input_path = sys.argv(1)
    output_path = sys.argv(2)
    ingest.run(spark, input_path, output_path)
    logging.information("Utility Finished: " + spark.sparkContext.appName)
    spark.cease()

Sie sollten zunächst die definierten Funktionen verstehen. Sie fragen sich vielleicht: „Was genau soll?“ sanitize_columns() Tun? Behandelt es führende Leerzeichen, nachfolgende Leerzeichen und interne Leerzeichen?“ Mit diesen Fragen im Kopf schreiben Sie folgenden Code:

from data_ingestions.ai_cost import ingest

def test_should_sanitize_nothing() -> None:
    no_whitespace_columns = ("Mannequin")

    precise = ingest.sanitize_columns(no_whitespace_columns)
    anticipated = no_whitespace_columns
    assert anticipated == precise

def test_should_sanitize_whitespace_outside() -> None:
    no_whitespace_columns = (" Immediate Tokens ")

    precise = ingest.sanitize_columns(no_whitespace_columns)
    anticipated = ("_Prompt_Tokens_")
    assert anticipated == precise

def test_should_sanitize_whitespace_in_between() -> None:
    no_whitespace_columns = ("Immediate Tokens")

    precise = ingest.sanitize_columns(no_whitespace_columns)
    anticipated = ("Prompt_Tokens")
    assert anticipated == precise

Mit dem Code können Sie die Funktion testen sanitize_columns() direkt, ohne Spark zu starten und Dateien zu verarbeiten. Es ist ein Beispiel für a Unit-Check.

Unit-Exams

Unit-Exams dienen dazu, einen kleinen Teil der Logik isoliert zu validieren. Sie sind in der Regel schnell, deterministisch und unabhängig von externen Systemen.

Integrationstests

Unit-Exams zeigen an, ob sich ein kleiner Teil der Logik korrekt verhält. Aber sie können die Frage nicht beantworten: „Funktioniert die gesamte Pipeline, wenn alle Komponenten miteinander verbunden sind?“

Für einen Dateningenieur bedeutet dies oft:

• Dateien lesen
• Spark starten
• Transformationen ausführen
• Ausgaben schreiben
• Ergebnisse validieren

Um die gesamte Pipeline zu testen, benötigen wir Integrationstestsdie das Systemverhalten offenbaren. Integrationstests sind beim Onboarding sehr nützlich, da sie beschreiben, was das System tun muss, unabhängig davon, wie sich die Implementierung im Laufe der Zeit weiterentwickelt.

Für die AI_cost Bei einem Datenerfassungsprojekt können Sie einen Integrationstest verwenden, um zu überprüfen, ob:

• Die Eingabe erfolgt als CSV-Dateien.
• Zur Verarbeitung der Daten wird Spark eingesetzt.
• Spaltennamen werden bereinigt.
• Datenwerte bleiben unverändert.
• Die Ausgabe erfolgt im Parquet-Format.
• Der gesamte Aufnahmeworkflow muss erfolgreich sein.

import csv
import os
import tempfile
from pathlib import Path
from typing import Record, Tuple

from pyspark.sql import SparkSession

from data_ingestions.ai_cost import ingest

def test_should_sanitize_column_names(
    spark_session: SparkSession,
) -> None:

    given_ingest_folder, given_transform_folder = (
        __create_ingest_and_transform_folders()
    )

    input_csv_path = given_ingest_folder + "enter.csv"

    csv_content = (
        (
            "Mannequin Identify",
            "Immediate Tokens",
            " Completion Tokens "
        ),
        (
            "GPT-5.5",
            "1200",
            "300"
        ),
        (
            "Gemini 3 Professional",
            "900",
            "250"
        ),
    )

    __write_csv_file(input_csv_path, csv_content)

    ingest.run(
        spark_session,
        input_csv_path,
        given_transform_folder
    )

    precise = spark_session.learn.parquet(
        given_transform_folder
    )

    anticipated = spark_session.createDataFrame(
        (
            ("GPT-5.5", "1200", "300"),
            ("Gemini 3 Professional", "900", "250")
        ),
        (
            "Model_Name",
            "Prompt_Tokens",
            "_Completion_Tokens_"
        )
    )

    assert anticipated.gather() == precise.gather()

Lassen Sie die KI die ETL-Pipeline lesen, bevor Sie es tun

Stellen Sie sich vor, Sie überprüfen eine unbekannte ETL-Pipeline, die Hunderte oder sogar Tausende Zeilen PySpark-Code enthält. Den Code zu verstehen und Exams zu schreiben, kann Stunden oder sogar Tage dauern. Heutzutage können Instruments wie Cursor, Windsurf und GitHub Copilot dabei helfen, diesen Prozess zu beschleunigen.

Nehmen Sie als Beispiel Cursor. Als KI-Assistent kann er ein gesamtes Repository analysieren und Erklärungen zu einzelnen Modulen, Funktionen und Datenflüssen generieren. Es kann auch erste Versionen von Unit-Exams und Integrationstests generieren. Um die Produktivität zu maximieren, müssen Sie als Dateningenieur die richtigen Fragen stellen. Hier einige Beispielfragen, die Sie stellen könnten:

• Was ist der Zweck dieses ETL-Jobs?
• Welche Eingabe- und Ausgabeformate erwartet diese Pipeline?
• Welche Funktionen sind für die Datenvalidierung verantwortlich?
• Welche Randfälle sind derzeit ungetestet?

KI kann Testfälle vorschlagen, aber nicht feststellen, ob diese Exams den Geschäftsanforderungen und der Unternehmensstrategie entsprechen. Es liegt weiterhin in Ihrer Verantwortung, die Pipeline zu verstehen, Annahmen zu validieren und den Code zu überprüfen. KI ist eher ein Produktivitätsbeschleuniger als ein Ersatz für technisches Urteilsvermögen. Es spart Ihnen Zeit, die ETL-Pipeline zu verstehen und zu testen, sodass Sie sich auf höherwertige Knowledge-Engineering-Arbeiten wie das Entwerfen von Datenarchitekturen, den Aufbau skalierbarer Datenplattformen und die Unterstützung datengesteuerter Entscheidungsfindung konzentrieren können.

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.