Wie ich lernte, mich nicht mehr zu sorgen und LLMs zu lieben

Im Meer der KI gibt es eine neue Bedrohung am Horizont: Große Sprachmodelle (LLMs) und darauf aufbauende Produkte wie ChatGPT und GitHub Copilot. Sind sie ein Tsunami, der uns mitreißen wird, oder eine riesige Welle, auf der wir lernen müssen zu reiten?

Um das zu untersuchen, begann ich mit einem konkreten Problem, das ich lösen musste: eine Erinnerung, um unsere Kunden per SMS zu informieren, und zwar in großen Mengen. Mit ChatGPT habe ich eine Anwendung in einer neuen Programmiersprache, Go, in wenigen Minuten statt in Tagen erstellt. Ich werde Ihnen erläutern, wie ich das gemacht habe und wie es war. Abschließend möchte ich darüber nachdenken, dass LLMs für Programmierer, die in der Falle sitzen, immer wieder dieselben Dinge mit minimalen Abweichungen zu tun, zu einem beängstigenden Tsunami werden können. Für flinke Programmierer sind LLMs jedoch eine unglaubliche Welle, auf der man reiten kann: Sie surfen höher und schneller, wenn Sie Ihre Züge kennen, und das macht eine Menge Spaß.

Seit der Einführung von GitHub Copilot und ChatGPT sagen einige Leute, dass Programmierer, wie wir sie heute kennen, verschwinden werden. Andere hingegen sagen, dass es den Programmierern gut gehen wird, solange die Tools nur eine statistisch wahrscheinliche Antwort ausspucken, ohne zu verstehen, was Sie fragen.

Heutzutage programmiere ich nicht mehr viel, so dass es schwierig ist, sich eine Meinung aus erster Hand zu bilden. Das hat sich letzte Woche geändert. Einige Kunden baten uns, an eine bevorstehende Schulung erinnert zu werden, und wir wollten eine SMS statt einer E-Mail versenden. Da wir dafür kein System hatten, bat mich ein Kollege um Rat. Ich wusste, dass Messaging-Plattformen APIs für den SMS-Versand anbieten, also sagte ich ihm, dass ich ein Tool für diese Aufgabe entwickeln würde. Die Auswahl einer Plattform war einfach: Ich weiß, dass MessageBird diesen Dienst anbietet, in der Nähe unseres Amsterdamer Büros liegt und derzeit mit Gegenwind zu kämpfen hat. Das ist das Äquivalent zu einem Bauernmarkt für eine API, dachte ich, also erstellte ich ein Konto.

MessageBird bietet Python-Anbindungen für den Versand von SMS über eine einfache API:

client = messagebird.Client(ACCESS_KEY)
message = client.message_create( 
    sender, 
    receiver, 
    message_text 
)

Da ich mich mit Python noch gut auskenne, sollte es schnell gehen, eine Anwendung dafür zu programmieren.

Aber dann dämmerte es mir: Wenn ein Kollege das nächste Mal Massen-SMS verschicken muss, werde ich das für ihn tun müssen, denn eine funktionierende Python-Umgebung zu schaffen, ist schwierig, wenn man kein Techniker ist. Was könnte ich tun, um nicht zum Engpass zu werden? Go, eine Sprache, die bei Google entwickelt wurde, wäre eine Option gewesen, denn sie ermöglicht es, Code auszuführen, ohne irgendetwas auf einem Computer zu installieren, egal ob Mac, Windows oder Linux. Und MessageBird bietet eine Go-API! Das einzige Problem: Ich habe noch nie in Go programmiert, und mein Kalender hat nur so viele freie Termine!

KI-gestützte Entwicklung

Ich las jedoch einen Beitrag des Mitbegründers von Django darüber, wie er dank der KI-gestützten Entwicklung ehrgeiziger mit seinen Projekten wurde. Ich musste es versuchen und begann mit der MessageBird Go API Dokumentation:

client := messagebird.New("YOUR_ACCESS_KEY") 
message, err := sms.Create(client, 
  sender, 
  []string{receiver}, 
  message_text
)

Der Code ähnelt dem Python-Schnipsel, mit einigen rätselhaften Syntaxen wie []string{receiver} und dem err, der herumliegt. Ich habe beschlossen, es auszuprobieren!

Von Menschenhand geschaffene Architektur

Zunächst einmal: Wie sollte das Programm aufgebaut sein? Ich habe mir nicht die Mühe gemacht, ChatGPT zu fragen, da das Erklären der Anforderungen wahrscheinlich mehr Zeit in Anspruch nehmen würde, als es einfach zu tun.

Um Programmierer durch KI zu ersetzen, müssen die Kunden genau beschreiben, was sie wollen.

Wir sind sicher. #softwareengineering #programmierung

- Dr. Milan Milanović (@milan_milanovic) February 5, 2023

Für den Anfang nehme ich an, dass meine Daten wie Tabelle 1 aussehen (aber ohne Kopfzeilen) und in einer CSV-Datei gespeichert werden.

Tabelle 1: Die CSV-Datei mit den Namen und Telefonnummern unserer Kunden

Name	Telefon
John	12345
Maria	54321

Danach muss ich, wie in der Dokumentation beschrieben, den MessageBird client erstellen und ihm den Zugangsschlüssel übergeben. Dann sollte ich die CSV-Datei mit den Datensätzen lesen, jeden Datensatz nach Name und Telefonnummer aufteilen und für jeden Datensatz eine SMS senden. Ich könnte die Kunden mit ihrem Vornamen ansprechen, um es persönlicher zu gestalten.

Der Zugriffsschlüssel ist jedoch ein Geheimnis und sollte nicht in dem von mir geschriebenen Code enthalten sein. Wie sollte ich dies in Go angehen?

ChatGPT für eine Spritztour mitnehmen

Zeit, unseren neuen KI-Overlord auszuprobieren:

F: Wie übergibt man Geheimnisse an ein Golang-Programm?

A: Die Verwendung von Umgebungsvariablen ist der richtige Weg, um Geheimnisse, wie API-Schlüssel oder sensible Konfigurationsdaten, an ein Golang-Programm zu übergeben.

Der Code schlug vor:

// GENERATED BY CHATGPT, EXCLUDING THIS COMMENT
package main  

import (  
    "fmt"  
    "os"  
)  

func main() {  
    secretKey := os.Getenv("MY_SECRET_KEY")  
    if secretKey == "" {  
        fmt.Println("MY_SECRET_KEY environment variable is not set")  
        os.Exit(1)  
    }  

    fmt.Println("My secret key is:", secretKey)  
}  

Großartig! Jetzt kann ich die Informationen aus den MessageBird-Dokumenten verwenden, um den Client mit dem secretKey zu erstellen. Als Nächstes muss ich eine CSV-Datei einlesen und eine Schleife über jede Zeile ziehen:

F: Wie lese ich eine CSV-Datei in Go und führe dann eine Schleife über jeden Datensatz?

// GENERATED BY CHATGPT, EXCLUDING THIS COMMENT
package main  

import (  
    "encoding/csv"  
    "fmt"  
    "log"  
    "os"  
)  

func main() {  
    // Open the CSV file  
    file, err := os.Open("data.csv")  
    if err != nil {  
        log.Fatal("Error opening the file:", err)  
    }  
    defer file.Close()  

    // Create a new CSV reader  
    reader := csv.NewReader(file)  

    // Read the header line (if present)  
    header, err := reader.Read()  
    if err != nil {  
        log.Fatal("Error reading the header:", err)  
    }  
    fmt.Println("Header:", header)  

    // Loop over the records  
    for {  
        record, err := reader.Read()  
        if err != nil {  
            break  
        }  
        fmt.Println("Record:", record)  
    }  

Das ist großartig, aber ich muss auf einzelne Felder im Datensatz zugreifen.

F: Wie kann ich einen Datensatz, der aus reader.Read() in go kommt, aufteilen, so dass ich mit jedem Feld etwas machen kann?

Es kam eine lange Antwort mit der richtigen Lösung, die im Code vergraben war, aber nicht genau das, wonach ich gefragt hatte. Beachten Sie auch, dass ich golang, go oder Go austauschbar verwenden kann. Die KI weiß das.

A: Wenn Sie einen Datensatz mit reader.Read() aus dem Encoding/csv-Paket in Go lesen, wird ein Slice von Strings zurückgegeben

// GENERATED BY CHATGPT, EXCLUDING THIS COMMENT
// stuff omitted for brevity
for {  
  record, err := reader.Read()  
  if err != nil {  
    break  
  }  
  // Process each field in the record  
  for i, field := range record {  
    fmt.Printf("Field %d (%s): %sn", i, header[i], field)  
  }  
  fmt.Println("----")  
    }  

Ah, header[i], so machen Sie es. Großartig! Jetzt habe ich alle Zutaten und muss nur noch eine Funktion erstellen, die den Namen, die Telefonnummer, einen MessageBird-Client und einen Absender aufnimmt und die SMS versendet!

F: Wie erstelle ich eine Funktion in go?

// GENERATED BY CHATGPT, EXCLUDING THIS COMMENT
func add(a int, b int) int {  
    sum := a + b  
    return sum  
}

OK, das scheint einfach zu sein. Jetzt bin ich mit dem Code dran:

func sendMessage(client, text str, sender str, recipient str, name str) {
    msg, err := sms.Create(
        client,
        sender,
        []string{recipient},
        text,
        nil,
    )
    if err != nil {
        log.Println(err)
    }
}

OK, fast geschafft. Dieser Code hat zwei Probleme:

1. client hat keinen Typ in der Funktionssignatur, und das mag Go nicht!
2. Ich möchte die Variable name in die Variable text interpolieren, um die Nachricht zu personalisieren.

Der letzte Schliff

F: Wie finde ich den Typ einer Go-Variablen heraus?

ChatGPT antwortete: fmt.Printf("Type of var1 (%v) is: %Tn", var1, var1). Nachdem ich das Snippet ausgeführt hatte, erhielt ich , was genau das war, was der Arzt verordnet hatte. Später, nachdem ich NeoVim mit dem Go Language Server-Protokoll(LSP) eingerichtet hatte, schlug der Editor den Typ praktischerweise automatisch vor.

F: Wie führe ich in Go eine String-Interpolation durch?

Die lange Antwort enthielt die Informationen, die ich brauchte: message := fmt.Sprintf("%s is %d years old and lives in %s.", name, age, city). Mein Code zum Senden der SMS lautet nun also:

func sendMessage(client *messageBird.Client, text str, sender str, recipient str, name str) {
  msg, err := sms.Create(
    client,
    sender,
    []string{recipient},
    fmt.Sprintf(text, name)  // text should have a single %s where the name should be!!!! ) if err != nil { log.Println(err) } } 

Alles zusammenfügen

Ich habe das Puzzle mit allen Teilen aus ChatGPT und der Dokumentation von MessageBird zusammengesetzt:

package main

import (
    "encoding/csv"
    "fmt"
    "log"
    "os"

    messagebird "github.com/messagebird/go-rest-api"
    "github.com/messagebird/go-rest-api/sms"
)

func sendMessage(client *messagebird.Client, text string, sender string, recipient string, name string) {
    msg, err := sms.Create(
        client,
        sender,
        []string{recipient},
        fmt.Sprintf(text, name), // text should have a single %s where the name should be!!!! nil, ) if err != nil { log.Println(err) } log.Println(msg) } func main() { secretKey := os.Getenv("MESSAGE_BIRD_API") if secretKey == "" { fmt.Println("MESSAGE_BIRD_API environment variable is not set") os.Exit(1) } client := messagebird.New(secretKey) // Open the CSV file file, err := os.Open("data.csv") if err != nil { log.Fatal("Error opening the file:", err) } defer file.Close() // Create a new CSV reader reader := csv.NewReader(file) // Loop over the records for { record, err := reader.Read() if err != nil { break } sendMessage(client, "Hey %s", "Xebia", record[1], record[0]) // assuming the csv file has the format name, phone } } 

Das ist alles, was Sie wissen müssen. Zeit, ihn zu starten?

F: Wie führe ich ein Go-Programm durch?

A: go run main.go

Nun, das hat bei ChatGPT nicht funktioniert. Meine Konsole beschwerte sich über eine fehlende go.mod Datei.

F: Wie erstelle ich die Datei go.mod in einem Go-Projekt?

Die Antwort lautete go mod init example.com/myproject. Danach erhielt ich einige Fehlermeldungen über fehlende Module, aber Go war so freundlich, mir zu sagen, wie ich sie beheben kann:

go get github.com/messagebird/go-rest-api/
go get github.com/messagebird/go-rest-api/sms

Ein funktionierendes Projekt zu haben, ist großartig, weil ich danach neue Funktionen Stück für Stück hinzufügen kann. Seitdem habe ich das Konfigurationsmanagement, die Schemaflexibilität und das Templating hinzugefügt. Im Geiste von Open Source habe ich das Repository auf GitHub veröffentlicht, damit jeder davon profitieren kann. Ich habe noch ein paar TODOs (zusätzliche Dokumentation und Tests) und möchte Copilot nutzen, um sie anzugehen. Mehr dazu in einem zukünftigen Beitrag.

Blick nach vorn

Die Geschwindigkeit, mit der ich funktionierenden Code in einer neuen Sprache erstellen konnte, war erstaunlich, und ich denke, dass dies zwei wesentliche Konsequenzen haben wird. Erstens: Wenn Ihr gesamter Code aus kleinen, sich wiederholenden Teilen besteht - das Schreiben eines SQL-Skripts von einem SQL-Dialekt in einen anderen, die Dokumentation, das Erstellen einfacher APIs auf der Grundlage von Datenbanken -, dann sollten Sie lernen, LLMs Prompting zu beherrschen, oder jemand anderes wird Ihren Platz einnehmen.

Es gibt einfach keine Möglichkeit, dass ChatGPT oder ein LLM, der auf diese Aufgabe eingestellt ist, nicht herausfinden kann, was Sie mit minimaler Aufsicht tun. Zweitens werden geschickte Programmierer, die in einem neuen Bereich anfangen oder experimentieren, viel Spaß haben.

Sie können das Denken auf hoher Ebene übernehmen, die LLMs zeitaufwändige, einfache Probleme lösen lassen, ihre Ergebnisse überprüfen - da sie im Moment nicht verstehen, was Sie ihnen sagen - und dann die Teile zusammensetzen.