Das August-Update für Visual Studio Code steht bereit. Unter der Versionsnummer 1.104 hat Microsofts freier Sourcecode-Editor einige KI-Neuerungen an Bord, darunter die automatische Modellauswahl im GitHub Copilot Chat, eine neue Sicherheitsebene für den Agent Mode und die automatische Verwendung von AGENTS.md-Dateien. Zu den weiteren Updates zählen unter anderem farblich hervorgehobene Fensterumrandungen unter Windows und eine Vorschau für Git-Worktree-Änderungen.

Automatische LLM-Auswahl im Copilot Chat

Im GitHub Copilot Chat können Entwicklerinnen und Entwickler nun als Preview-Feature dasjenige Large Language Model (LLM) auswählen lassen, das eine optimale Performance und eine Reduzierung der Rate Limits bieten soll – denn manche Modelle weisen eine stärkere Nutzung auf. Diese Funktion soll zunächst die User mit individuellen Copilot-Abos erreichen und im Verlauf der nächsten Wochen an alle Copilot-Nutzerinnen und -Nutzer ausgespielt werden.

Um die automatische Modellauswahl zu aktivieren, ist im Model Picker die Option Auto anzuklicken. Dann fällt VS Code die Entscheidung zwischen Claude Sonnet 4, GPT-5, GPT-5 mini und GPT-4.1 – sofern das Unternehmen der Entwicklerinnen und Entwickler keines dieser Modelle blockiert hat. Der Name des ausgewählten Modells erscheint beim Hovern über der Antwort in der Chatansicht.

Änderungsbestätigung für Agent Mode

Der Agent Mode in GitHub Copilot erhält derweil eine neue Sicherheitsebene: Er erfordert nun eine explizite Bestätigung, bevor er Änderungen an sensiblen Dateien („sensitive files“) vornimmt. Welche das sind, können Entwicklerinnen und Entwickler mit der Einstellung chat.tools.edits.autoApprove festlegen. Einige Dateien, wie solche außerhalb des Workspace, werden standardmäßig als sensible Dateien behandelt.

Als experimentelles Feature verwendet der Agent Mode zudem automatisch eine AGENTS.md-Datei – sofern diese im Workspace-Root vorhanden ist – als Kontext für Chatanfragen. Mit einer AGENTS.md-Datei lassen sich einem Agenten Kontext und Anweisungen vermitteln.

Updates abseits der KI

Windows-Nutzer können dank der neuen Einstellung window.border ihre VS-Code-Fenster nun mit einem farblich hervorgehobenen Rahmen versehen. Die Farben lassen sich je nach Workspace anpassen, sodass auf einen Blick sichtbar ist, welcher Workspace in welchem Fenster geöffnet ist:

Eine weitere Neuerung betrifft die Versionskontrolle: Eine Vorschau zeigt nun die Änderungen zwischen Worktree-Dateien und dem aktuellen Workspace. Dazu dient ein Rechtsklick auf eine Worktree-Datei, um das Kontextmenü in der Ansicht Source Control Changes zu öffnen. Dort lässt sich dann Compare with Workspace auswählen.

Nach Review der Änderungen können Entwicklerinnen und Entwickler dann den Befehl Migrate Worktree Changes… aus der Befehlspalette verwenden, um alle Änderungen aus einem Worktree in den aktuellen Workspace zu mergen. Das soll es vereinfachen, mit mehreren Worktrees zu arbeiten und Änderungen selektiv in das Haupt-Repository zu übernehmen.

Weitere Informationen zu diesen und zahlreichen anderen neuen Features lassen sich der offiziellen Ankündigung entnehmen.

(mai)

Google hat mit Genkit Go 1.0 die erste stabile Version seines Open-Source-Frameworks für KI-Entwicklung im Go-Ökosystem veröffentlicht. Entwicklerinnen und Entwickler können damit ab sofort produktionsreife KI-Anwendungen erstellen und deployen. Gleichzeitig bringt Google mit dem neuen CLI-Befehl genkit init:ai-tools eine direkte Integration für gängige KI-Coding-Assistenten.

Typsichere KI-Flows erstellen

Eine der spannendsten Neuerungen in Genkit Go 1.0 ist die Möglichkeit, typensichere KI-Flows mit Go-Structs und JSON-Schema-Validierung zu erstellen. Dadurch lassen sich Modellantworten offenbar zuverlässig strukturieren und einfacher testen.

Im folgenden Beispiel aus dem Ankündigungsbeitrag generiert ein Flow ein strukturiertes Rezept:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

// Define your data structures
type RecipeInput struct {
    Ingredient          string `json:"ingredient" jsonschema:"description=Main ingredient or cuisine type"`
    DietaryRestrictions string `json:"dietaryRestrictions,omitempty" jsonschema:"description=Any dietary restrictions"`
}

type Recipe struct {
    Title        string   `json:"title"`
    Description  string   `json:"description"`
    PrepTime     string   `json:"prepTime"`
    CookTime     string   `json:"cookTime"`
    Servings     int      `json:"servings"`
    Ingredients  []string `json:"ingredients"`
    Instructions []string `json:"instructions"`
    Tips         []string `json:"tips,omitempty"`
}

func main() {
    ctx := context.Background()

    // Initialize Genkit with plugins
    g := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.5-flash"),
    )

    // Define a type-safe flow
    recipeFlow := genkit.DefineFlow(g, "recipeGeneratorFlow", 
        func(ctx context.Context, input *RecipeInput) (*Recipe, error) {
            dietaryRestrictions := input.DietaryRestrictions
            if dietaryRestrictions == "" {
                dietaryRestrictions = "none"
            }

            prompt := fmt.Sprintf(`Create a recipe with the following requirements:
                Main ingredient: %s
                Dietary restrictions: %s`, input.Ingredient, dietaryRestrictions)

            // Generate structured data with type safety
            recipe, _, err := genkit.GenerateData[Recipe](ctx, g,
                ai.WithPrompt(prompt),
            )
            if err != nil {
                return nil, fmt.Errorf("failed to generate recipe: %w", err)
            }

            return recipe, nil
        })

    // Run the flow
    recipe, err := recipeFlow.Run(ctx, &RecipeInput{
        Ingredient:          "avocado",
        DietaryRestrictions: "vegetarian",
    })
    if err != nil {
        log.Fatalf("could not generate recipe: %v", err)
    }

    // Print the structured recipe
    recipeJSON, _ := json.MarshalIndent(recipe, "", "  ")
    fmt.Println("Sample recipe generated:")
    fmt.Println(string(recipeJSON))

    <-ctx.Done() // Used for local testing only
}

Hier wird ein Flow (recipeGeneratorFlow) definiert, der Rezepte auf Basis einer Hauptzutat und optionaler Ernährungsvorgaben wie „vegetarian“ generiert. Der Prompt wird dynamisch gebaut, ans KI-Modell (Google Gemini) übergeben und die Antwort in eine klar definierte Go-Datenstruktur (Recipe) zurückgeschrieben. Am Ende läuft der Flow mit der Eingabe „avocado, vegetarisch“ und gibt ein komplettes JSON-Rezept mit Zutaten, Kochzeit und Tipps zurück.

Anbindung an gängige Sprachmodelle

Darüber hinaus haben Developer mit Genkit Go 1.0 die Möglichkeit, externe APIs über Tool Calling einzubinden und Modelle von Google AI, Vertex AI, OpenAI, Anthropic und Ollama über eine einheitliche Schnittstelle zu nutzen. Die Bereitstellung soll unkompliziert als HTTP-Endpoint erfolgen. Eine Standalone-CLI sowie eine interaktive Developer UI unterstützen beim Schreiben von Tests, Debugging und Monitoring.

Der neue Befehl genkit init:ai-tools richtet automatisch KI-Assistenztools wie Gemini CLI, Firebase Studio, Claude Code und Cursor ein. Somit können Entwicklerinnen und Entwickler damit direkt die Genkit-Dokumentation durchsuchen, Flows testen, Debug-Traces ausführen und Go-Code nach Best Practices generieren.

(mdo)

In den Weiten des Volkswagen-Konzerns darf sich kaum eine Marke optisch so weit vorwagen wie Cupra. Tatsächlich seriennah dürfte die Studie Tindaya kaum sein, und doch ist die spektakuläre Formgebung mehr als nur ein Blickfang auf der IAA. Der Name Tindaya, nach einem Vulkan auf der Insel Fuerteventura, ist dabei durchaus Programm.

Terramar, Tavascan, Formentor und auch noch der Ateca, dessen Produktion absehbar ausläuft: An SUVs mangelt es der Marke Cupra derzeit wahrlich nicht. Ist dort perspektivisch Platz für ein weiteres Modell mit rund 4,7 m Länge? Ja, befanden offenbar die Verantwortlichen. Die Studie Tindaya ist 4,72 m lang und ausschließlich auf batterieelektrische Antriebe ausgerichtet. Welche Plattform in einem Serienmodell genutzt werden würde, ist aktuell noch zweitrangig. Viel spricht dafür, dass es die Basis des kommenden VW ID.4 sein könnte.

23-Zoll-Felgen

Das kantig-faltige Design ist bewusst überzeichnet. Allein schon der gesetzliche Fußgängerschutz würde einem Serieneinsatz dieser Front vermutlich entgegenstehen. Riesige Radhäuser, in denen selbst 23-Zoll-Felgen samt Reifen mit geringer Flankenhöhe nicht übertrieben scheinen, haben da vermutlich bessere Chancen. Innen gibt es vier Einzelsitze, ein 24-Zoll-Display, ein Lenkrad im Gaming-Stil und eine Mittelkonsole, die an die 2023er-Studie des Lamborghini Lanzador erinnert. In der Mitte der bis in den Fond durchgehenden Konsole befindet sich ein Zentralknopf, mit dem sich verschiedene Funktionen ansteuern lassen.

250 kW Leistung im Spitzenmodell – mindestens

Ein aufregend gestaltetes Serienmodell würde sich bei den Antriebskomponenten vermutlich im Baukasten des Konzerns bedienen. Hinter- wie Allradantrieb wären damit möglich. Das Leistungsangebot dürfte sich zwischen 210 und 250 kW bewegen, wobei wir damit rechnen, dass sich Volkswagen irgendwann genötigt sehen könnte, in dieser Hinsicht nachzulegen. Ein Ende des Wettrüstens ist schließlich nicht abzusehen – ganz im Gegenteil: Der Umstieg auf Elektromobilität macht mehr Leistung vergleichsweise problemlos möglich, was eher Folgen für die Verkehrssicherheit haben wird als auf den Bedarf an Fahrenergie.

Bild 1 von 7

Unter anderem Volkswagen hat mit dem E-Motor APP550 gezeigt, dass sich selbst 210 kW Spitzenleistung potenziell mitführen lassen, ohne beim Verbrauch dramatisch über dem zu liegen, was ein elektrischer Kleinwagen wie der Opel Corsa-e auch braucht. Auch in dieser Hinsicht unterscheiden sich Verbrenner und batterieelektrischer Antrieb enorm. Das Potenzial eines aufgeladenen V8 wird auch bei gemäßigter Fahrweise immer ein Stück weit zu füttern sein. Beim ungleich effizienteren E-Motor steigt der Verbrauch erst dann, wenn die Leistung abgerufen wird.

Ladeleistung: 200 kW plus X

Zweigeteilt ist die Welt bei Volkswagen hinsichtlich der Ladeleistung. Audi und Porsche haben schon Modelle mit 800 Volt Spannungsebene, was Ladeleistung von deutlich mehr als 200 kW an der gängigen, mit 500 Ampere abgesicherten Ladeinfrastruktur erlaubt. Marken wie Skoda, VW und eben auch Cupra nutzen derzeit ein 400-Volt-System. Damit ist an Ladesäulen mit 500 A bei 200 kW die Spitze erreicht. Mittelfristig werden auch andere Konzernmarken Elektroautos mit 800 Volt ins Sortiment aufnehmen. Ob ein Serienableger der Studie Tindaya dazu gehören könnte, ist ungewiss.

(mfz)