[{"data":1,"prerenderedAt":1230},["ShallowReactive",2],{"/de-de/blog/categories/ai-ml/":3,"navigation-de-de":22,"banner-de-de":443,"footer-de-de":456,"ai-ml-category-page-de-de":666},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"seo":8,"content":11,"config":12,"_id":15,"_type":16,"title":17,"_source":18,"_file":19,"_stem":20,"_extension":21},"/de-de/blog/categories/ai-ml","categories",false,"",{"title":9,"description":10},"KI/ML","Browse articles related to KI/ML on the GitLab Blog",{"name":9},{"template":13,"slug":14,"hide":6},"BlogCategory","ai-ml","content:de-de:blog:categories:ai-ml.yml","yaml","Ai Ml","content","de-de/blog/categories/ai-ml.yml","de-de/blog/categories/ai-ml","yml",{"_path":23,"_dir":24,"_draft":6,"_partial":6,"_locale":7,"data":25,"_id":439,"_type":16,"title":440,"_source":18,"_file":441,"_stem":442,"_extension":21},"/shared/de-de/main-navigation","de-de",{"logo":26,"freeTrial":31,"sales":36,"login":41,"items":46,"search":380,"minimal":416,"duo":430},{"config":27},{"href":28,"dataGaName":29,"dataGaLocation":30},"/de-de/","gitlab logo","header",{"text":32,"config":33},"Kostenlose Testversion anfordern",{"href":34,"dataGaName":35,"dataGaLocation":30},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":37,"config":38},"Vertrieb kontaktieren",{"href":39,"dataGaName":40,"dataGaLocation":30},"/de-de/sales/","sales",{"text":42,"config":43},"Anmelden",{"href":44,"dataGaName":45,"dataGaLocation":30},"https://gitlab.com/users/sign_in/","sign in",[47,91,190,195,301,361],{"text":48,"config":49,"cards":51,"footer":74},"Plattform",{"dataNavLevelOne":50},"platform",[52,58,66],{"title":48,"description":53,"link":54},"Die umfassendste KI-basierte DevSecOps-Plattform",{"text":55,"config":56},"Erkunde unsere Plattform",{"href":57,"dataGaName":50,"dataGaLocation":30},"/de-de/platform/",{"title":59,"description":60,"link":61},"GitLab Duo (KI)","Entwickle Software schneller mit KI in jeder Phase der Entwicklung",{"text":62,"config":63},"Lerne GitLab Duo kennen",{"href":64,"dataGaName":65,"dataGaLocation":30},"/de-de/gitlab-duo/","gitlab duo ai",{"title":67,"description":68,"link":69},"Gründe, die für GitLab sprechen","10 Gründe, warum Unternehmen sich für GitLab entscheiden",{"text":70,"config":71},"Mehr erfahren",{"href":72,"dataGaName":73,"dataGaLocation":30},"/de-de/why-gitlab/","why gitlab",{"title":75,"items":76},"Erste Schritte mit",[77,82,87],{"text":78,"config":79},"Platform Engineering",{"href":80,"dataGaName":81,"dataGaLocation":30},"/de-de/solutions/platform-engineering/","platform engineering",{"text":83,"config":84},"Entwicklererfahrung",{"href":85,"dataGaName":86,"dataGaLocation":30},"/de-de/developer-experience/","Developer experience",{"text":88,"config":89},"MLOps",{"href":90,"dataGaName":88,"dataGaLocation":30},"/de-de/topics/devops/the-role-of-ai-in-devops/",{"text":92,"left":93,"config":94,"link":96,"lists":100,"footer":172},"Produkt",true,{"dataNavLevelOne":95},"solutions",{"text":97,"config":98},"Alle Lösungen anzeigen",{"href":99,"dataGaName":95,"dataGaLocation":30},"/de-de/solutions/",[101,127,150],{"title":102,"description":103,"link":104,"items":109},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":105},{"icon":106,"href":107,"dataGaName":108,"dataGaLocation":30},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[110,114,118,123],{"text":111,"config":112},"CI/CD",{"href":113,"dataGaLocation":30,"dataGaName":111},"/de-de/solutions/continuous-integration/",{"text":115,"config":116},"KI-unterstützte Entwicklung",{"href":64,"dataGaLocation":30,"dataGaName":117},"AI assisted development",{"text":119,"config":120},"Quellcodeverwaltung",{"href":121,"dataGaLocation":30,"dataGaName":122},"/de-de/solutions/source-code-management/","Source Code Management",{"text":124,"config":125},"Automatisierte Softwarebereitstellung",{"href":107,"dataGaLocation":30,"dataGaName":126},"Automated software delivery",{"title":128,"description":129,"link":130,"items":135},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":131},{"href":132,"dataGaName":133,"dataGaLocation":30,"icon":134},"/de-de/solutions/security-compliance/","security and compliance","ShieldCheckLight",[136,140,145],{"text":137,"config":138},"Sicherheit und Compliance",{"href":132,"dataGaLocation":30,"dataGaName":139},"Security & Compliance",{"text":141,"config":142},"Schutz der Software-Lieferkette",{"href":143,"dataGaLocation":30,"dataGaName":144},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":146,"config":147},"Compliance und Governance",{"href":148,"dataGaLocation":30,"dataGaName":149},"/de-de/solutions/continuous-software-compliance/","Compliance and governance",{"title":151,"link":152,"items":157},"Bewertung",{"config":153},{"icon":154,"href":155,"dataGaName":156,"dataGaLocation":30},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[158,162,167],{"text":159,"config":160},"Sichtbarkeit und Bewertung",{"href":155,"dataGaLocation":30,"dataGaName":161},"Visibility and Measurement",{"text":163,"config":164},"Wertstrommanagement",{"href":165,"dataGaLocation":30,"dataGaName":166},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":168,"config":169},"Analysen und Einblicke",{"href":170,"dataGaLocation":30,"dataGaName":171},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":173,"items":174},"GitLab für",[175,180,185],{"text":176,"config":177},"Enterprise",{"href":178,"dataGaLocation":30,"dataGaName":179},"/de-de/enterprise/","enterprise",{"text":181,"config":182},"Kleinunternehmen",{"href":183,"dataGaLocation":30,"dataGaName":184},"/de-de/small-business/","small business",{"text":186,"config":187},"den öffentlichen Sektor",{"href":188,"dataGaLocation":30,"dataGaName":189},"/de-de/solutions/public-sector/","public sector",{"text":191,"config":192},"Preise",{"href":193,"dataGaName":194,"dataGaLocation":30,"dataNavLevelOne":194},"/de-de/pricing/","pricing",{"text":196,"config":197,"link":199,"lists":203,"feature":288},"Ressourcen",{"dataNavLevelOne":198},"resources",{"text":200,"config":201},"Alle Ressourcen anzeigen",{"href":202,"dataGaName":198,"dataGaLocation":30},"/de-de/resources/",[204,237,260],{"title":205,"items":206},"Erste Schritte",[207,212,217,222,227,232],{"text":208,"config":209},"Installieren",{"href":210,"dataGaName":211,"dataGaLocation":30},"/de-de/install/","install",{"text":213,"config":214},"Kurzanleitungen",{"href":215,"dataGaName":216,"dataGaLocation":30},"/de-de/get-started/","quick setup checklists",{"text":218,"config":219},"Lernen",{"href":220,"dataGaLocation":30,"dataGaName":221},"https://university.gitlab.com/","learn",{"text":223,"config":224},"Produktdokumentation",{"href":225,"dataGaName":226,"dataGaLocation":30},"https://docs.gitlab.com/","product documentation",{"text":228,"config":229},"Best-Practice-Videos",{"href":230,"dataGaName":231,"dataGaLocation":30},"/de-de/getting-started-videos/","best practice videos",{"text":233,"config":234},"Integrationen",{"href":235,"dataGaName":236,"dataGaLocation":30},"/de-de/integrations/","integrations",{"title":238,"items":239},"Entdecken",[240,245,250,255],{"text":241,"config":242},"Kundenerfolge",{"href":243,"dataGaName":244,"dataGaLocation":30},"/customers/","customer success stories",{"text":246,"config":247},"Blog",{"href":248,"dataGaName":249,"dataGaLocation":30},"/de-de/blog/","blog",{"text":251,"config":252},"Remote",{"href":253,"dataGaName":254,"dataGaLocation":30},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":256,"config":257},"TeamOps",{"href":258,"dataGaName":259,"dataGaLocation":30},"/de-de/teamops/","teamops",{"title":261,"items":262},"Vernetzen",[263,268,273,278,283],{"text":264,"config":265},"GitLab-Services",{"href":266,"dataGaName":267,"dataGaLocation":30},"/de-de/services/","services",{"text":269,"config":270},"Community",{"href":271,"dataGaName":272,"dataGaLocation":30},"/community/","community",{"text":274,"config":275},"Forum",{"href":276,"dataGaName":277,"dataGaLocation":30},"https://forum.gitlab.com/","forum",{"text":279,"config":280},"Veranstaltungen",{"href":281,"dataGaName":282,"dataGaLocation":30},"/events/","events",{"text":284,"config":285},"Partner",{"href":286,"dataGaName":287,"dataGaLocation":30},"/de-de/partners/","partners",{"backgroundColor":289,"textColor":290,"text":291,"image":292,"link":296},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":293,"config":294},"the source promo card",{"src":295},"/images/navigation/the-source-promo-card.svg",{"text":297,"config":298},"Lies die News",{"href":299,"dataGaName":300,"dataGaLocation":30},"/de-de/the-source/","the source",{"text":302,"config":303,"lists":305},"Unternehmen",{"dataNavLevelOne":304},"company",[306],{"items":307},[308,313,319,321,326,331,336,341,346,351,356],{"text":309,"config":310},"Über",{"href":311,"dataGaName":312,"dataGaLocation":30},"/de-de/company/","about",{"text":314,"config":315,"footerGa":318},"Karriere",{"href":316,"dataGaName":317,"dataGaLocation":30},"/jobs/","jobs",{"dataGaName":317},{"text":279,"config":320},{"href":281,"dataGaName":282,"dataGaLocation":30},{"text":322,"config":323},"Geschäftsführung",{"href":324,"dataGaName":325,"dataGaLocation":30},"/company/team/e-group/","leadership",{"text":327,"config":328},"Team",{"href":329,"dataGaName":330,"dataGaLocation":30},"/company/team/","team",{"text":332,"config":333},"Handbuch",{"href":334,"dataGaName":335,"dataGaLocation":30},"https://handbook.gitlab.com/","handbook",{"text":337,"config":338},"Investor Relations",{"href":339,"dataGaName":340,"dataGaLocation":30},"https://ir.gitlab.com/","investor relations",{"text":342,"config":343},"Trust Center",{"href":344,"dataGaName":345,"dataGaLocation":30},"/de-de/security/","trust center",{"text":347,"config":348},"AI Transparency Center",{"href":349,"dataGaName":350,"dataGaLocation":30},"/de-de/ai-transparency-center/","ai transparency center",{"text":352,"config":353},"Newsletter",{"href":354,"dataGaName":355,"dataGaLocation":30},"/company/contact/","newsletter",{"text":357,"config":358},"Presse",{"href":359,"dataGaName":360,"dataGaLocation":30},"/press/","press",{"text":362,"config":363,"lists":364},"Kontakt",{"dataNavLevelOne":304},[365],{"items":366},[367,370,375],{"text":37,"config":368},{"href":39,"dataGaName":369,"dataGaLocation":30},"talk to sales",{"text":371,"config":372},"Support",{"href":373,"dataGaName":374,"dataGaLocation":30},"/support/","get help",{"text":376,"config":377},"Kundenportal",{"href":378,"dataGaName":379,"dataGaLocation":30},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":381,"login":382,"suggestions":389},"Schließen",{"text":383,"link":384},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":385,"config":386},"gitlab.com",{"href":44,"dataGaName":387,"dataGaLocation":388},"search login","search",{"text":390,"default":391},"Vorschläge",[392,395,400,402,407,412],{"text":59,"config":393},{"href":64,"dataGaName":394,"dataGaLocation":388},"GitLab Duo (AI)",{"text":396,"config":397},"Code Suggestions (KI)",{"href":398,"dataGaName":399,"dataGaLocation":388},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":111,"config":401},{"href":113,"dataGaName":111,"dataGaLocation":388},{"text":403,"config":404},"GitLab auf AWS",{"href":405,"dataGaName":406,"dataGaLocation":388},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":408,"config":409},"GitLab auf Google Cloud",{"href":410,"dataGaName":411,"dataGaLocation":388},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":413,"config":414},"Warum GitLab?",{"href":72,"dataGaName":415,"dataGaLocation":388},"Why GitLab?",{"freeTrial":417,"mobileIcon":422,"desktopIcon":427},{"text":418,"config":419},"Kostenlos testen",{"href":420,"dataGaName":35,"dataGaLocation":421},"https://gitlab.com/-/trials/new/","nav",{"altText":423,"config":424},"GitLab-Symbol",{"src":425,"dataGaName":426,"dataGaLocation":421},"/images/brand/gitlab-logo-tanuki.svg","gitlab icon",{"altText":423,"config":428},{"src":429,"dataGaName":426,"dataGaLocation":421},"/images/brand/gitlab-logo-type.svg",{"freeTrial":431,"mobileIcon":435,"desktopIcon":437},{"text":432,"config":433},"Erfahre mehr über GitLab Duo",{"href":64,"dataGaName":434,"dataGaLocation":421},"gitlab duo",{"altText":423,"config":436},{"src":425,"dataGaName":426,"dataGaLocation":421},{"altText":423,"config":438},{"src":429,"dataGaName":426,"dataGaLocation":421},"content:shared:de-de:main-navigation.yml","Main Navigation","shared/de-de/main-navigation.yml","shared/de-de/main-navigation",{"_path":444,"_dir":24,"_draft":6,"_partial":6,"_locale":7,"title":445,"titleMobile":445,"button":446,"config":451,"_id":453,"_type":16,"_source":18,"_file":454,"_stem":455,"_extension":21},"/shared/de-de/banner","GitLab 18 und der nächste Schritt im Bereich der intelligenten DevSecOps. Sei am 24. Juni dabei.",{"text":447,"config":448},"Jetzt registrieren",{"href":449,"dataGaName":450,"dataGaLocation":30},"/de-de/eighteen/","gitlab 18 banner",{"layout":452},"release","content:shared:de-de:banner.yml","shared/de-de/banner.yml","shared/de-de/banner",{"_path":457,"_dir":24,"_draft":6,"_partial":6,"_locale":7,"data":458,"_id":662,"_type":16,"title":663,"_source":18,"_file":664,"_stem":665,"_extension":21},"/shared/de-de/main-footer",{"text":459,"source":460,"edit":466,"contribute":471,"config":476,"items":481,"minimal":654},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":461,"config":462},"Quelltext der Seite anzeigen",{"href":463,"dataGaName":464,"dataGaLocation":465},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":467,"config":468},"Diese Seite bearbeiten",{"href":469,"dataGaName":470,"dataGaLocation":465},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":472,"config":473},"Beteilige dich",{"href":474,"dataGaName":475,"dataGaLocation":465},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":477,"facebook":478,"youtube":479,"linkedin":480},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[482,505,560,589,624],{"title":48,"links":483,"subMenu":488},[484],{"text":485,"config":486},"DevSecOps-Plattform",{"href":57,"dataGaName":487,"dataGaLocation":465},"devsecops platform",[489],{"title":191,"links":490},[491,495,500],{"text":492,"config":493},"Tarife anzeigen",{"href":193,"dataGaName":494,"dataGaLocation":465},"view plans",{"text":496,"config":497},"Vorteile von Premium",{"href":498,"dataGaName":499,"dataGaLocation":465},"/de-de/pricing/premium/","why premium",{"text":501,"config":502},"Vorteile von Ultimate",{"href":503,"dataGaName":504,"dataGaLocation":465},"/de-de/pricing/ultimate/","why ultimate",{"title":506,"links":507},"Lösungen",[508,513,516,518,523,528,532,535,538,543,545,547,550,555],{"text":509,"config":510},"Digitale Transformation",{"href":511,"dataGaName":512,"dataGaLocation":465},"/de-de/solutions/digital-transformation/","digital transformation",{"text":137,"config":514},{"href":132,"dataGaName":515,"dataGaLocation":465},"security & compliance",{"text":124,"config":517},{"href":107,"dataGaName":108,"dataGaLocation":465},{"text":519,"config":520},"Agile Entwicklung",{"href":521,"dataGaName":522,"dataGaLocation":465},"/de-de/solutions/agile-delivery/","agile delivery",{"text":524,"config":525},"Cloud-Transformation",{"href":526,"dataGaName":527,"dataGaLocation":465},"/de-de/solutions/cloud-native/","cloud transformation",{"text":529,"config":530},"SCM",{"href":121,"dataGaName":531,"dataGaLocation":465},"source code management",{"text":111,"config":533},{"href":113,"dataGaName":534,"dataGaLocation":465},"continuous integration & delivery",{"text":163,"config":536},{"href":165,"dataGaName":537,"dataGaLocation":465},"value stream management",{"text":539,"config":540},"GitOps",{"href":541,"dataGaName":542,"dataGaLocation":465},"/de-de/solutions/gitops/","gitops",{"text":176,"config":544},{"href":178,"dataGaName":179,"dataGaLocation":465},{"text":181,"config":546},{"href":183,"dataGaName":184,"dataGaLocation":465},{"text":548,"config":549},"Öffentlicher Sektor",{"href":188,"dataGaName":189,"dataGaLocation":465},{"text":551,"config":552},"Bildungswesen",{"href":553,"dataGaName":554,"dataGaLocation":465},"/de-de/solutions/education/","education",{"text":556,"config":557},"Finanzdienstleistungen",{"href":558,"dataGaName":559,"dataGaLocation":465},"/de-de/solutions/finance/","financial services",{"title":196,"links":561},[562,564,566,568,571,573,575,577,579,581,583,585,587],{"text":208,"config":563},{"href":210,"dataGaName":211,"dataGaLocation":465},{"text":213,"config":565},{"href":215,"dataGaName":216,"dataGaLocation":465},{"text":218,"config":567},{"href":220,"dataGaName":221,"dataGaLocation":465},{"text":223,"config":569},{"href":225,"dataGaName":570,"dataGaLocation":465},"docs",{"text":246,"config":572},{"href":248,"dataGaName":249,"dataGaLocation":465},{"text":241,"config":574},{"href":243,"dataGaName":244,"dataGaLocation":465},{"text":251,"config":576},{"href":253,"dataGaName":254,"dataGaLocation":465},{"text":264,"config":578},{"href":266,"dataGaName":267,"dataGaLocation":465},{"text":256,"config":580},{"href":258,"dataGaName":259,"dataGaLocation":465},{"text":269,"config":582},{"href":271,"dataGaName":272,"dataGaLocation":465},{"text":274,"config":584},{"href":276,"dataGaName":277,"dataGaLocation":465},{"text":279,"config":586},{"href":281,"dataGaName":282,"dataGaLocation":465},{"text":284,"config":588},{"href":286,"dataGaName":287,"dataGaLocation":465},{"title":302,"links":590},[591,593,595,597,599,601,603,608,613,615,617,619],{"text":309,"config":592},{"href":311,"dataGaName":304,"dataGaLocation":465},{"text":314,"config":594},{"href":316,"dataGaName":317,"dataGaLocation":465},{"text":322,"config":596},{"href":324,"dataGaName":325,"dataGaLocation":465},{"text":327,"config":598},{"href":329,"dataGaName":330,"dataGaLocation":465},{"text":332,"config":600},{"href":334,"dataGaName":335,"dataGaLocation":465},{"text":337,"config":602},{"href":339,"dataGaName":340,"dataGaLocation":465},{"text":604,"config":605},"Umwelt, Soziales und Governance",{"href":606,"dataGaName":607,"dataGaLocation":465},"/de-de/environmental-social-governance/","environmental, social and governance",{"text":609,"config":610},"Vielfalt, Inklusion und Zugehörigkeit",{"href":611,"dataGaName":612,"dataGaLocation":465},"/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":342,"config":614},{"href":344,"dataGaName":345,"dataGaLocation":465},{"text":352,"config":616},{"href":354,"dataGaName":355,"dataGaLocation":465},{"text":357,"config":618},{"href":359,"dataGaName":360,"dataGaLocation":465},{"text":620,"config":621},"Transparenzerklärung zu moderner Sklaverei",{"href":622,"dataGaName":623,"dataGaLocation":465},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":625,"links":626},"Nimm Kontakt auf",[627,630,632,634,639,644,649],{"text":628,"config":629},"Sprich mit einem Experten/einer Expertin",{"href":39,"dataGaName":40,"dataGaLocation":465},{"text":371,"config":631},{"href":373,"dataGaName":374,"dataGaLocation":465},{"text":376,"config":633},{"href":378,"dataGaName":379,"dataGaLocation":465},{"text":635,"config":636},"Status",{"href":637,"dataGaName":638,"dataGaLocation":465},"https://status.gitlab.com/","status",{"text":640,"config":641},"Nutzungsbedingungen",{"href":642,"dataGaName":643,"dataGaLocation":465},"/terms/","terms of use",{"text":645,"config":646},"Datenschutzerklärung",{"href":647,"dataGaName":648,"dataGaLocation":465},"/privacy/","privacy statement",{"text":650,"config":651},"Cookie-Einstellungen",{"dataGaName":652,"dataGaLocation":465,"id":653,"isOneTrustButton":93},"cookie preferences","ot-sdk-btn",{"items":655},[656,658,660],{"text":640,"config":657},{"href":642,"dataGaName":643,"dataGaLocation":465},{"text":645,"config":659},{"href":647,"dataGaName":648,"dataGaLocation":465},{"text":650,"config":661},{"dataGaName":652,"dataGaLocation":465,"id":653,"isOneTrustButton":93},"content:shared:de-de:main-footer.yml","Main Footer","shared/de-de/main-footer.yml","shared/de-de/main-footer",{"featuredPost":667,"allPosts":697,"totalPages":1228,"initialPosts":1229},{"_path":668,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":669,"content":677,"config":690,"_id":693,"_type":16,"title":694,"_source":18,"_file":695,"_stem":696,"_extension":21},"/de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover",{"title":670,"description":671,"ogTitle":670,"ogDescription":671,"noIndex":6,"ogImage":672,"ogUrl":673,"ogSiteName":674,"ogType":675,"canonicalUrls":673,"schema":676},"GitLab Duo Chat wird jetzt zum agentischen KI-Assistenten ","Unser neuer GitLab Duo Chat, der derzeit ein experimenteller Release ist, hilft Entwickler(inne)n, sich in Projekte einzuarbeiten, Aufgaben zu verstehen, Änderungen umzusetzen und mehr.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099203/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2820%29_2bJGC5ZP3WheoqzlLT05C5_1750099203484.png","https://about.gitlab.com/blog/gitlab-duo-chat-gets-agentic-ai-makeover","https://about.gitlab.com","article","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Chat wird jetzt zum agentischen KI-Assistenten \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Torsten Linz\"}],\n        \"datePublished\": \"2025-05-29\",\n      }\n                  ",{"title":670,"description":671,"authors":678,"heroImage":672,"date":680,"body":681,"category":14,"tags":682,"updatedDate":689},[679],"Torsten Linz","2025-05-29","Generative KI-Chat-Assistenten sind in kurzer Zeit zum Standard in der Softwareentwicklung geworden und helfen dabei, Code zu erstellen und zu verbessern. Stell dir nun vor, dein Chat-Assistent könnte die Artefakte deines gesamten Entwicklungsprozesses und nicht nur deinen Code verstehen.\n\nWas wäre, wenn dieser Chat-Assistent dir hilft, Tickets und Projektdokumentationen zu bearbeiten, bevor er dich beim Programmieren unterstützt, und auf CI/CD-Pipelines und Merge Requests zugreifen könnte, um dich bei der ordnungsgemäßen Durchführung von Programmieraufgaben zu begleiten?\n\n**Lerne die nächste Generation von GitLab Duo Chat kennen – GitLab Duo Agentic Chat, eine bedeutende Weiterentwicklung in der KI-nativen Entwicklungsunterstützung und die neueste Ergänzung unserer Plattform, die jetzt als [experimenteller Release (nur in englischer Sprache)](https://docs.gitlab.com/policy/development_stages_support/#experiment) verfügbar ist.** \n\nGitLab Duo Agentic Chat ist für alle GitLab.com-Benutzer(innen) mit der Workflow-Erweiterung von GitLab in VS Code verfügbar.\n\nMit Agentic Chat ist der Chat nicht mehr bloß eine herkömmliche dialogorientierte KI, sondern wird zum Chat-Assistenten, der in deinem Namen selbst handelt und komplexe Probleme in einzelne Aufgaben unterteilt, die er lösen kann. Anstatt einfach nur Fragen mit deinem angegebenen Kontext zu beantworten, kann Agentic Chat:\n\n* **Autonom feststellen**, welche Informationen er braucht, um deine Fragen zu beantworten\n* **Eine Reihe von Vorgängen ausführen**, um diese Informationen aus verschiedenen Quellen zu sammeln\n* **Umfassende Antworten formulieren**, indem er Einblicke aus deinem gesamten Projekt kombiniert\n* **Dateien erstellen und bearbeiten**, um dir dabei zu helfen, Lösungen zu implementieren.\n\nDabei bleibt stets der Mensch als Entwickler(in) involviert.\n\nAgentic Chat basiert auf der Architektur von Duo Workflow, der derzeit in der [privaten Beta-Version verfügbar ist](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/). Die Architektur besteht aus Agenten und Tools, die bestimmte Aufgaben übernehmen, z. B. den richtigen Kontext für eine bestimmte Frage finden oder Dateien bearbeiten. \n\n**Anwendungsfälle für GitLab Duo Agentic Chat**\n\nHier findest du einige praktische und häufige Anwendungsfälle für Agentic Chat:\n\n* Arbeite dich schneller in neue Projekte ein, indem die KI dir hilft, mit einer neuen Codebase vertraut zu werden.\n\n* Lege sofort mit der zugewiesenen Arbeit los, auch wenn Ticketbeschreibungen unklar sind. Agentic Chat kann dir nämlich helfen, die Lücke zwischen Anforderungen und bestehenden Implementierungen zu überbrücken.\n\n* Wenn du Änderungen vornehmen möchtest, kann Agentic Chat die Implementierung übernehmen, indem er Dateien übergreifend über dein Projekt erstellt und bearbeitet.\n\n* Wenn ein Release ansteht, kann dir Agentic Chat helfen, zu überprüfen, ob deine Lösung die ursprünglichen Anforderungen auch tatsächlich erfüllt, indem er deinen Merge Request anhand des ursprünglichen Tickets oder der ursprünglichen Aufgabe überprüft.\n\n![Agentic Chat – Beispiel](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099210/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750099210429.png)\n\n\u003Ccenter>\u003Ci>Agentic Chat bearbeitet Code\u003C/i>\u003C/center>\n\n## Vom Lernen zum Bereitstellen: eine komplette Workflow-Demonstration in vier Schritten\n\nUm dir zu zeigen, wie Agentic Chat das Entwicklererlebnis transformiert, sehen wir uns ein echtes Szenario unserer Entwicklungsteams an. Stell dir vor, du bist ein neues Teammitglied und hast ein Ticket zugewiesen bekommen, weißt aber nichts über die Codebase. Sieh dir diese Videodemonstration an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/uG9-QLAJrrg?si=kaOhYylMIaWkIuG8j\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n**Schritt 1: Das Projekt verstehen**\n\nAnstatt manuell die Dateien und die Dokumentation zu durchforsten, kannst du einfach folgenden Prompt in Agentic Chat eingeben:\n\n```unset\nI am new to this project. Could you read the project structure and explain it to me?\n```\n(Ich kenne dieses Projekt noch nicht. Lies dir bitte die Projektstruktur durch und erkläre sie mir.)\n\nAgentic Chat bietet dir dann wir folgt einen umfassenden Projektüberblick:\n- Er sieht sich die Verzeichnisstruktur an.\n- Er liest README-Dateien und die Dokumentation.\n- Er identifiziert wichtige Komponenten und Anwendungen.\n\n**Schritt 2: Deine zugewiesene Aufgabe verstehen**\n\nNun musst du deine jeweilige Aufgabe verstehen. Gib dazu den folgenden Prompt ein:\n\n```unset\nI have been assigned Issue 1119. Could you help me understand this task, specifically where do I need to apply the refactoring?\n```\n(Mir wurde das Ticket 1119 zugewiesen. Hilf mir bitte, diese Aufgabe zu verstehen. Wo genau muss ich das Refactoring durchführen?)\n\nAgentic Chat erklärt dir die Aufgabe und schlägt einen Refactoring-Ansatz vor, indem er wie folgt vorgeht:\n- Er ruft die Details des Tickets vom GitLab-Remote-Server ab und analysiert sie.\n- Er untersucht relevante Projektdateien.\n- Er identifiziert die spezifischen Orte, für die Änderungen nötig sind.\n\n**Schritt 3: Die Lösung implementieren**\n\nAnstatt die Arbeit manuell zu erledigen, kannst du folgende Frage stellen:\n\n```unset\nCould you make the edits for me? Please start with steps one, two, three.\n```\n(Kannst du die Bearbeitungen für mich vornehmen? Bitte beginne mit den Schritten eins, zwei und drei.)\n\nAgentic Chat geht dann so vor:\n- Er erstellt, wenn nötig, neue Verzeichnisse und Dateien.\n- Er extrahiert und refaktorisiert Code an mehreren Stellen.\n- Er stellt die Konsistenz übergreifend über alle geänderten Dateien sicher.\n- Er erstelle eine Übersicht über alle vorgenommenen Änderungen.\n\n**Schritt 4: Vollständigkeit überprüfen**\n\nNachdem nun abschließend dein Merge Request erstellt wurde, kannst du deine Arbeit überprüfen:\n\n```unset\nDoes my MR fully address Issue 1119?\n```\n\n(Löst mein MR das Ticket 1119 vollständig?)\n\nAgentic Chat bestätigt nun, dass alle Anforderungen erfüllt werden, indem er sowohl deinen Merge Request als auch das ursprüngliche Ticket analysiert.\n\n## Probiere es jetzt aus und teile dein Feedback\n\nGitLab Duo Agentic Chat ist derzeit als experimentelle Funktion in VS Code für Benutzer(innen) von GitLab Duo Pro und GitLab Duo Enterprise verfügbar. In unserer [Einrichtungsdokumentation (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/) findest du die Voraussetzungen und Konfigurationsschritte.\n\nDa Agentic Chat derzeit nur eine experimentelle Funktion ist, hat er einige bekannte Einschränkungen, an denen wir derzeit aktiv arbeiten. Dazu gehören langsamere Reaktionszeiten aufgrund mehrerer API-Aufrufe, eine eher schlüsselwortbasierte als semantische Suche und eine eingeschränkte Unterstützung für neue lokale Ordner oder Nicht-GitLab-Projekte. **Dein Feedback ist wichtig, damit wir die Verbesserungen priorisieren und Agentic Chat bald allgemein verfügbar machen können. Teile daher bitte deine Erfahrungen in [diesem Ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/542198) mit uns.**\n\n## Wie geht es weiter?\n\nUnser Hauptaugenmerk liegt darauf, Agentic Chat zu verbessern und allgemein verfügbar zu machen. In der Zwischenzeit arbeiten wir daran, die Reaktionszeiten zu verbessern und Funktionen hinzuzufügen, die GitLab Duo Chat derzeit bietet, wie z. B. die Verwendung von selbst gehosteten Modellen oder die Unterstützung von JetBrains und Visual Studio zusätzlich zu VS Code. Sobald wir Duo Chat auf diese neue Architektur umgestellt haben, planen wir außerdem, Agentic Chat in die Chat-Funktion der GitLab-Webanwendung zu integrieren. Zudem sind viele weitere Funktionen geplant, wie z. B. die Bearbeitung von GitLab-Artefakten, die Unterstützung von Kontexten aus benutzerdefinierten Model-Context-Protocol- oder MCP-Servern und Befehle, die im Terminal ausgeführt werden können.\n\n> Möchtest du autonome Entwicklungsunterstützung erleben, bist aber noch kein(e) GitLab-Kund(in)? Probiere Agentic Chat jetzt im Rahmen [einer kostenlosen 60-tägigen Testversion von GitLab Ultimate mit Duo Enterprise](https://about.gitlab.com/de-de/free-trial/) aus und gestalte die Zukunft der KI-basierten Entwicklung mit. Folge diesen [Einrichtungsschritten für VS Code (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/#use-agentic-chat-in-vs-code).\n\n***Haftungsausschlussklausel: Dieser Blog enthält Informationen zu kommenden Produkten, Funktionen und Funktionalitäten. Bitte beachte, dass die Informationen in diesem Blogbeitrag nur zu Informationszwecken dienen. Bitte verlasse dich nicht auf diese Informationen, wenn du etwas kaufen oder planen möchtest. Wie bei allen Projekten können sich die in diesem Blog und auf den verlinkten Seiten genannten Punkte ändern oder verzögern. Die Entwicklung, Freigabe und der Zeitplan von Produkten, Funktionen oder Funktionalitäten liegen im alleinigen Ermessen von GitLab.***\n\n## Mehr erfahren\n\n- [GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/)\n- [Was ist agentische KI?](https://about.gitlab.com/de-de/topics/agentic-ai/)\n- [Leitfäden und Ressourcen zu agentischer KI (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/agentic-ai-guides-and-resources/)\n",[683,684,685,686,687,688],"AI/ML","news","features","DevSecOps platform","product","tutorial","2025-06-04",{"slug":691,"featured":93,"template":692},"gitlab-duo-chat-gets-agentic-ai-makeover","BlogPost","content:de-de:blog:gitlab-duo-chat-gets-agentic-ai-makeover.yml","Gitlab Duo Chat Gets Agentic Ai Makeover","de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover.yml","de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover",[698,718,740,761,781,801,822,843,864,884,902,922,941,962,984,1006,1028,1049,1067,1087,1106,1126,1147,1167,1187,1208],{"_path":699,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":700,"content":706,"config":713,"_id":714,"_type":16,"title":715,"_source":18,"_file":716,"_stem":717,"_extension":21},"/de-de/blog/agentic-ai-guides-and-resources",{"ogTitle":701,"schema":702,"ogImage":703,"ogDescription":704,"ogSiteName":674,"noIndex":6,"ogType":675,"ogUrl":705,"title":701,"canonicalUrls":705,"description":704},"Leitfäden und Ressourcen zu agentischer KI","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Leitfäden und Ressourcen zu agentischer KI\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2025-05-07\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749658912/Blog/Hero%20Images/blog-image-template-1800x945__20_.png","Hier erfährst du alles, was du über agentische KI wissen musst, wie sie funktioniert, warum sie deine DevSecOps-Umgebung aufwertet und welche bewährten Methoden es für die Implementierung gibt.","https://about.gitlab.com/blog/agentic-ai-guides-and-resources",{"heroImage":703,"body":707,"authors":708,"updatedDate":710,"date":711,"title":701,"tags":712,"description":704,"category":14},"## Inhaltsverzeichnis\n- [Definition von agentischer KI](#definition-von-agentischer-ki)\n- [Einblicke in die agentische KI](#einblicke-in-die-agentische-ki)\n- [Best Practices für die Implementierung von agentischer KI](#best-practices-für-die-implementierung-von-agentischer-ki)\n- [Das bietet GitLab im Bereich agentische KI](#das-bietet-gitlab-im-bereich-agentische-ki)\n - [GitLab Duo mit Amazon Q](#gitlab-duo-mit-amazon-q)\n - [GitLab Duo Workflow](#gitlab-duo-workflow)\n- [Mehr erfahren mit GitLab University (nur in englischer Sprache verfügbar)](#mehr-erfahren-mit-gitlab-university-(nur-in-englischer-sprache-verfügbar))\n- [Weitere Ressourcen zum Bereich KI](#weitere-ressourcen-zum-bereich-ki)\n\n## Definition von agentischer KI\n\nAgentische KI ist eine Form der künstlichen Intelligenz, die fortschrittliche Sprachmodelle und linguistische Datenverarbeitung nutzt, um eigenständig zu handeln. Im Gegensatz zu herkömmlichen generativen KI-Tools, bei denen ständige menschliche Anweisung nötig ist, können diese Systeme Anfragen verstehen, Entscheidungen treffen und mehrstufige Pläne ausführen, um Ziele zu erreichen. Sie bewältigen komplexe Aufgaben, indem sie sie in umsetzbare Schritte unterteilen, und setzen adaptives Lernen ein, um ihren Ansatz zu verändern, wenn sie auf Schwierigkeiten treffen.\n\n[Erfahre mehr über agentische KI](https://about.gitlab.com/de-de/topics/agentic-ai/)\n\n## Einblicke in die agentische KI\n\n- [Neue Trends in der agentischen KI, die die Softwareentwicklung verändern (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/emerging-agentic-ai-trends-reshaping-software-development/): Erfahre, wie agentische KI die Entwicklung von isolierter Programmierung in intelligente Workflows verwandelt, die die Produktivität steigern und gleichzeitig die Sicherheit gewährleisten.\n- [Agentische KI: Entwicklungspotenzial im großen Stil](https://about.gitlab.com/de-de/the-source/ai/agentic-ai-unlocking-developer-potential-at-scale/): Entdecke, wie agentische KI die Softwareentwicklung verändert und über die Code-Vervollständigung hinausgeht, um KI-Partner zu schaffen, die komplexe Aufgaben proaktiv angehen.\n- [Agentische KI, Self-Hosted Models und mehr: KI-Trends im Jahr 2025](https://about.gitlab.com/de-de/the-source/ai/ai-trends-for-2025-agentic-ai-self-hosted-models-and-more/): Entdecke die wichtigsten KI-Trends im Bereich der Softwareentwicklung – von der lokalen Bereitstellung von Modellen bis hin zu intelligenten, adaptiven KI-Tools.\n- [Wie agentische KI das Potenzial von Platform Engineering freisetzt (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/how-agentic-ai-unlocks-platform-engineering-potential/): Erfahre, wie agentische KI Platform Engineering verbessert, indem sie komplexe Workflows automatisiert und die Standardisierung vorantreibt.\n\n## Best Practices für die Implementierung von agentischer KI\n\n- [Implementierung effektiver Leitlinien für KI-Agenten (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/implementing-effective-guardrails-for-ai-agents/): Entdecke die wichtigsten Sicherheitsleitlinien für KI-Tools in DevSecOps, von Compliance-Kontrollen über den Schutz der Infrastruktur bis hin zur Benutzerzugriffsverwaltung.\n\n## Das bietet GitLab im Bereich agentische KI\n\n### GitLab Duo mit Amazon Q\n\n- [GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/): Die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen beschleunigt Entwicklungszyklen, erhöht die Automatisierung und verbessert die Codequalität.\n- [DevSecOps + agentische KI: Jetzt für GitLab Self-Managed Ultimate auf AWS (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/devsecops-agentic-ai-now-on-gitlab-self-managed-ultimate-on-aws/): Verwende KI-basierte Agents, die für DevSecOps optimiert sind, in deiner Instanz von AWS GitLab Self-Managed Ultimate. Profitiere von den Vorteilen von GitLab Duo und Amazon Q in deinem Unternehmen.\n- [GitLab Duo mit Amazon Q – Partnerseite](https://about.gitlab.com/de-de/partners/technology-partners/aws/)\n\nSieh dir GitLab Duo mit Amazon Q in Aktion an:\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1075753390?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Technical Demo: GitLab Duo with Amazon Q\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n#### Geführte Tour\n\nKlicke auf das Bild, um eine englischsprachige Tour durch GitLab Duo mit Amazon Q zu starten:\n\n[![GitLab Duo mit Amazon Q – interaktive Tour](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673568/Blog/Content%20Images/Screenshot_2025-05-07_at_7.24.45_AM.png)](https://gitlab.navattic.com/duo-with-q)\n\n#### GitLab Duo mit Amazon Q – Tutorial\n\n- [GitLab Duo + Amazon Q: Ideen in wenigen Minuten in Code umwandeln (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes/): Die neue Integration „GitLab Duo mit Amazon Q“ analysiert deine Ticketbeschreibungen und generiert automatisch vollständige, funktionierende Code-Lösungen. So werden deine Entwicklungsworkflows beschleunigt.\n\n### GitLab Duo Workflow\n\n- [GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/workflow/): Die Zukunft der sicheren Entwicklung von agentischer KI-Software\n- [GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/): Sichere, autonome, kontextbewusste KI-Tools übernehmen komplexe Aufgaben und geben Entwickler(inne)n die Möglichkeit, innovative Software schneller zu entwickeln. Die private Beta-Warteliste ist jetzt geöffnet.\n- [GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/workflow/)\n- [Dokumentation für GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/duo_workflow/)\n\nSieh dir GitLab Duo Workflow in Aktion an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/eN2Sd5UNc0g?si=C9HibBJ3QDDHADq2\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Geführte Tour\n\nKlicke auf das Bild unten, um die englischsprachige Tour durch GitLab Duo Workflow zu starten:\n\n[![GitLab Duo Workflow – geführte Tour](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673569/Blog/Content%20Images/Screenshot_2025-05-07_at_7.29.57_AM.png)](https://gitlab.navattic.com/duo-workflow)\n\n#### Tutorials und Anwendungsfälle für GitLab Duo Workflow\n\n- [Refactoring von JavaScript zu TypeScript mit GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/refactoring-javascript-to-typescript-with-gitlab-duo-workflow/)\n\n- [Automatisierung mühsamer Programmieraufgaben mit GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/automate-tedious-coding-tasks-with-gitlab-duo-workflow/): Erfahre, wie agentische KI den Zeitaufwand für sich wiederholende Aufgaben reduzieren kann, damit du dich auf die Entwicklung innovativer Lösungen und die Bereitstellung der nächsten großen Innovation konzentrieren kannst.\n\n- [Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow](https://about.gitlab.com/de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance/): Erfahre, wie du mithilfe von agentischer KI Unit-Tests zu einer Java-Anwendung hinzufügst (Video-Tutorial inklusive).\n\n- [Komplexe Herausforderungen mit GitLab Duo Workflow lösen (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/solving-complex-challenges-with-gitlab-duo-workflow/): Erfahre, wie ein Mitglied des GitLab-Management-Teams für Kundenerfolge agentische KI für die Lösung realer Probleme einsetzt, einschließlich der Bewältigung von Helm-Chart-Limits in der Paket-Registry.\n\n## Mehr erfahren mit GitLab University (nur in englischer Sprache verfügbar)\n\n- [Kurs „Erste Schritte mit GitLab Duo“](https://university.gitlab.com/pages/ai)\n- [GitLab Duo Enterprise Learning Path](https://university.gitlab.com/learning-paths/gitlab-duo-enterprise-learning-path)\n\n## Weitere Ressourcen zum Bereich KI\n\n- [Globaler DevSecOps-Bericht 2024: Navigation durch die KI-Entwicklung in DevSecOps](https://about.gitlab.com/de-de/developer-survey/2024/ai/)\n- [Die Rolle der KI bei DevOps](https://about.gitlab.com/de-de/topics/devops/the-role-of-ai-in-devops/)\n- [Die neuesten KI-/ML-Artikel von GitLab](https://about.gitlab.com/de-de/blog/categories/ai-ml/)\n- [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/)",[709],"GitLab","2025-06-18","2025-05-07",[683,686,688],{"featured":93,"template":692},"content:de-de:blog:agentic-ai-guides-and-resources.yml","Agentic Ai Guides And Resources","de-de/blog/agentic-ai-guides-and-resources.yml","de-de/blog/agentic-ai-guides-and-resources",{"_path":719,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":720,"content":726,"config":734,"_id":736,"_type":16,"title":737,"_source":18,"_file":738,"_stem":739,"_extension":21},"/de-de/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes",{"title":721,"description":722,"ogTitle":721,"ogDescription":722,"noIndex":6,"ogImage":723,"ogUrl":724,"ogSiteName":674,"ogType":675,"canonicalUrls":724,"schema":725},"GitLab Duo mit Amazon Q: In wenigen Minuten wird aus einer Idee der passende Code","Die neue Integration von GitLab Duo mit Amazon Q analysiert deine Tickets und erstellt automatisch funktionierende Codelösungen, wodurch deine Workflows beschleunigt werden.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097127/Blog/Hero%20Images/Blog/Hero%20Images/Screenshot%202024-11-27%20at%204.55.28%E2%80%AFPM_4VVz6DgGBOvbGY8BUmd068_1750097126673.png","https://about.gitlab.com/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo mit Amazon Q: In wenigen Minuten wird aus einer Idee der passende Code\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cesar Saavedra\"}],\n        \"datePublished\": \"2025-04-28\",\n      }\n                  ",{"title":721,"description":722,"authors":727,"heroImage":723,"date":729,"body":730,"category":14,"tags":731,"updatedDate":733},[728],"Cesar Saavedra","2025-04-28","Hast du schon einmal Tage oder sogar Wochen damit verbracht, aus einem komplexen Problem einen funktionierenden Code zu machen? Wer hat das nicht? Man beginnt mit einer vernünftigen Idee und klaren Anforderungen, aber der Weg vom anfänglichen Konzept hin zu bereitstellbarem Code kann frustrierend lang sein. Deine Produktivität wird durch Implementierungsdetails gebremst und Projekte, die schnell vorankommen sollten, ziehen sich in die Länge.\n\nHier kommt die [agentische KI](https://about.gitlab.com/de-de/topics/agentic-ai/) mit all ihrer Power ins Spiel. [GitLab Duo mit Amazon Q](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/) kombiniert die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen, um deinen Anwendungsentwicklungsprozess innerhalb deines vertrauten GitLab-Workflows drastisch zu beschleunigen. Indem sie deinen Weg von der Idee bis zur Bereitstellung optimiert, kann diese leistungsstarke Integration Implementierungslösungen ausschließlich anhand deiner Ticketbeschreibungen vorschlagen – so wird ein Vorgang, der früher Tage dauerte, in wenigen Minuten erledigt.\n\n## So funktioniert’s: vom Ticket zum funktionierenden Code\n\nSehen wir uns an, wie die agentische KI-Funktion in der Praxis funktioniert. Stell dir vor, du bist Entwickler(in) und sollst eine Anwendung für einen Hypothekenrechner erstellen. So hilft dir GitLab Duo mit Amazon Q dabei:\n\n1. **Erstelle ein Ticket mit detaillierten Anforderungen:** Erstelle zunächst ein Standard-[GitLab-Ticket](https://docs.gitlab.com/user/project/issues/). In der Beschreibung gibst du eine umfassende Liste der Anforderungen an, die deine Anwendung erfüllen muss. Dies bildet die Grundlage für deine Lösung.\n\n2. **Rufe Amazon Q mit einem Schnellzugriff auf:** Sobald dein Ticket erstellt ist, fügst du einfach einen Kommentar mit dem Schnellzugriff „/q dev“ hinzu, um Amazon Q aufzurufen. Jetzt wird es magisch. \n\n3. **Lass die KI deine Implementierung generieren:** GitLab Duo mit Amazon Q analysiert deine Ticketbeschreibung und den Kontext deines Quellcodes und generiert dann autonom Code, der alle angegebenen Anforderungen erfüllt. Und das ist noch nicht alles – es überträgt diese Änderungen sogar in einen Merge Request, der dann von dir überprüft werden kann.\n\n![Screenshot des Aktivitäts-Pop-ups von GitLab Duo mit Amazon Q](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097156/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097156018.png)\n\n4. **Überprüfe die generierte Anwendung**: Gehe nun zum Merge Request, um den generierten Code zu überprüfen. Sieh dir hier an, ob alle deine Anforderungen erfüllt wurden, und nimm bei Bedarf Anpassungen vor.\n\n5. **Teste die vorgeschlagene Anwendung**: Überprüfe abschließend, ob die Anwendung erfolgreich ausgeführt wird. Mit minimalem Aufwand hast du jetzt einen funktionierenden Code, der deine festgelegten Anforderungen erfüllt.\n\n## Transformiere deinen Entwicklungsprozess\n\nGitLab Duo mit Amazon Q transformiert diesen Prozess vollständig, indem es durch intelligente Automatisierung die Zeit, die für komplexe Entwicklungsaufgaben aufgewendet werden muss, signifikant senkt. Durch den Einsatz von agentischer KI kannst du deinen Weg von der Idee bis zur Bereitstellung verkürzen und gibst Entwicklungsteams so die Möglichkeit, sich auf strategischere Aufgaben zu konzentrieren.\n\nMit GitLab Duo und Amazon Q entwickelst du Software schneller, effizienter und mit geringerem manuellem Programmieraufwand. Diese Integration hilft dir:\n\n* **Wertvolle Entwicklungszeit zu sparen**, indem Implementierungen automatisiert werden und die jeweiligen Anforderungen berücksichtigt werden\n* **Konsistent zu bleiben**, wenn du Code übergreifend über Projekte generierst\n* **Die kognitive Belastung zu reduzieren**, die auftritt, wenn Anforderungen in funktionierenden Code umgewandelt werden sollen\n* **Deine Bereitstellungszyklen zu beschleunigen**, indem Engstellen bei der Implementierung eliminiert werden\n* **Dich auf deine Expertise zu konzentrieren** und Code zu überprüfen und zu optimieren, anstatt dich mit Boilerplate-Code herumschlagen zu müssen.\n\nBist du bereit, GitLab Duo mit Amazon Q in Aktion zu erleben? In unserem Demo-Video erfährst du, wie du deinen Entwicklungsworkflow jetzt transformieren kannst.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/jxxzNst3jpo?si=j_LQdZhUnwqoQEst\" title=\"GitLab Duo with Amazon Q demo video for dev workflow\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n> Besuche uns auf einem der bevorstehenden [AWS Summits in einer Stadt in deiner Nähe](https://about.gitlab.com/de-de/events/aws-summits/) oder [wende dich an deine(n) GitLab-Vertreter(in)](https://about.gitlab.com/de-de/partners/technology-partners/aws/#form), um mehr über GitLab Duo mit Amazon Q zu erfahren.\n\n## Ressourcen zu GitLab Duo mit Amazon Q\n\n- [GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/)\n- [GitLab und AWS – Partnerseite](https://about.gitlab.com/de-de/partners/technology-partners/aws/)\n- [Dokumentation zu GitLab Duo mit Amazon Q (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/duo_amazon_q/)",[683,732,688,686,687,236],"AWS","2025-06-06",{"slug":735,"featured":93,"template":692},"gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes","content:de-de:blog:gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes.yml","Gitlab Duo Amazon Q Transform Ideas Into Code In Minutes","de-de/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes.yml","de-de/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes",{"_path":741,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":742,"content":748,"config":755,"_id":757,"_type":16,"title":758,"_source":18,"_file":759,"_stem":760,"_extension":21},"/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws",{"title":743,"description":744,"ogTitle":743,"ogDescription":744,"noIndex":6,"ogImage":745,"ogUrl":746,"ogSiteName":674,"ogType":675,"canonicalUrls":746,"schema":747},"GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar","Die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen beschleunigt Entwicklungszyklen, erhöht die Automatisierung und verbessert die Codequalität.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659604/Blog/Hero%20Images/Screenshot_2024-11-27_at_4.55.28_PM.png","https://about.gitlab.com/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Emilio Salvador\"}],\n        \"datePublished\": \"2025-04-17\",\n      }\n                  ",{"title":743,"description":744,"authors":749,"heroImage":745,"date":751,"body":752,"category":14,"tags":753,"updatedDate":754},[750],"Emilio Salvador","2025-04-17","Wir freuen uns, heute die allgemeine Verfügbarkeit von **[GitLab Duo mit Amazon Q](https://about.gitlab.com/de-de/partners/technology-partners/aws/)** bekannt zu geben. Damit wird AWS-Kund(inn)en eine [agentenbasierte KI](https://about.gitlab.com/de-de/topics/agentic-ai/) während des gesamten Software-Entwicklungsprozesses zur Verfügung gestellt.\n\nGitLab Duo mit Amazon Q basiert auf GitLab Ultimate und enthält viele bekannte Funktionen wie Codevervollständigung, Codeerläuterung, Codegenerierung, Chat sowie Erklärung und Behebung von Sicherheitslücken – allesamt jetzt mit Amazon Q. Es ist mit einem selbstverwalteten Bereitstellungsmodell für Kund(inn)en von Amazon Web Services (AWS) verfügbar.\n\nDa die Agenten von Amazon Q direkt in die DevSecOps-Plattform von GitLab eingebettet sind, können Entwickler(innen) in ihrer gewohnten Umgebung arbeiten und gleichzeitig von leistungsstarken KI-Funktionen profitieren. Das Ergebnis ist eine reibungslose Erfahrung, die Entwicklungszyklen beschleunigt, manuellen Aufwand reduziert und die Codequalität verbessert.\n\n> Durch die Teilnahme am Early-Access-Programm für GitLab Duo mit Amazon Q konnten wir einen Einblick in das transformative Potenzial für unsere Entwicklungs-Workflows gewinnen. **Schon in der Anfangsphase haben wir gesehen, wie die tiefere Integration mit autonomen Agenten unseren Prozess vom Code-Commit bis hin zur Produktion optimieren kann.** Wir sind gespannt, wie unser Team sich mit dieser Technologie auf Innovationen konzentrieren und unsere digitale Transformation beschleunigen kann.\n\n**Osmar Alonso, DevOps Engineer bei Volkswagen Digital Solutions**\n\n## Agentische KI für komplexe Kundenumgebungen\n\nDurch die Kombination von agentischer KI mit einer sicheren und zuverlässigen Cloud-Infrastruktur bieten GitLab und AWS integrierte Sicherheit, Skalierbarkeit und Zuverlässigkeit für komplexe Kundenumgebungen, sodass diese von folgenden Vorteilen profitieren können:\n\n__Einheitliche Entwicklererfahrung für optimierte Entwicklung__\n\nEntwickler(innen) können über die Schnittstelle von GitLab Duo Chat von ihrer bevorzugten IDE oder der GitLab-Weboberfläche aus mit Amazon Q interagieren. Dadurch entfällt der Kontextwechsel zu anderen Tools und Entwickler(innen) können sich besser auf das Projekt konzentrieren, an dem sie gerade arbeiten.\n\n__Eine Lösung für den gesamten Software-Entwicklungsprozess__\n\nCodevorschläge und -optimierungen nutzen AWS-spezifische Muster und Vorgehensweisen, während Testtools die Interaktionen und Abhängigkeiten der AWS-Services verstehen. Ein gemeinsamer Datenspeicher für alle Phasen liefert KI-Agenten wichtige Kontextinformationen und ermöglicht so vollständige Transparenz und Nachverfolgbarkeit relevanter Aktionen.\n\n__Sichere Entwicklung mit Leitlinien auf Unternehmensebene__\n\nEnd-to-End-Sicherheit und Compliance sind direkt in die Entwicklungsplattform integriert, mit Leitlinien, die Risiken reduzieren, ohne die Geschwindigkeit zu beeinträchtigen. Dieser sichere Ansatz für die Softwareentwicklung sorgt für Transparenz und Überprüfbarkeit durch KI-Agenten und lässt sich nahtlos in AWS-Sicherheitsdienste und Compliance-Frameworks integrieren.\n\n## So kannst du GitLab Duo mit Amazon Q nutzen\n\nHier sind fünf Anfangsbeispiele, die wir uns vorgenommen haben, um Teams dabei zu helfen, mit agentenbasierter KI schneller sichere Software zu entwickeln:\n\n1. **Schnellere Entwicklung von Funktionen** - Erstellt Ticketbeschreibungen, macht Implementierungspläne auf Basis deiner bestehenden Codebase und erstellt komplette Merge Requests, die sofort überprüft werden können. Das beschleunigt die Bereitstellung von Funktionen und sorgt gleichzeitig für die Einhaltung der internen Entwicklungsstandards.  \n2. **Modernisieren von älteren Anwendungen** - Analysiert deine alte Java-Codebase, erstellt einen umfassenden Upgrade-Plan und generiert einen Merge Request mit allen notwendigen Codeänderungen. Dadurch werden Java-Upgrades beschleunigt und ein klarer Audit-Trail für alle Codetransformationen bereitgestellt. Die Unterstützung für .NET und andere Sprachen ist für zukünftige Versionen geplant.\n3. **Verbessern der Qualitätssicherung** - Analysiert Code und erstellt automatisch umfassende Unit-Tests, die deine Anwendungslogik und die Interaktionen mit AWS-Services berücksichtigen. Dies erhöht die Testabdeckung, reduziert den Aufwand für das manuelle Schreiben von Tests und trägt dazu bei, eine konsistente Testqualität über alle Anwendungen hinweg sicherzustellen.  \n4. **Optimieren der Code Review** - Bietet Inline-Feedback zu Codeänderungen, schlägt Verbesserungen auf Basis von Entwicklungsstandards vor und hebt Sicherheits- und Leistungsaspekte hervor. Dies ermöglicht kürzere Code-Review-Zyklen und die Bereitstellung hochwertigerer Codezusammenführungen für die Bereitstellung.  \n5. **Beheben von Sicherheitslücken** - Erläutert erkannte Sicherheitslücken anhand klarer, detaillierter Beschreibungen und ermöglicht die Behebung mit einem Klick auf Basis empfohlener Codeänderungen, wodurch die Zeit zwischen Erkennung und Behebung erheblich verkürzt wird.\n\nSieh dir GitLab Duo mit Amazon Q in Aktion an:\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1075753390?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Technical Demo: GitLab Duo with Amazon Q\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n#### Profitiere noch heute von den Vorteilen von GitLab Duo mit Amazon Q\nDie einheitliche, KI-gestützte DevSecOps-Plattform von GitLab mit den fortschrittlichen KI-Funktionen von Amazon Q bietet AWS-Kund(inn)en eine Lösung, die die Art und Weise, wie Teams Software entwickeln und bereitstellen, verändert. \n\nBesuche uns auf einem bevorstehenden [AWS Summit in einer Stadt in deiner Nähe](https://about.gitlab.com/de-de/events/aws-summits/) oder [wende dich an deine*n GitLab-Vertreter*in](https://about.gitlab.com/de-de/partners/technology-partners/aws/), um mehr über GitLab Duo mit Amazon Q zu erfahren.",[683,686,732,687,685,684],"2025-05-26",{"slug":756,"featured":93,"template":692},"gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws","content:de-de:blog:gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws.yml","Gitlab Duo With Amazon Q Agentic Ai Optimized For Aws","de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws.yml","de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws",{"_path":762,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":763,"content":769,"config":775,"_id":777,"_type":16,"title":778,"_source":18,"_file":779,"_stem":780,"_extension":21},"/de-de/blog/what-is-generative-ai",{"title":764,"description":765,"ogTitle":764,"ogDescription":765,"noIndex":6,"ogImage":766,"ogUrl":767,"ogSiteName":674,"ogType":675,"canonicalUrls":767,"schema":768},"Was ist Generative KI?","Erfahre, was generative KI ist, wie sie sich von klassischer KI unterscheidet, welche Modelle es gibt und wie GitLab mit generativer KI arbeitet.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663009/Blog/Hero%20Images/ESA_case_study_image.jpg","https://about.gitlab.com/blog/what-is-generative-ai","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Was ist Generative KI?\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab Germany Team\"}],\n        \"datePublished\": \"2025-04-16\",\n      }",{"title":764,"description":765,"authors":770,"heroImage":766,"date":772,"body":773,"category":14,"tags":774},[771],"GitLab Germany Team","2025-04-16","# Was ist Generative KI?\nGenerative KI ist eine revolutionäre Technologie, die über die reine Analyse bestehender Daten hinausgeht und eigenständig neue Inhalte wie Texte, Bilder, Musik oder Code erstellt. Sie unterstützt kreative Prozesse und treibt Innovationen in unterschiedlichsten Branchen voran.\n\nAber wie funktioniert diese fortschrittliche Technologie, was macht sie so einzigartig und welche Modelle stecken dahinter? In diesem Artikel erhältst du umfassende Antworten auf diese Fragen sowie praxisnahe Beispiele und spannende Anwendungsfälle.\n\n## Generative KI: Definition\nGenerative künstliche Intelligenz ist ein spezieller Bereich der künstlichen Intelligenz, der nicht nur bestehende Daten analysiert oder kategorisiert, sondern eigenständig neue Inhalte erschafft.\n\nMithilfe komplexer Algorithmen und neuronaler Netzwerke entstehen Texte, Bilder, Musik oder andere Inhalte, die so realistisch wirken sollen, dass sie zukünftig kaum von menschlich erstellten Werken zu unterscheiden sind. Die Technologie lernt aus vorhandenen Mustern und wendet dieses Wissen an, um innovative und kreative Ergebnisse zu erzielen.\n\n## Wie unterscheidet sich generative KI von KI?\nDer Begriff „künstliche Intelligenz“ umfasst viele Technologien, doch generative KI ist ein spezifischer Teilbereich davon. Klassische KI-Modelle erkennen Muster, treffen Entscheidungen oder automatisieren Prozesse, während generative KI auf die Erzeugung neuer Inhalte spezialisiert ist.\n\n### KI und generative KI: Unterschiede im Überblick:\n**Klassische KI** wird vor allem für Analyse, Vorhersagen und Automatisierung eingesetzt. Typische Technologien sind Entscheidungsbäume, Regressionsmodelle oder Klassifikatoren. Anwendungen finden sich zum Beispiel in Chatbots, Sprachassistenten oder Empfehlungssystemen.\n\n**Generative KI** hingegen geht einen Schritt weiter: Sie kann eigenständig neue Inhalte erzeugen. Möglich machen das fortschrittliche Modelle wie GANs (Generative Adversarial Networks), Transformer oder Diffusionsmodelle. So entstehen KI-generierte Texte, Bilder, Musik oder Videos – etwa mit Tools wie ChatGPT oder DALL-E.\n\n**Die beiden KI-Formen verfolgen also unterschiedliche Ziele: Während klassische KI auf Analyse basiert, steht bei generativer KI die kreative Inhaltserstellung im Fokus.**\n\n### Warum ist der Unterschied wichtig?\nGenerative KI eröffnet neue Anwendungsfelder: Statt nur zu reagieren oder Aufgaben zu automatisieren, können nun innovative und kreative Prozesse unterstützt werden. Das hat auch Auswirkungen auf kreative Berufe, Produktentwicklung oder auch die Art, wie wir miteinander kommunizieren.\n\n## Wie funktioniert generative KI?\nDie Funktionsweise generativer KI basiert auf komplexen mathematischen Modellen, die von neuronalen Netzwerken trainiert werden. Diese Netzwerke analysieren riesige Datenmengen und lernen, Muster und Beziehungen innerhalb dieser Daten zu erkennen.\n\n### Grundlagen der Funktionsweise generativer KI\nGenerative KI ist ein faszinierendes Feld, das sich auf die Erstellung neuer Inhalte aus bestehenden Daten konzentriert. \n\nHier sind die wesentlichen Grundlagen, wie diese Technologien arbeiten und welche Modelle dabei eine Rolle spielen.\n\n1. **Training mit Daten:** Das Modell wird mit großen Mengen an Daten, wie Texte, Bilder oder Videos, gefüttert. Ziel ist es, Muster und Zusammenhänge in diesen Daten zu erkennen.\n\n2. **Modelltypen:** Die häufigsten Modelle, die in der generativen KI verwendet werden, sind:\n\n- **GANs (Generative Adversarial Networks):** Zwei Netzwerke arbeiten gegeneinander – eines generiert Inhalte, das andere bewertet deren Qualität.\n\n- **Transformermodelle:** Diese Modelle, wie GPT, setzen auf Kontextverständnis, um kohärente und logische Inhalte zu erstellen.\n\n- **Diffusionsmodelle:** Sie erstellen Inhalte, indem sie Rauschen schrittweise reduzieren und werden häufig in der Bildgenerierung eingesetzt.\n\n3. **Generierung neuer Inhalte:** Nach dem Training kann das Modell auf neue Eingaben reagieren und basierend auf gelernten Mustern neue Inhalte erstellen.\n\nMit diesen Modellen kann generative KI erstaunliche Inhalte erzeugen, die in vielen Bereichen Anwendung finden – von der Texterstellung bis hin zur Kunst- und Bildproduktion.\n\n## Wie Deep Learning die generative KI vorantreibt\nDeep Learning ist die treibende Kraft hinter generativer KI. Als Teilgebiet des maschinellen Lernens setzt es auf neuronale Netzwerke mit mehreren Schichten, um komplexe Muster in Daten zu erkennen und darauf aufbauend neue Inhalte zu generieren. Diese Methode ist besonders leistungsfähig, da sie in der Lage ist, tiefere Zusammenhänge in Daten zu verstehen. Dadurch werden qualitativ hochwertige Ergebnisse erzielt.\n\n### Was ist Deep Learning?\nDeep Learning ist eine Technologie, die künstliche neuronale Netzwerke verwendet, um Daten Schritt für Schritt zu analysieren. Jede Schicht des Netzwerks verarbeitet spezifische Merkmale der Daten und übergibt die Ergebnisse an die nächste Ebene.\nDieser schichtweise Ansatz ermöglicht es, sowohl einfache als auch komplexe Muster zu erkennen, was für die Generierung neuer Inhalte essenziell ist.\n\n### Die Rolle von Deep Learning\nDeep Learning ist für generative KI unverzichtbar, weil es:\nSkalierbar ist und große Datenmengen effizient verarbeiten kann.\nFlexibel für verschiedene Datentypen wie Text, Bilder und Audio einsetzbar ist.\nLeistungsstark durch Fortschritte in Algorithmen und Rechenleistung immer präzisere Ergebnisse liefert.\n\n### Warum ist Deep Learning entscheidend?\nOffensichtlich beeinflusst Deep Learning generative KI grundlegend. Ohne Deep Learning wäre sie in ihrer heutigen Form nicht möglich. Es ermöglicht nicht nur die Erstellung realistischer Inhalte, sondern treibt auch die Weiterentwicklung von Modellen voran. \nDadurch kann generative KI in immer mehr Bereichen eingesetzt werden und liefert innovative Lösungen für kreative und technische Herausforderungen.\n\n## Generative KI – Modelle\nGenerative KI stützt sich auf verschiedene Modelltypen, die jeweils für unterschiedliche Anwendungen optimiert sind. Jedes Modell hat eigene Stärken und Schwächen und wird je nach Anwendungsfall eingesetzt.\n\n### GANs (Generative Adversarial Networks)\nGANs bestehen aus zwei miteinander konkurrierenden neuronalen Netzwerken:\n\n**Der Generator** erstellt neue Inhalte.\n\n**Der Diskriminator** bewertet, ob die Inhalte echt oder künstlich sind.\nDieser Wettbewerb zwischen den Netzwerken verbessert die Qualität der generierten Inhalte kontinuierlich, was GANs besonders für die Erstellung von Bildern, Videos und anderen visuellen Medien prädestiniert.\n\n### Transformermodelle\nTransformermodelle wie GPT (Generative Pre-trained Transformer) basieren auf der Fähigkeit, den Kontext von Wörtern und Sätzen zu verstehen. Sie sind besonders effektiv bei der Verarbeitung und Erstellung von Texten. Transformermodelle analysieren Daten in Sequenzen, um sinnvolle und kohärente Inhalte zu generieren.\n\n### Variational Autoencoders (VAEs)\nVAEs komprimieren Daten in ein kompaktes Format, um sie später zu rekonstruieren. Sie erzeugen neue Inhalte, indem sie Variationen innerhalb eines Datensatzes erstellen. VAEs werden häufig in der Bild- und Tondatenverarbeitung eingesetzt und eignen sich gut für Aufgaben, bei denen Variationen auf Basis bestehender Muster benötigt werden.\n\n### Diffusionsmodelle\nDiffusionsmodelle entfernen schrittweise Rauschen aus einer Pixelmatrix, um realistische Bilder zu erstellen. Diese Modelle sind besonders beliebt in der Bildgenerierung, da sie detaillierte und hochqualitative Ergebnisse liefern können.\n\n## Generative KI-Anwendungen in unterschiedlichen Bereichen\nGenerative KI hat das Potenzial, Branchen zu transformieren, Arbeitsprozesse zu vereinfachen und zu automatisieren und große Datenmengen schneller zu verarbeiten. \n\n### Generative KI in Marketing und Kommunikation\nIn Marketing und Kommunikation wird generative KI wie ChatGPT vor allem für die automatisierte Erstellung von Inhalten wie Blogbeiträgen, Social-Media-Posts oder Produktbeschreibungen genutzt. Sie kann auch personalisierte Anzeigen generieren, die gezielt auf die Interessen der Zielgruppe zugeschnitten sind.\n\nAllerdings gibt es Herausforderungen: KI-generierte Inhalte wirken oft unpersönlich, können kulturelle Feinheiten übersehen und dadurch Missverständnisse auslösen. Zudem kann die Authentizität fehlen, was die Markenbindung negativ beeinflusst.\n\n### Generative KI in der Bildung\nIn der Bildung wird generative KI eingesetzt, um personalisierte Lernmaterialien zu erstellen, die sich an den individuellen Fortschritt der Lernenden anpassen. Auch virtuelle Simulationen werden immer häufiger genutzt, um praxisnahes Lernen zu fördern, etwa in der Medizin oder Technik.\n\nVorteile sind die Anpassungsfähigkeit und die interaktive Gestaltung des Lernens. Allerdings müssen generierte Inhalte überprüft werden, um Fehler zu vermeiden, und die Implementierung solcher Technologien kann kostenintensiv sein.\n\n### Generative KI in der Forschung und Entwicklung\nGenerative KI unterstützt die Forschung und Entwicklung, indem sie neue Prototypen und Designs generiert und komplexe Daten analysiert. Dadurch werden Innovationsprozesse beschleunigt und neue Zusammenhänge schneller erkannt.\n\nWährend die Effizienz dadurch deutlich steigt, bleibt die Abhängigkeit von der Datenqualität ein Schwachpunkt. Fehlerhafte Daten können die Ergebnisse negativ beeinflussen, und der hohe Rechenaufwand macht die Nutzung oft teuer.\n\n## Beispiele für Generative-KI-Anwendungen in der Arbeitswelt\nGenerative KI hat ihren Weg in zahlreiche Branchen gefunden und bietet eine Vielzahl von Anwendungsmöglichkeiten.\n\n## Kreative Anwendungen\n**Texterstellung:** Tools wie ChatGPT oder Jasper AI erstellen Artikel, Blogbeiträge oder Produktbeschreibungen.\n\n**Bildgenerierung:** Mit Tools wie DALL-E oder MidJourney können Benutzer(innen) Bilder auf Basis einfacher Texteingaben erzeugen.\n\n**Musikproduktion:** Plattformen wie Amper Music oder AIVA komponieren Musikstücke für Filme oder Podcasts.\n\n### Industrie und Technologie\n**Code-Generierung:** Entwickler(innen) nutzen Tools wie [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), um automatisiert Codevorschläge zu erhalten.\n\n**Prototypen-Design:** Generative KI hilft Entwickler(inn)en und Designer(innen) bei der Entwicklung neuer Produkte.\n\n**Automatisierte Tests:** Softwaretests können durch KI schneller und effizienter gestaltet werden.\n\n### Gesundheit und Wissenschaft\n**Medikamentenentwicklung:** KI-Modelle wie [AlphaFold](https://alphafold.ebi.ac.uk/) haben die Vorhersage von Proteinstrukturen revolutioniert.\n\n**Diagnostik:** Generative KI analysiert medizinische Bilder und erkennt Krankheiten wie Tumore oder Anomalien.\n\n### Unterhaltung und Gaming\n**Spieldesign:** Generative KI erschafft neue Level, Charaktere oder Szenarien für Videospiele.\n\n**Filmproduktion:** Erstellung von Drehbüchern oder visuellen Effekten, die durch KI unterstützt werden.\n\n## Best Practices für den Einsatz von Generativer KI\nDer erfolgreiche Einsatz von generativer KI erfordert durchdachte Ansätze, um Qualität, Sicherheit und Effektivität zu gewährleisten.\n\n**Definierte Ziele setzen:** Bevor ein KI-Modell eingesetzt wird, sollte klar definiert sein, welche spezifischen Aufgaben oder Probleme es lösen soll. Eine präzise Zielsetzung verhindert Fehlentwicklungen und verbessert die Ergebnisse.\n\n**Kontext berücksichtigen:** Die generierten Inhalte müssen immer mit ihrem Einsatzzweck übereinstimmen. Dies umfasst die Berücksichtigung kultureller, sozialer oder geschäftlicher Anforderungen, um relevante und angemessene Ergebnisse zu erzielen.\n\n**Vielfältige Evaluation:** Die Leistung von KI-Modellen sollte mit verschiedenen Methoden überprüft werden. Neben technischen Metriken ist auch qualitatives Feedback von Expert(inn)en und Nutzer(inne)n entscheidend, um die Anwendbarkeit und Qualität sicherzustellen.\n\n**Kontinuierliche Optimierung:** KI-Modelle sollten regelmäßig überprüft und weiterentwickelt werden, um auf veränderte Daten, Anforderungen oder Technologien reagieren zu können.\n\n## Herausforderungen und ethische Aspekte von generativer KI\nNeben den zahlreichen Vorteilen bringt der Einsatz generativer KI auch einige Herausforderungen mit sich:\n\n**Urheberrechtsfragen:** Es bleibt unklar, wem die Rechte an KI-generierten Inhalten gehören – den Entwicklern, den Nutzern oder sogar den Datengrundlagen?\n\n**Verzerrungen in den Ergebnissen:** Wenn die zugrunde liegenden Trainingsdaten voreingenommen sind, können die generierten Inhalte diese Vorurteile widerspiegeln und verstärken.\n\n**Potenzial für Missbrauch:** Generative KI kann für negative Zwecke eingesetzt werden, etwa zur Verbreitung von Fehlinformationen oder zur Durchführung von Cyberangriffen.\n\nUm die Herausforderungen im Umgang mit generativer KI zu bewältigen, ist es entscheidend, mehr Transparenz bei der Entwicklung und Nutzung von KI-Modellen zu schaffen. Darüber hinaus sollten klare ethische Standards sowie gesetzliche Regelungen eingeführt und konsequent eingehalten werden, um potenzielle Risiken zu minimieren und einen verantwortungsvollen Einsatz sicherzustellen.\n\n## Wie setzt GitLab generative KI ein\n[GitLab](https://about.gitlab.com/de-de/) integriert generative KI umfassend in seine DevSecOps-Plattform, um den gesamten Softwareentwicklungsprozess zu optimieren. Durch die Partnerschaft mit Unternehmen wie Anthropic nutzt GitLab fortschrittliche KI-Modelle, um Entwickler(innen) bei verschiedenen Aufgaben zu unterstützen.\n\n**Code-Vorschläge:** Die Funktion [Code Suggestions](https://about.gitlab.com/blog/gitlab-uses-anthropic-for-smart-safe-ai-assisted-code-generation/) bietet während des Tippens kontextbezogene Code-Vorschläge, was die Effizienz beim [Code Refactoring](https://about.gitlab.com/de-de/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo/) erhöht. \n\n**Automatische Reviewer-Zuweisung:** Mit [Suggested Reviewers](https://about.gitlab.com/blog/gitlab-ai-assisted-features/) identifiziert die KI geeignete Personen für die Überprüfung von Merge Requests, was den Review-Prozess beschleunigt. \n\n**Zusammenfassungen von Merge Requests:** Die KI generiert prägnante Zusammenfassungen von Änderungen in Merge Requests, um die Kommunikation zwischen Teammitgliedern zu erleichtern. \n\n**Erklärung von Schwachstellen:** Die Funktion „Explain This Vulnerability” hilft Entwickler(innen), Sicherheitslücken besser zu verstehen und effizienter zu beheben. \n\n**Testgenerierung in Merge Requests:** Die KI kann automatisch Tests für neuen Code generieren, um die Qualitätssicherung zu unterstützen.\n\n### GitLab Duo – weiter hilfreiche KI-Funktionen\nDurch diese erweiterten KI-Funktionen fördert GitLab eine effizientere, sicherere und innovativere Softwareentwicklung.\n\n**[GitLab Duo Chat:](https://docs.gitlab.com/development/ai_features/duo_chat/)** Ein KI-gestützter Chatbot, der Fragen beantwortet und bei der Navigation durch die Plattform hilft, um den Lernprozess zu unterstützen.\n\n**Refactoring von Code in moderne Sprachen:** GitLab Duo unterstützt Entwickler(innen) dabei, bestehenden Code in moderne Programmiersprachen zu überführen. Dies erleichtert die Modernisierung von Anwendungen und das Erlernen neuer Sprachfunktionen. \n\n**Sicheres Testen von KI-generiertem Code:** Durch die Kombination von GitLab Duo mit GitLab Pages können Entwickler(innen) KI-generierten Code gründlich testen und Sicherheitslücken identifizieren. Dies gewährleistet die Zuverlässigkeit und Sicherheit des Codes. \n\n**Automatisierte Entwicklung mit GitLab Duo Workflow:** [GitLab Duo Workflow](https://about.gitlab.com/de-de/blog/meet-gitlab-duo-workflow-the-future-of-ai-driven-development/) transformiert die Softwareentwicklung, indem es repetitive Aufgaben automatisiert und Entwickler(innen) ermöglicht, sich auf innovative Problemlösungen zu konzentrieren. \n\n[Teste GitLab Duo jetzt kostenlos!](https://about.gitlab.com/de-de/gitlab-duo/) \n\n## FAQs - Generative KI\n### Was ist der Unterschied zwischen AI und KI?\nEs gibt keinen Unterschied zwischen AI und KI. „AI” steht für „Artificial Intelligence”, „KI” steht für „Künstliche Intelligenz” und ist der deutsche Begriff für AI. Häufig werden beide Begriffe verwendet – die Bedeutung ist jedoch immer dieselbe. \n\n### Wo wird generative KI angewendet?\nGenerative KI findet Anwendung in der Content-Erstellung, bei Designprozessen, in der Medizin zur Analyse und Modellierung, in der Softwareentwicklung für automatisierte Codegenerierung und in der Unterhaltungsindustrie zur Erstellung von Filmen, Musik und Spielen.\n\n### Was unterscheidet generative KI von klassischer KI?\nKlassische KI verarbeitet und analysiert Daten, um Entscheidungen zu treffen oder Prozesse zu automatisieren. Generative KI hingegen erschafft eigenständig neue Inhalte, die sich an den erlernten Daten orientieren, aber originell und innovativ sind.\n\n### Welche Arten von generativer KI gibt es?\nZu den gängigen Modellen gehören GANs, Transformermodelle, Variational Autoencoders und Diffusionsmodelle. Jedes Modell ist auf spezifische Anwendungen wie die Generierung von Texten, Bildern oder Audio spezialisiert. \n\n### Wie sicher ist generative KI?\nDie Sicherheit generativer KI hängt stark von ihrem Einsatz ab. Während sie viele positive Anwendungen hat, können Risiken wie die Erstellung von Falschinformationen oder urheberrechtliche Konflikte auftreten, wenn sie nicht verantwortungsvoll genutzt wird.\n\n### Welche Herausforderungen gibt es bei generativer KI?\nHerausforderungen umfassen den hohen Rechenaufwand, die Qualität der Trainingsdaten, ethische Fragen wie Bias in Modellen und mögliche Missbrauchsrisiken, etwa durch die Generierung manipulativer Inhalte.\n\n### Wie wird generative KI bei GitLab eingesetzt?\nGitLab nutzt generative KI, um Entwicklungsprozesse zu optimieren. Sie wird unter anderem für automatisierte Code-Vorschläge, Dokumentationserstellung und Fehlerbehebung eingesetzt, wodurch Entwickler(innen) Zeit sparen und effizienter arbeiten können.",[683],{"slug":776,"featured":6,"template":692},"what-is-generative-ai","content:de-de:blog:what-is-generative-ai.yml","What Is Generative Ai","de-de/blog/what-is-generative-ai.yml","de-de/blog/what-is-generative-ai",{"_path":782,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":783,"content":789,"config":795,"_id":797,"_type":16,"title":798,"_source":18,"_file":799,"_stem":800,"_extension":21},"/de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance",{"title":784,"description":785,"ogTitle":784,"ogDescription":785,"noIndex":6,"ogImage":786,"ogUrl":787,"ogSiteName":674,"ogType":675,"canonicalUrls":787,"schema":788},"Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow","Erfahre, wie du mithilfe von agentischer KI Unit-Tests zu einer Java-Anwendung hinzufügst (Video-Tutorial inklusive).","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097617/Blog/Hero%20Images/Blog/Hero%20Images/Workflow%201800x945_2gQoQIbY9NvjLFpXtsxtXy_1750097616649.png","https://about.gitlab.com/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cesar Saavedra\"}],\n        \"datePublished\": \"2025-04-10\",\n      }\n                  ",{"title":784,"description":785,"authors":790,"heroImage":786,"date":791,"body":792,"category":14,"tags":793,"updatedDate":794},[728],"2025-04-10","Die Qualität deiner Anwendungen durch testbasiertes Design, gute Testabdeckung und Fehlererkennung sicherzustellen, ist für deine Kund(inn)en und deinen Ruf immens wichtig, kann aber auch ziemlich zeitaufwändig sein. [GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/workflow/), eine agentische KI, die auf der umfassendsten DevSecOps-Plattform aufbaut, kann dir dabei helfen, Entwicklungsaufgaben wie das Hinzufügen von Unit-Tests zu einer Java-Anwendung schnell zu erledigen. In diesem Tutorial siehst du anhand eines [Java-Beispielprojekts](https://gitlab.com/gitlab-da/playground/csaavedra/gdw/prodmgr-gdw), wie das geht.\n\n> Der GitLab Duo Workflow befindet sich derzeit in der privaten Beta-Phase. Trag dich in die [Warteliste](https://about.gitlab.com/de-de/gitlab-duo/workflow/) ein, um zu erfahren, was du mit KI-Tools, die deinen gesamten SDLC verstehen, alles machen kannst.\n\n## Öffne dein Projekt in VS Code\n\n1. Öffne das Java-Projekt in Visual Studio Code (nachdem du es auf deinen lokalen Computer geklont hast). Stelle sicher, dass du dich in einem Feature-Branch befindest (nicht im main- oder default-Branch), bevor du beginnst. Wenn du schon an einem Merge Request arbeitest, hat dieser einen eigenen Feature-Branch.\n\n2. (Dieser Schritt ist optional.) Gehe zu der Datei, die die Java-Klasse definiert, für die du mit GitLab Duo Workflow Unit-Tests erstellen möchtest. Sieh sie dir genau an, damit du später überprüfen kannst, ob die generierten Unit-Tests die Komponenten der Klasse abdecken. Das solltest du sehen:\n\n![Datei, die die Java-Klasse definiert, für die du mit GitLab Duo Workflow Unit-Tests erstellen möchtest](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097627482.png)\n\n**Hinweis:** Wir gehen davon aus, dass du die Erweiterung von GitLab Duo Workflow in VS Code bereits aktiviert hast. Wenn nicht, lies dir die [Einrichtungsdokumentation](https://docs.gitlab.com/user/duo_workflow/#use-workflow-in-vs-code) durch (nur in englischer Sprache verfügbar).\n\n3. Starte GitLab Duo Workflow, indem du die Befehlspalette von VS Code öffnest [Strg + Umschalt + P], „GitLab Duo Workflow“ eingibst und **GitLab: Duo Workflow anzeigen** auswählst. Es erscheint eine Registerkarte, die wie folgt aussieht:\n\n![Starten von GitLab Duo Workflow mit VS Code](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097627483.png)\n\n4. Im nächsten Schritt fügst du Tests für den Standardkonstruktor, die Überprüfung der Objekterstellung und den Anfangszustand der Eigenschaften der Klasse „Product“ hinzu. Dazu gibst du den folgenden Prompt in den Textbereich in GitLab Duo Workflow ein:\n\n```unset\nCreate unit tests for class defined in the Product.java file and store the unit tests in its own file titled ProductTest.java\n```\n\n(Erstelle Unit-Tests für die in der Datei „Product.java“ definierte Klasse und speichere die Unit-Tests in einer eigenen Datei mit dem Namen „ProductTest.java“.)\n\n![Eingabe eines Prompts in GitLab Duo Workflow](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097627484.png)\n\n5. Klick in GitLab Duo Workflow auf die Schaltfläche **Start**. Es werden zwei neue Fenster angezeigt: eins in der Mitte des Bildschirms und eins rechts davon. Das rechte Fenster zeigt die Analyse an, die GitLab Duo Workflow durchführt, um einen Plan zu erstellen, mit dem das in deinem Prompt angegebene Ziel erreicht werden kann. Der Plan wird im mittleren Fenster angezeigt. Nach Abschluss der Analyse und der Planerstellung sollte eine Ausgabe wie die folgende angezeigt werden:\n\n![Von GitLab Duo Workflow generierte Analyse und Plan](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097627486.png)\n\n6. Sieh dir die Analyse und den Plan an und klick unten im Fenster auf **Plan genehmigen**, wenn du damit einverstanden bist.\n\n7. GitLab Duo Workflow beginnt mit der Ausführung des genehmigten Plans und nimmt die entsprechenden Änderungen an deinem Projekt vor.\n\n8. Sobald die Ausführung des Plans abgeschlossen ist, siehst du im Projekt ein neues Verzeichnis `src/test/java/csaa/jspring/ProductManager` mit einer neuen Datei mit dem Namen `ProductTest.java`, die alle Unit-Tests für die Klasse `Product.java` enthält.\n\n![Neues Verzeichnis im Projekt mit einem neuen Dateinamen „ProductTest.java“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097627488.png)\n\n9. Navigiere zu der neu erstellten Datei `ProductTest.java`. Du wirst sehen, dass einige Importanweisungen rot unterstrichen sind, was auf Importfehler hinweist:\n\n![„ProductTest.java“ enthält Importanweisungen und Fehleranzeigen in Rot](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097627489.png)\n\nGitLab Duo Workflow soll das für uns beheben.\n\n**Hinweis:** Wir hätten GitLab Duo Workflow auch in unserem ersten Prompt bitten können, die Datei `pom.xml` entsprechend zu aktualisieren. Da wir das aber nicht gemacht haben, beheben wir diese Fehler in einem neuen Workflow.\n\n## Starten von GitLab Duo Workflow, um Fehler im generierten Code zu beheben\n\n10. Starte einen neuen Workflow, indem du unten im Analysefenster auf der rechten Seite deines Bildschirms auf die Schaltfläche **Neuer Workflow** klickst.\n\n![Schaltfläche „Neuer Workflow“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097627491.png)\n\n11. Gib im Textbereich für den Prompt Folgendes ein:\n\n```unset\nThe file ProductTest.java has an error “The import org.junit cannot be resolved”. Please fix it\n```\n\n(Die Datei „ProductTest.java“ hat einen Fehler: „Der Import org.junit kann nicht aufgelöst werden“. Bitte behebe diesen Fehler.)\n\n12. Nachdem du den vorgeschlagenen Plan genehmigt hast, startet GitLab Duo Workflow seine Analyse, indem es die aktuelle `pom.xml`-Datei liest. Anschließend wird sie bearbeitet und die veraltete JUnit-Abhängigkeit entfernt. Danach werden die richtige Abhängigkeit und Version für JUnit hinzugefügt. Zuletzt wird die Datei `ProductTest.java` gelesen, um alle Abhängigkeitsfehler zu beheben.\n\n![GitLab Duo Workflow führt eine Analyse durch, indem es die Datei „pom.xml“ liest.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097627492.png)\n\n## Sieh dir das Tutorial an\n\nDurch die Ausführung dieses Plans führt GitLab Duo Workflow effektiv Aktualisierungen am Projekt durch, um die im Prompt geforderten Aufgaben zu erfüllen. Das spart Zeit und Aufwand und steigert die Produktivität, sodass Entwickler(innen) mehr Zeit für Innovationen und die Schaffung von Mehrwert für ihr Unternehmen aufwenden können.\n\nWenn du sehen möchtest, wie das oben Beschriebene in der Praxis funktioniert, sieh dir das folgende Video an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/Tuj7TgqY81Q?si=RReuL1pUsLafvAzs\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line ->\n\n> Trag dich in die [Warteliste für die private Beta-Version von GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/workflow/) ein, um zu sehen, was du mit KI-Tools machen kannst, die deinen gesamten SDLC verstehen.\n\n## Mehr über GitLab Duo Workflow und agentische KI\n\n- [GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/)\n- [Dokumentation für GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/duo_workflow/)\n- [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/)\n- [Agentische KI: Entwicklerpotenzial in großem Maßstab freisetzen (The Source) (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/agentic-ai-unlocking-developer-potential-at-scale/)\n",[683,686,688,687,685],"2025-05-01",{"slug":796,"featured":6,"template":692},"use-gitlab-duo-workflow-to-improve-application-quality-assurance","content:de-de:blog:use-gitlab-duo-workflow-to-improve-application-quality-assurance.yml","Use Gitlab Duo Workflow To Improve Application Quality Assurance","de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance.yml","de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance",{"_path":802,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":803,"content":809,"config":816,"_id":818,"_type":16,"title":819,"_source":18,"_file":820,"_stem":821,"_extension":21},"/de-de/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy",{"title":804,"description":805,"ogTitle":804,"ogDescription":805,"noIndex":6,"ogImage":806,"ogUrl":807,"ogSiteName":674,"ogType":675,"canonicalUrls":807,"schema":808},"GitLab Duo Self-Hosted: Enterprise-KI für mehr Datenschutz","Kund(inn)en in regulierten Branchen können GitLab Duo jetzt auf Self-Managed-Infrastruktur bereitstellen und so leistungsfähige generative KI nutzen, ohne dabei die Datenresidenz und Datenschutzbedenken über Bord werfen zu müssen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097840/Blog/Hero%20Images/Blog/Hero%20Images/Self-Hosted%201800x945_1dL1II2ITh2PteObA9DBLD_1750097839679.png","https://about.gitlab.com/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Self-Hosted: Enterprise-KI für mehr Datenschutz\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Susie Bitters\"},{\"@type\":\"Person\",\"name\":\"Aathira Nair\"}],\n        \"datePublished\": \"2025-02-27\",\n      }\n                  ",{"title":804,"description":805,"authors":810,"heroImage":806,"date":813,"body":814,"category":14,"tags":815},[811,812],"Susie Bitters","Aathira Nair","2025-02-27","Wir freuen uns, dass GitLab Duo Self-Hosted für GitLab Duo Code Suggestions und GitLab Chat jetzt allgemein verfügbar ist. Als optionale Funktion für Self-Managed-Kund(inn)en mit einem Abonnement von GitLab Duo Enterprise unterstützt GitLab Duo Self-Hosted eine flexible Bereitstellung auf mehreren Plattformen, darunter auf lokaler Infrastruktur, in privaten Clouds und in sicheren Cloud-Umgebungen über AWS Bedrock und Azure OpenAI. Mit GitLab Duo Self-Hosted können Teams mit KI-Unterstützung innovativ sein und gleichzeitig die Kontrolle über sensible Daten und geistiges Eigentum behalten.Sicherheitsbedenken stellen ein großes Hindernis für die Einführung von KI in regulierten Branchen dar. In unserer [globalen DevSecOps-Umfrage](http://about.gitlab.com/de-de/developer-survey/2024/ai) gab mehr als die Hälfte der Befragten an, dass die Einführung von KI in den Software-Entwicklungsprozess riskant sei. Mit [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) bieten wir Unternehmen nun eine Möglichkeit, sicherere Software dank in den gesamten Software-Entwicklungsprozess integrierte KI schneller bereitzustellen.GitLab Duo Self-Hosted weitet die verfügbaren KI-Funktionen von GitLab Duo auf Unternehmen mit strengen Datenschutzanforderungen aus und bietet sowohl bei der Auswahl der für die KI verwendeten großen Sprachmodelle (LLM) als auch bei den Bereitstellungsoptionen mehr Flexibilität. Zu den Erstanwender(inne)n von GitLab Duo Self-Hosted zählen Unternehmen im öffentlichen Bereich und in regulierten Branchen, z. B. im Bereich der Finanzdienstleistungen, im Automobilsektor und im Gesundheitswesen. Diese Unternehmen möchten KI als Wettbewerbsvorteil nutzen, indem sie KI-basierte Entwicklungstools in ihre Umgebungen integrieren und gleichzeitig Sicherheitsteams die Kontrolle bieten, die sie brauchen.Eine US-Regierungsbehörde berichtet: „Nachdem wir GitLab als Eckpfeiler unserer behördenweiten DevSecOps-Plattform ausgewählt hatten, entschieden wir uns dafür, GitLab Duo Self-Hosted zu verwenden, um die Funktionen unserer Software Factory weiter zu verbessern. Die Möglichkeit, GitLab Duo in Air-Gapped-Umgebungen einzusetzen, sowie die granulare Kontrolle über unsere Daten war für die Bereitstellung sicherer KI-basierter Funktionen von entscheidender Bedeutung. Dieser einheitliche Ansatz vereinfacht unseren Workflow und stärkt die Sicherheit, sodass wir mit KI eine höhere Produktivität erzielen und gleichzeitig die strengen Compliance-Anforderungen erfüllen können.“ \n\n![Modelle von GitLab Duo Self-Hosted](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097848/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097848329.png)\n\n## Sichere KI-Bereitstellungen entwickeln\n\nMit GitLab Duo Self-Hosted können Funktionen von GitLab Duo genutzt werden, wobei eine kuratierte Auswahl an führenden KI-LLMs geboten wird, darunter von Anthropic, Mistral und OpenAI. Diese LLMs unterstützen GitLab derzeit:\n\n* Lokal: Mistral-Modelle mit der vLLM-Serving-Plattform  \n* AWS: Mistral und Anthropic Claude 3.5 Sonnet über AWS Bedrock  \n* Microsoft Azure: OpenAI-GPT-Modelle über Azure AI\n\nWir prüfen weitere Modelle, die in naher Zukunft unterstützt werden sollen. [Erfahre mehr über die von uns unterstützten LLMs.](https://docs.gitlab.com/ee/administration/self_hosted_models/supported_models_and_hardware_requirements.html#approved-llms)\n\nZu den Bereitstellungsoptionen von GitLab Duo Self-Hosted gehören lokale Installationen, die auf dem Open-Source-vLLM-Framework basieren, sowie Bereitstellungen in privaten Clouds über Dienste wie AWS Bedrock und Microsoft Azure AI. Diese Flexibilität hilft Unternehmen, KI-Lösungen zu nutzen, die ihren einzigartigen Sicherheits-, Compliance- und Performance-Anforderungen entsprechen.\n\n## KI-/ML-Implementierung vereinfachen\n\nDie KI-Abstraktionsschicht von GitLab Duo standardisiert und vereinfacht die Integration des ausgewählten LLM in eine Funktion, wodurch die Implementierung von KI-/ML-Technologien vereinfacht wird. So können Unternehmen die Einführung von KI optimieren und das Entwicklererlebnis verbessern, ohne sich mit der Komplexität der Integration und Wartung mehrerer Tools auseinandersetzen zu müssen.\n\n![KI-basierte Funktionen von GitLab Duo Self-Hosted](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097848/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097848330.png)\n\n## Kontrolle über sensible Daten behalten\n\nDurch die Isolierung deiner GitLab-Instanz, deines KI-Gateways und der LLMs in deiner eigenen Umgebung oder dem Land deiner Wahl sorgst du mit GitLab Duo Self-Hosted dafür, dass sensible Daten und geistiges Eigentum innerhalb deines festgelegten Bereichs bleiben. Die granulare Kontrolle über die Datenlokalität ermöglicht es, strenge Vorschriften zur Datenresidenz einzuhalten und gleichzeitig KI-Funktionen in einer sicheren Umgebung zu nutzen. Egal, ob du GitLab Duo Self-Hosted in einer reinen Air-Gapped-Umgebung mit vLLM nutzt oder eine unterstützte private Cloud verwendest: Du kannst alle Aspekte der Bereitstellung kontrollieren, um den geografischen Standort der Komponenten einzubeziehen. Indem du nicht von externen APIs abhängig bist und volle Transparenz in alle Anfrage- und Antwortprotokolle hast, ermöglicht es GitLab Duo Self-Hosted sogar äußerst streng regulierten Unternehmen, KI-Funktionen mit gutem Gewissen zu nutzen und die strengsten Compliance-Vorgaben einzuhalten.\n\n**Beginne eine interaktive Tour durch GitLab Self-Hosted, indem du auf das folgende Bild klickst:**\n\n[![Screenshot von der Tour durch GitLab Duo Self-Hosted](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097848/Blog/Content%20Images/Blog/Content%20Images/Screenshot_2025-02-20_at_7.00.34_AM_aHR0cHM6_1750097848332.png)](https://gitlab.navattic.com/gitlab-duo-self-hosted)\n\n## Lege jetzt mit GitLab Duo Self-Hosted los\n\nWenn du bereit bist, deine KI-Reise voranzutreiben und gleichzeitig auf Sicherheit und Datenschutz zu achten, [wende dich an uns](https://about.gitlab.com/de-de/sales/), um GitLab Duo Self-Hosted jetzt in deiner Umgebung einzurichten. ",[683,685,686,687,684],{"slug":817,"featured":93,"template":692},"gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy","content:de-de:blog:gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy.yml","Gitlab Duo Self Hosted Enterprise Ai Built For Data Privacy","de-de/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy.yml","de-de/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy",{"_path":823,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":824,"content":830,"config":837,"_id":839,"_type":16,"title":840,"_source":18,"_file":841,"_stem":842,"_extension":21},"/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai",{"title":825,"description":826,"ogTitle":825,"ogDescription":826,"noIndex":6,"ogImage":827,"ogUrl":828,"ogSiteName":674,"ogType":675,"canonicalUrls":828,"schema":829},"GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau","Sichere, autonome, kontextbewusste KI-Tools übernehmen komplexe Aufgaben und geben Entwickler(inne)n die Möglichkeit, innovative Software schneller zu entwickeln. Die private Beta-Warteliste ist jetzt geöffnet.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660174/Blog/Hero%20Images/Workflow_1800x945.png","https://about.gitlab.com/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Pini Wietchner\"}],\n        \"datePublished\": \"2025-02-24\",\n      }\n                  ",{"title":825,"description":826,"authors":831,"heroImage":827,"date":833,"body":834,"category":14,"tags":835,"updatedDate":754},[832],"Pini Wietchner","2025-02-24","Setze dich ab heute auf die Warteliste für die [private Beta-Version von GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/workflow/): **eine agentische KI, die auf der umfassendsten DevSecOps-Plattform basiert.** GitLab Duo Workflow ist der nächste Schritt unserer KI-Roadmap und wird Entwicklungsteams innerhalb der IDE bei allen Aufgaben unterstützen – von Bootstrapping von Projekten bis hin zu Bereitstellungsprozessen, von der Fehlersuche bis hin zur teamübergreifenden Koordination.\n\nDabei nutzt GitLab Duo Workflow die Struktur der GitLab-Plattform für Zusammenarbeit, kontinuierliche Integration, kontinuierliche Bereitstellung, Sicherheit und Compliance, um Unternehmen dabei zu helfen, ihren Entwicklungsprozess mit KI-Tools zu beschleunigen.\n\nVerwende GitLab Duo Workflow, um:   \n* [ein neues Entwicklungsprojekt zu starten](#from-slow-project-setup-to-a-running-start)  \n* [Code zu modernisieren](#from-legacy-code-to-modern-applications)  \n* [kontextbezogene Aufgaben durchzuführen](#from-context-switching-toflow-state) \n* [eine Dokumentation zu erstellen](#from-stale-docs-to-dynamic-knowledge)\n* [die Testabdeckung zu verbessern](#from-patchy-to-comprehensive-testing) \n* und mehr.\n\nDas ist aber erst der Anfang. Mit dem einheitlichen Datenspeicher von GitLab gilt: Je mehr du GitLab verwendest, desto mehr Kontext hat GitLab Duo Workflow zu deinem Code, deinen Konfigurationen, deinen erkannten Sicherheitsrisiken und deinen Bereitstellungspraktiken. Das Ergebnis ist eine immer leistungsfähigere Entwicklungserfahrung, die auf dein Unternehmen zugeschnitten ist.\n\n## Das Versprechen und die Herausforderung von KI-Tools\n\nSoftware hat die Welt grundlegend verändert, aber nur ein winziger Bruchteil der Weltbevölkerung verfügt heute über die Fähigkeiten, Software zu entwickeln. Dennoch erreichen diese Entwickler(innen) Milliarden von Menschen mit Smartphones und Internetanschlüssen. Stellen Sie sich eine Welt vor, in der *mehr* Menschen produktionsreife Software entwickeln, sichern und bereitstellen können – es gäbe eine Explosion von Innovationen, da mehr Menschen Software entwickeln könnten, die Milliarden von Menschen beeinflusst. **[Agentische KI](https://about.gitlab.com/de-de/topics/agentic-ai/) wird dies ermöglichen.**\n\nKI-Tools verstehen den Kontext, kennen ganze Codebases und arbeiten aktiv an komplexen Softwareprojekten in den Bereichen Entwicklung, Sicherheit und Betrieb mit. Mit KI-Tools können Entwickler(innen) Software in einem Umfang entwickeln, der für Einzelpersonen oder sogar Teams bisher unvorstellbar war.\n\nDieser Trend wirft jedoch wichtige Fragen zu Transparenz, Kontrolle und den Auswirkungen von KI auf die Arbeit der Entwickler(innen) auf. Unternehmen müssen sicherstellen, dass KI die Fähigkeiten ihrer Entwickler(innen) verbessert und sie gleichzeitig den Überblick über ihren Entwicklungsprozess behalten. Der Schlüssel zum Erfolg liegt nicht nur in der Einführung von KI, sondern auch darin, sie so einzusetzen, dass sie die Entwickler(innen) unterstützt und gleichzeitig Sicherheit, Compliance und Governance gewährleistet.\n\n## Der Erfolg von KI hängt von deiner Plattform ab, nicht von dem Hinzufügen zusätzlicher Tools\n\nWenn du mit mehr Entwickler(inne)n, Code und potenziellen Sicherheitsrisiken arbeitest, bringen zusätzliche Tools für jede neue Herausforderung nur noch mehr Komplexität mit sich. Unsere jüngste [DevSecOps-Umfrage (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/platform/devops-teams-want-to-shake-off-diy-toolchains-a-platform-is-the-answer/) zeigt, wie ernst dieses Problem ist: DevSecOps-Teams jonglieren mit bis zu 14 verschiedenen Tools und verbringen bis zu 80 % ihrer Zeit mit Aufgaben, die nichts mit Programmierung zu tun haben. Damit KI wirklich effektiv sein kann, braucht sie außerdem hochwertige, einheitliche Daten. Das ist mit uneinheitlichen Tools schwer zu erreichen.\n\n**Die GitLab DevSecOps-Plattform in Kombination mit GitLab-KI-Tools** führt alles in einem einzigen Datenmodell zusammen, das Quellcode, Merge Requests, Epics, Benutzerkonten, Zugriffsrechte und vieles mehr umfasst. Die Tools, die wir entwickeln, nutzen den Kontext von Benutzer(inne)n und Projekten, um die Arbeitsweise von Teams zu standardisieren und die Aufgaben zu automatisieren, die nichts mit Programmierung zu tun haben und die Entwickler(innen) Zeit kosten, wie z. B. die Suche nach Sicherheitsproblemen und die Durchsetzung von Compliance-Regeln. Wenn KI direkt in die Plattform integriert wird, werden diese Funktionen noch leistungsfähiger. Dann werden KI-Tools zu Entwicklungspartnern, während du die Kontrolle darüber behältst, wie KI den Prozess verbessert.\n\n**Das ist keine ferne Zukunft, sondern das, was wir mit GitLab Duo Workflow schon jetzt entwickeln.**\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1059060959?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Duo Workflow, the future of secure agentic AI software development\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>`\n\n## GitLab Duo Workflow: KI-Tools auf der umfassendsten DevSecOps-Plattform\n\nGitLab Duo Workflow nutzt die durchgängige DevSecOps-Plattform von GitLab, um Entwickler(inne)n dabei zu helfen, ihr volles Potenzial auszuschöpfen. Während KI-Programmierassistenten bei der Programmierung einzelner Teile des Codes helfen, versteht GitLab Duo Workflow deinen gesamten Entwicklungslebenszyklus und automatisiert Routineaufgaben, damit sich die Entwickler(innen) auf strategische Innovationen und kreative Problemlösungen konzentrieren können. Wir entwickeln GitLab Duo Workflow, um Teams zu unterstützen: \n\n### Von der langsamen Projekteinrichtung zum schnellen Start\n\nEntwickler(innen) verbringen wertvolle Zeit damit, neue Projekte zu konfigurieren, Abhängigkeiten zu verwalten und die grundlegende Infrastruktur einzurichten, anstatt neue Funktionen zu entwickeln. Mit GitLab Duo Workflow kannst du **das Bootstrapping von Projekten direkt in der IDE automatisieren** und von Anfang an die richtigen Konfigurationen bereitstellen. So kannst du dich schneller darauf konzentrieren, Innovationen zu entwickeln.\n\n### Vom Legacy-Code zu modernen Anwendungen\n\nBei der Modernisierung von Legacy-Code geht es nicht nur um die Aktualisierung der Syntax, sondern auch um das Verständnis von Abhängigkeiten, Tests, CI/CD-Pipelines und Dokumentation. GitLab Duo Workflow hilft dir bei der **Modernisierung deiner Codebase, indem es das Code-Refactoring übernimmt** – vom Code bis hin zu Tests.\n\n### Vom Kontextwechsel zum Flow State\n\nEntwickler(innen) wechseln ständig zwischen Tools, Dokumenten und Codebases, um Probleme zu lösen. GitLab Duo Workflow hilft bei der **Lösung von Aufgaben mit dem vollständigen Kontext deiner Codebase-bezogenen Probleme und Merge Requests**, damit die Entwickler(innen) in ihrem Flow bleiben können.\n\n### Von einer veralteten Dokumentation zu dynamischem Wissen\n\nDokumentation verliert schnell an Aktualität, was das Verständnis und die Wartung von Codebases erschwert. GitLab Duo Workflow **unterstützt Entwickler(innen) bei der Erstellung und Aktualisierung der Dokumentation**, einschließlich README-Dateien, Ablaufdiagrammen und Architekturdokumentation.\n\n### Von lückenhaften zu umfassenden Tests\n\nMit dem Wachstum von Codebases wird es immer schwieriger, eine umfassende Testabdeckung zu gewährleisten. GitLab Duo Workflow **kann Tests für ganze Abschnitte deiner Codebase erstellen** und dabei deine bestehende Testinfrastruktur einbinden, sodass du mit weniger Aufwand eine zuverlässigere Software erhältst.\n\n## Melde dich für die private Beta-Warteliste an\n\n[Melde dich für die Warteliste für die private Beta-Version von GitLab Duo Workflow an](https://about.gitlab.com/de-de/gitlab-duo/workflow/), um beim nächsten Schritt in unserer Vision für sichere agentische KI dabei zu sein – von der Projekteinrichtung bis hin zur Bereitstellung. Diese Tools basieren auf der DevSecOps-Plattform von GitLab und verstehen deinen gesamten Software-Lebenszyklus, während sie gleichzeitig die Sicherheit und Kontrolle aufrechterhalten, die Unternehmen benötigen.\n\n*Haftungsausschluss: Diese Seite enthält Informationen über zukünftige Produkte, Funktionen und Funktionalitäten. Diese Informationen dienen nur zu Informationszwecken. Bitte verlasse dich daher nicht auf die Informationen, wenn du etwas kaufen oder planen möchtest. Alle Inhalte können sich ändern oder verzögern, und die Entwicklung, die Veröffentlichung und der Zeitplan liegen im alleinigen Ermessen von GitLab Inc.*",[686,683,685,687,684,836],"workflow",{"slug":838,"featured":93,"template":692},"gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai","content:de-de:blog:gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai.yml","Gitlab Duo Workflow Enterprise Visibility And Control For Agentic Ai","de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai.yml","de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai",{"_path":844,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":845,"content":851,"config":858,"_id":860,"_type":16,"title":861,"_source":18,"_file":862,"_stem":863,"_extension":21},"/de-de/blog/automating-with-gitlab-duo-part-3-validating-testing",{"title":846,"description":847,"ogTitle":846,"ogDescription":847,"noIndex":6,"ogImage":848,"ogUrl":849,"ogSiteName":674,"ogType":675,"canonicalUrls":849,"schema":850},"Automatisierung mit GitLab Duo, Teil 3: Validierung von Tests","Hier erfährst du, welche Tests wir durchgeführt haben, um die Auswirkungen von GitLab Duo auf die automatisierten Tests unseres Teams zu überprüfen – und welche Ergebnisse wir erzielt haben.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097447/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750097447404.png","https://about.gitlab.com/blog/automating-with-gitlab-duo-part-3-validating-testing","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Automatisierung mit GitLab Duo, Teil 3: Validierung von Tests\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Byron Boots\"}],\n        \"datePublished\": \"2024-12-17\",\n      }\n                  ",{"title":846,"description":847,"authors":852,"heroImage":848,"date":854,"body":855,"category":14,"tags":856},[853],"Byron Boots","2024-12-17","In früheren Beiträgen dieser Serie haben wir beschrieben, [wie wir GitLab Duo zur Erstellung von Tests für unseren Code verwendet haben](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests/) und [was wir bei der Verwendung von GitLab Duo zur Erstellung automatisierter Tests gelernt haben](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing/). Wir haben auch darüber berichtet, wie wir Änderungen an den von GitLab Duo generierten Tests vorgenommen haben. In diesem letzten Artikel der Reihe geht es um einen Test, den wir durchgeführt haben, um die Auswirkungen von GitLab Duo auf die automatisierten Tests unseres Teams zu validieren, und um die beeindruckenden Ergebnisse, die wir bis jetzt erzielt haben.\n\n### Ergebnisse des Validierungstests\n\nUm zu überprüfen, ob die Nutzung von GitLab Duo zur Erstellung von Tests den erwarteten Mehrwert bringt, haben wir uns selbst und GitLab Duo vor die Aufgabe gestellt, Tests zu ersetzen und die Testabdeckung zu erhöhen. Das Team entfernte alle bereits geschriebenen Tests, um die Testabdeckung auf 0 % zu bringen. Dann ging es methodisch durch das Repository und erstellte neue Testdateien, um die von GitLab Duo generierten Tests zu speichern.\n\nVon diesem Ausgangspunkt aus folgte das Team den Schritten, die im [ersten Blogbeitrag](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests/) beschrieben sind, um Tests zu erstellen. Um eine stabile Kontrollgruppe zu haben, wurden die Tests und Testdateien nicht von Menschen verändert. Für die Identifizierung, woher die Tests stammen, wurde am Anfang der Datei der Kommentar `Tests Generated by Duo` sowie am Ende der Zusatz `duo.py` hinzugefügt.\n\nAlle Iterationen der Tests erfolgten ausschließlich durch Interaktion mit GitLab Duo über `Generate Tests` und das GitLab-Duo-Chat-Fenster, wie [im zweiten Blogartikel dieser Reihe](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing/) beschrieben. Wie bereits erwähnt, haben wir GitLab Duo gebeten, Aktualisierungen vorzunehmen, die auf aufgetretenen Fehlern, fehlgeschlagenen Tests und Beispielcode-Schnipseln basieren, die GitLab Duo als zusätzlichen Kontext verwenden kann.\n\nBeim Testen mit GitLab Duo haben wir ständig Tests ausgeführt und Abdeckungsberichte erstellt, damit wir sehen konnten, ob unsere von GitLab Duo generierten Tests die Testabdeckung erhöhen und den erwarteten Mehrwert bringen. Mit der [Visualisierung der Testabdeckung von GitLab](https://docs.gitlab.com/ee/ci/testing/test_coverage_visualization/) (nur in englischer Sprache verfügbar) konnten wir die Ergebnisse unserer Arbeit kontinuierlich überwachen.\n\nNachdem wir mit GitLab Duo die Tests für den Code neu erstellt hatten, der zuvor hauptsächlich durch manuelle Tests abgedeckt war, konnten wir schließlich eine Testabdeckung von 84 % erreichen. Das war ein großer Erfolg für das Team, denn:\n\n1. Es war eine signifikante Verbesserung gegenüber der vorherigen Abdeckung, die bei 74 % lag.  \n2. Eine einzelne Person brauchte etwa zwei Tage, um eine Testabdeckung von 84 % zu erreichen, während zuvor mehrere Entwickler(innen) etwa vier Wochen für die manuelle Testabdeckung von 74 %  benötigt hatten.\n\nSeit diesem Experiment hat das Team die Abdeckung mit Hilfe von GitLab Duo sogar noch auf 89 % erhöht und gleichzeitig neue Funktionen eingeführt.\n\n![Abbildung der Erfolge](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097456/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097456771.png)\n\nDurch den Einsatz von GitLab Duo konnten die Testeffizienz und die Testabdeckung erhöht werden. Außerdem konnten Entwickler(innen), die mit dem vorhandenen Code weniger vertraut sind, schnell sinnvolle Tests schreiben. Das hat das Vertrauen des Teams gestärkt, neue Funktionen zu entwickeln, ohne befürchten zu müssen, Fehler einzuführen.\n\n> Wenn du [GitLab Duo ausprobieren](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/) möchtest, melde dich noch heute für eine kostenlose 60-tägige Testversion an!\n",[683,857,686,685],"testing",{"slug":859,"featured":6,"template":692},"automating-with-gitlab-duo-part-3-validating-testing","content:de-de:blog:automating-with-gitlab-duo-part-3-validating-testing.yml","Automating With Gitlab Duo Part 3 Validating Testing","de-de/blog/automating-with-gitlab-duo-part-3-validating-testing.yml","de-de/blog/automating-with-gitlab-duo-part-3-validating-testing",{"_path":865,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":866,"content":872,"config":878,"_id":880,"_type":16,"title":881,"_source":18,"_file":882,"_stem":883,"_extension":21},"/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing",{"title":867,"description":868,"ogTitle":867,"ogDescription":868,"noIndex":6,"ogImage":869,"ogUrl":870,"ogSiteName":674,"ogType":675,"canonicalUrls":870,"schema":871},"Automatisierung mit GitLab Duo, Teil 2: Komplexes Testen","Hier erfährst du, wie das GitLab-Team mit Hilfe der KI-Funktionen von GitLab Duo komplexere Testsituationen bewältigt und dabei auch sicherstellt, dass die Code-Tests den Standards entsprechen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099243/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750099243011.png","https://about.gitlab.com/blog/automating-with-gitlab-duo-part-2-complex-testing","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Automatisierung mit GitLab Duo, Teil 2: Komplexes Testen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Byron Boots\"}],\n        \"datePublished\": \"2024-12-10\",\n      }\n                  ",{"title":867,"description":868,"authors":873,"heroImage":869,"date":874,"body":875,"category":14,"tags":876,"updatedDate":877},[853],"2024-12-10","Im ersten Teil unserer dreiteiligen Serie über die [Testerstellung mit GitLab Duo](https://about.gitlab.com/de-dE/blog/automating-with-gitlab-duo-part-1-generating-tests/) ging es darum, wie man Code-Tests automatisieren kann. Jetzt werden wir die Erfahrungen teilen, die wir beim Einsatz von KI für die Testgenerierung gemacht haben.\n\n## Herausforderungen und wie wir sie gemeistert haben\n\nInsgesamt waren wir mit den Ergebnissen zufrieden, die wir mit [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) bei der Testgenerierung für unseren Code erzielt haben. Wie bei jeder Sprachgenerierung waren in einigen Fällen kleinere Anpassungen erforderlich, z. B. die Korrektur von Importpfaden oder die Bearbeitung von Inhalten in Datensätzen. Bei den komplexeren Fällen mussten wir berücksichtigen, dass KI-Lösungen oft der Kontext fehlt. Hier erfährst du, wie wir die komplexeren Testsituationen mit GitLab Duo gemeistert haben.\n\n### Aktualisieren bestehender Testfälle\n\nWie so oft bei der Entwicklung eines Softwareprodukts stießen wir auf Fälle, in denen wir bestehende Tests aktualisieren mussten. Anstatt eine komplette Testsuite für ein häufiges Problem manuell anzupassen, nutzten wir die Fähigkeiten des GitLab-Duo-Chat-Fensters in VS Code voll aus. Um beispielsweise Tests zu überarbeiten, nutzten wir den Chat-Prompt „Please update the provided tests to use unittest rather than pytest“ („Aktualisiere die bereitgestellten Tests so, dass sie unittest und nicht pytest verwenden“) und fügten dann die Tests ein, die GitLab Duo aktualisieren sollte.\n\n![Automatisierte Testgenerierung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099252/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750099252303.png)\n\n\u003Cbr>\u003C/br>\n\n![Chat-Prompt zur Verwendung von unittest anstelle von pytest](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099252/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750099252304.png)\n\n**Hinweis:** Wir haben die Empfehlungen von GitLab Duo kopiert und in unseren Code eingefügt.\n\n### Erstellen von Tests für Legacy-Code\n\nDas Erstellen von Tests für älteren Code, von dem wir wussten, dass er funktioniert, war eine weitere Herausforderung. In solchen Fällen war es sinnvoll, neben den fehlgeschlagenen Tests auch Fehlerschnipsel bereitzustellen und GitLab Duo zu bitten, neue Tests zu erstellen. Wir haben die Fehler aus dem Terminalfenster in den Chat kopiert und mit der Aufforderung „Please explain and fix this failing test“ („Erkläre und behebe diesen fehlgeschlagenen Test“) oder ähnlichen Prompts eine Zusammenfassung der Probleme mit dem Test ausgeben lassen sowie einen neuen Test erstellt, der das Problem behebt. Wir mussten feststellen, dass dies manchmal mehrere Überarbeitungsrunden erforderte, wenn neue Testfehler auftraten. Die Effizienz von GitLab Duo bei der Erstellung verschiedener überarbeiteter Lösungen war jedoch schnell und wirkte sich positiv auf die Effizienz des Teams und der Entwickler(innen) aus.\n\n### Herausforderungen mit komplexem oder abstraktem Code\n\nIn anderen Fällen führte die Modularisierung oder die Komplexität unseres Codes zu Abweichungen bei den Ergebnissen von GitLab Duo. Bei der Erstellung von Tests erzeugte GitLab Duo beispielsweise manchmal eine Reihe bestandener und fehlgeschlagener Tests, was auf unterschiedliche Testansätze zurückzuführen war (z. B. die Verwendung von Simulationen und die Objekte, die simuliert wurden). Wir gaben GitLab Duo ein eigenes Beispiel für einen bestandenen Test und forderten es auf, die einzelnen Tests nacheinander so zu ändern, dass sie dem Stil der bestandenen Tests entsprechen, um die Konsistenz zu wahren. Außerdem stellten wir GitLab Duo eine Datei mit funktionierenden Tests für ein ähnliches Objekt oder eine ähnliche Aufgabe zur Verfügung, damit es die Struktur nachbilden konnte.\n\n### Sicherstellen, dass der generierte Code unseren Standards entspricht\n\nWährend der Entwicklung eines Python-Moduls generierte GitLab Duo viele Tests mit Simulationen, die oft überarbeitet werden mussten, insbesondere im Hinblick auf die Standardisierung der Namensgebung. In solchen Fällen konnten wir GitLab Duo Chat nutzen, um die Tests zu überarbeiten und Anweisungen zu geben, welche Testkomponenten zu aktualisieren waren. GitLab Duo zu diesen Änderungen aufzufordern, war wesentlich schneller als die Überarbeitung einzelner Tests, wie wir es zuvor getan hatten.\n\n### Nicht abgedeckte Testfälle\n\nGitLab Duo erstellte Tests für zusätzliche Testfälle, die das Team zuvor nicht berücksichtigt hatte, und erhöhte so die Abdeckung. So konnten wir dank GitLab Duo diese Grenzfälle schnell und effizient angehen und die Testabdeckung erweitern, was für unser Team einen wichtigen Mehrwert darstellt, um schneller ein robustes Produkt zu entwickeln.\n\n## Was wir gelernt haben\n\nDie folgenden Erkenntnisse waren wichtig für unseren Erfolg mit GitLab Duo:\n\n* **Schnell und effizient für eine schnelle Entwicklung und Iteration –** Die Rolle von GitLab Duo bei der Erstellung von automatisierten Tests war für unser Team ein wichtiger Beschleuniger bei der Entwicklung und ermöglichte es uns, schneller und mit größerem Vertrauen in unsere Änderungen zu arbeiten.\n* **Es ist wichtig, geeignete Prompts zu verwenden –** Bei der Verwendung von GitLab Duo für unseren Anwendungsfall sind wir auf ein wichtiges Thema für die Optimierung des Machine Learning gestoßen: das Prompt-Engineering. Manchmal mussten wir nur wenige Schlüsselwörter in unserer Frage ändern, um die ideale Antwort zu generieren.\n* **Wir müssen die zugrunde liegenden Frameworks und den Code verstehen –** Bei jeglichem KI-generierten Code, der in ein Produkt einfließt, selbst wenn es sich nur um Tests handelt, ist es wichtig, dass wir verstehen, wie der Code funktioniert, damit wir ihn angemessen debuggen und Änderungen beantragen können.\n* **Wir müssen den gewünschten Endzustand und die Standards kennen –** Ähnlich wie bei der Einhaltung von Programmierstandards für die Formatierung und die Verwendung von Bibliotheken bei der Entwicklung ohne KI ist es wichtig, die Übersicht darüber zu behalten, wie die beabsichtigten Ergebnisse aussehen sollen und welche Standards beim Einsatz von KI eingehalten werden müssen. GitLab Duo braucht den Kontext, um Code-Standards zu verstehen. Deshalb ist es wichtig, dass die Teammitglieder, die GitLab Duo nutzen, die Ergebnisse angemessen überwachen, um sicherzustellen, dass die Qualität und andere Erwartungen erfüllt werden.\n* **GitLab Duo ist kein Ersatz für alle Tests –** Auch wenn wir GitLab Duo in großem Umfang für die Erstellung automatisierter Tests nutzen, ersetzt es nicht unsere anderen Tests und die menschliche Aufsicht. Funktionale Tests, Integrationstests und andere Tests haben nach wie vor einen wichtigen Platz im Qualitätssicherungsprozess und im gesamten Software-Entwicklungsprozess.\n\nIn unserem nächsten Artikel der Reihe geht es um einen Test, den wir durchgeführt haben, um die Auswirkungen von GitLab Duo auf die automatisierten Tests unseres Teams zu validieren, und um die beeindruckenden Ergebnisse, die wir bis jetzt erzielt haben.",[683,857,686],"2025-01-14",{"slug":879,"featured":6,"template":692},"automating-with-gitlab-duo-part-2-complex-testing","content:de-de:blog:automating-with-gitlab-duo-part-2-complex-testing.yml","Automating With Gitlab Duo Part 2 Complex Testing","de-de/blog/automating-with-gitlab-duo-part-2-complex-testing.yml","de-de/blog/automating-with-gitlab-duo-part-2-complex-testing",{"_path":885,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":886,"content":891,"config":896,"_id":898,"_type":16,"title":899,"_source":18,"_file":900,"_stem":901,"_extension":21},"/de-de/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai",{"title":887,"description":888,"ogTitle":887,"ogDescription":888,"noIndex":6,"ogImage":745,"ogUrl":889,"ogSiteName":674,"ogType":675,"canonicalUrls":889,"schema":890},"GitLab Duo mit Amazon Q: DevSecOps trifft agentenbasierte KI","KI-basiertes DevSecOps, das mit autonomen KI-Tools erweitert wird, steigert die Produktivität der Entwickler(innen), die Anwendungsmodernisierung und beschleunigt Innovation.","https://about.gitlab.com/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo mit Amazon Q: DevSecOps trifft agentenbasierte KI\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Emilio Salvador\"}],\n        \"datePublished\": \"2024-12-03\",\n      }\n                  ",{"title":887,"description":888,"authors":892,"heroImage":745,"date":893,"body":894,"category":14,"tags":895,"updatedDate":754},[750],"2024-12-03","Es ist uns eine Freude, GitLab Duo mit Amazon Q anzukündigen, ein gemeinsames Angebot, das die umfassende, KI-basierte DevSecOps-Plattform von GitLab mit den autonomen KI-Tools von Amazon Q in einer einzigen, integrierten Lösung vereint.\n\nGitLab Duo mit Amazon Q verändert die Softwareentwicklung, indem es leistungsstarke KI-Tools direkt in deine täglichen Arbeitsabläufe integriert. Anstatt zwischen verschiedenen Tools zu wechseln, können Entwickler(innen) jetzt wichtige Aufgaben – von der Feature-Entwicklung bis hin zu Code Reviews – innerhalb der umfassenden DevSecOps-Plattform von GitLab beschleunigen. Die KI-Tools von Amazon Q fungieren als intelligente Assistenten, die zeitaufwändige Aufgaben wie die Codegenerierung aus Anforderungen, die Erstellung von Unit-Tests, die Durchführung von Code Reviews und die Modernisierung von Java-Anwendungen automatisieren. Dieses gemeinsame Angebot hilft Teams, sich auf Innovationen zu konzentrieren und gleichzeitig die Sicherheits- und Qualitätsstandards einzuhalten, indem es diese komplexen Aufgaben übernimmt.\n\nDieses erstklassige Entwicklererlebnis beinhaltet:\n* Die einheitliche GitLab-Plattform mit einem einzigen Datenspeicher, der das Erstellen, Testen, Paketieren und Bereitstellen von sicherem Code automatisiert.\n* GitLab Duo mit Amazon Q Developer, das den GitLab-Projektkontext nutzt, um aufgabenabhängige Änderungen an mehreren Dateien vorzunehmen\n* KI-Tools von Amazon Q, die in GitLab Duo integriert sind, die Tickets aktualisieren und Merge Requests pro Aufgabe erstellen, wobei die Berechtigung auf das Projekt beschränkt ist\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1033653810?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Duo and Amazon Q\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## Partnerschaftsinnovation: GitLab und AWS\n\nGitLab Duo mit Amazon Q ist das Ergebnis einer engen Zusammenarbeit zwischen GitLab und AWS-Engineering-Teams, die unsere Stärken kombiniert, um die Softwareentwicklung zu verändern. Diese Partnerschaft vereint das Fachwissen von GitLab im Bereich Unified DevSecOps mit der führenden Rolle von AWS im Cloud Computing und schafft so eine innovative Lösung, die versteht, wie Entwickler(innen) arbeiten\n\nDurch die Integration der autonomen Agents von Amazon Q mit der umfassenden KI-basierten Plattform von GitLab haben wir mehr als nur eine technische Integration geschaffen. Wir haben eine Erfahrung geschaffen, mit der sich die KI-basierte Entwicklung natürlich anfühlt und die Sicherheit, Compliance und Zuverlässigkeit gewährleistet, die Unternehmen benötigen.\n\nBranchenanalyst(inn)en erkennen die Bedeutung dieser Integration für den Fortschritt der KI-basierten Softwareentwicklung:\n\n***„Mit diesem gemeinsamen Angebot bündeln GitLab und AWS ihre Stärken, um [agentenbasierte KI](https://about.gitlab.com/de-de/topics/agentic-ai/) in der Softwareentwicklung Realität werden zu lassen“, sagt Katie Norton, Research Manager bei IDC. „GitLab Duo mit Amazon Q geht starke Anwendungsfälle und kritische Herausforderungen an, mit denen Kund(inn)en das volle Potenzial der KI nutzen können.“***\n\n***„Sowohl Entwickler(innen) als auch die Unternehmen, für die sie arbeiten, sind zunehmend an vereinfachten und einheitlichen Erfahrungen interessiert“, sagt Rachel Stephens, Senior Analyst bei RedMonk. „Vor allem im Zeitalter der KI, in dem Sicherheit und Datenschutz an erster Stelle stehen, wollen Unternehmen die Möglichkeiten modernster Technologien nutzen, gleichzeitig aber auch Risiken kontrollieren und unzusammenhängende Software-Toolketten minimieren. Die Partnerschaft zwischen GitLab Duo und Amazon Q bietet Entwickler(inne)n die Werkzeuge, die sie im Rahmen einer durchgängigen DevSecOps-Erfahrung benötigen.“***\n\n## 4 wichtige Kundenvorteile \n\nGitLab Duo mit Amazon Q kombiniert KI-basiertes DevSecOps mit umfassenden Cloud-Computing-Funktionen. Gemeinsam helfen sie Entwicklungsteams bei folgenden Herausforderungen:\n\n### 1. Optimieren der Funktionsentwicklung von der Idee bis zum Code \n\nEntwicklungsteams verbringen oft Stunden damit, Anforderungen in Code zu übersetzen, was zu einer langsameren Bereitstellung und inkonsistenten Umsetzung führt. Du kannst jetzt den Agent „GitLab Duo mit Amazon Q“ mit dem neuen Schnellzugriff `/q dev` aufrufen. Damit wird eine Ticketbeschreibung in wenigen Minuten direkt in zusammenführbaren Code umgewandelt. Der Agent analysiert die Anforderungen, plant die Umsetzung und erstellt einen vollständigen Merge Request – alles unter Einhaltung der Entwicklungsstandards deines Teams. Teams können mit Hilfe von Feedback in Kommentaren schnell iterieren und so die Zeit von der Idee bis zur Produktion deutlich verkürzen.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050110?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Feature Dev with Rev\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### 2. Einfaches Modernisieren von Legacy-Code\n\nDas Upgraden von Java-Anwendungen erfordert normalerweise wochenlange sorgfältige Planung, manuelle Codeänderungen und umfangreiche Tests. Der Schnellzugriff `/q transform` automatisiert den gesamten Prozess der Java-Modernisierung für dich. In wenigen Minuten, nicht Stunden, analysiert der Agent deine Codebase in Java 8 oder 11, erstellt einen umfassenden Upgrade-Plan und generiert vollständig dokumentierte Merge Requests für die Migration auf Java 17. Jede Änderung ist nachvollziehbar, was den Teams Vertrauen gibt und die Sicherheit und Leistung der Anwendung verbessert.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050145?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"QCT\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### 3. Beschleunigen von Code Reviews ohne Qualitätseinbußen \n\nCode Reviews führen oft zu Engpässen: Teams warten tagelang auf Feedback, müssen aber konsistente Standards einhalten. Mit dem Schnellzugriff `/q review` bekommst du sofort intelligentes Feedback zur Codequalität und -sicherheit direkt in Merge Requests. Durch die automatische Identifizierung potenzieller Probleme und Verbesserungsvorschläge, die auf deinen Standards basieren, können Teams qualitativ hochwertigen Code pflegen und gleichzeitig die Überprüfungszyklen drastisch reduzieren.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050136?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Code Reviews\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### 4. Automatisieren von Tests, um mit Zuversicht zu veröffentlichen\n\nDie manuelle Testerstellung ist zeitaufwändig und führt oft zu einer uneinheitlichen Testabdeckung im Team. Mit dem Schnellzugriff `/q test` kannst du automatisch umfangreiche Unit-Tests generieren, die deine Anwendungslogik verstehen. Der Agent sorgt für eine gründliche Abdeckung kritischer Pfade und Sonderfälle und passt sie an deine bestehenden Testmuster an. Dank dieser Automatisierung können Teams Probleme früher erkennen und konsistente Qualitätsstandards einhalten, was den Entwickler(inne)n wertvolle Zeit spart.\n\n\u003Cdiv style=\"padding:54.37% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1034050181?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Use GitLab Duo with Amazon Q to add tests\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## Inklusive Sicherheit und Leitlinien auf Enterprise-Niveau\n\nDieses Angebot wurde für den Einsatz in Unternehmen entwickelt und kombiniert die integrierten Sicherheits-, Compliance- und Datenschutzfunktionen von GitLab mit dem KI-Tool von Amazon Q. Es beschleunigt die Arbeitsabläufe von Entwickler(inne)n und hilft Unternehmen, sichere Software schneller bereitzustellen.\n\nDie Integration bietet:\n\n* Integrierte Leitlinien, die die Entwicklungsgeschwindigkeit aufrechterhalten  \n* Granulare Kontrollen für KI-basierte Funktionen auf Benutzer-, Projekt- und Gruppenebene  \n* End-to-End-Sicherheitsintegration in bestehende Workflows\n\nDevSecOps-Teams können die Entwicklungsumgebung mit der weltweit am weitesten verbreiteten Cloud sicher skalieren.\n\n## Ausblick\n\nGitLab Duo mit Amazon Q baut auf unserer bestehenden Integration mit [AWS, angekündigt im Mai 2024 (nur in englischer Sprache)](https://press.aboutamazon.com/2024/4/aws-announces-general-availability-of-amazon-q-the-most-capable-generative-ai-powered-assistant-for-accelerating-software-development-and-leveraging-companies-internal-data) auf und stellt einen bedeutenden Schritt vorwärts in unserer gemeinsamen Mission dar, die Softwareentwicklung zu verändern. Diese weiterführende Integration von KI-Funktionen markiert den Beginn unserer erweiterten Zusammenarbeit mit AWS. Bei der Weiterentwicklung dieser Fähigkeiten werden wir uns auf Folgendes konzentrieren:\n\n* Ausweitung der KI-Funktionen auf den gesamten Entwicklungslebenszyklus  \n* Steigerung der Entwicklerproduktivität  \n* Erfüllung der Entwicklungsanforderungen von Unternehmen im großen Maßstab\n\n**GitLab Duo mit Amazon Q ist ab heute im [öffentlichen Branch (nur in englischer Sprache)](https://gitlab.com/groups/gitlab-org/-/epics/16059) des GitLab.org-Projekts verfügbar. Eine Vorschau und weitere Informationen darüber, wie es deinen Softwareentwicklungsprozess verändern kann, findest du auf [unserer Website](https://about.gitlab.com/partners/technology-partners/aws/#interest).**",[684,732,683,686,236],{"slug":897,"featured":93,"template":692},"gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai","content:de-de:blog:gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai.yml","Gitlab Duo With Amazon Q Devsecops Meets Agentic Ai","de-de/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai.yml","de-de/blog/gitlab-duo-with-amazon-q-devsecops-meets-agentic-ai",{"_path":903,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":904,"content":910,"config":916,"_id":918,"_type":16,"title":919,"_source":18,"_file":920,"_stem":921,"_extension":21},"/de-de/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai",{"title":905,"description":906,"ogTitle":905,"ogDescription":906,"noIndex":6,"ogImage":907,"ogUrl":908,"ogSiteName":674,"ogType":675,"canonicalUrls":908,"schema":909},"Beschädigte CI/CD-Pipelines schnell entfernen – mit KI","Wenn deine CI/CD-Pipeline fehlschlägt, führt dies zu Verzögerungen, verminderter Produktivität und Stress. Mit der KI-basierten Root Cause Analysis kannst du Probleme nun rascher und intelligenter lösen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097355/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2811%29_78Dav6FR9EGjhebHWuBVan_1750097355230.png","https://about.gitlab.com/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Beschädigte CI/CD-Pipelines schnell entfernen – mit KI\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Itzik Gan Baruch\"}],\n        \"datePublished\": \"2024-12-03\",\n      }",{"title":905,"description":906,"authors":911,"heroImage":907,"date":893,"body":913,"category":14,"tags":914,"updatedDate":915},[912],"Itzik Gan Baruch","CI/CD-Pipelines sorgen dafür, dass die Softwareentwicklung effizient abläuft. Sie helfen Teams, Code schnell zu testen, zu erstellen und bereitzustellen. Wenn diese Pipelines jedoch fehlschlagen, verlangsamt sich alles – Fristen werden verpasst und die Entwickler(innen) sind frustriert, da sie die Fehler beheben und dafür sorgen müssen, dass die Projekte trotzdem im Zeitrahmen bleiben.\n\n![CI/CD-Pipeline mit mehreren fehlgeschlagenen Jobs](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097362/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097362772.png)\n\n\u003Ccenter>\u003Ci>CI/CD-Pipeline mit mehreren fehlgeschlagenen Jobs\u003C/i>\u003C/center>\u003Cbr>\u003C/br>\n\n**Warum schlagen Pipelines fehl?** Sehen wir uns das genauer an.\n\n## Gründe für Pipeline-Fehler\n\nEin Pipeline-Fehler tritt auf, wenn der automatisierte Workflow in deiner [CI/CD-Pipeline](https://about.gitlab.com/de-de/topics/ci-cd/cicd-pipeline/) – also in einer Reihe von Schritten, wie Erstellen, Testen und Bereitstellen von Code – nicht wie erwartet ausgeführt wird und mit einer Fehlermeldung endet. Dieser Fehler kann verhindern, dass der Code ordnungsgemäß erstellt, getestet oder bereitgestellt wird, was zu Verzögerungen bei der Softwarebereitstellung führen kann. Zudem ist eine Fehlerbehebung nötig.\n\nPipeline-Fehler können aus einer Vielzahl von Gründen auftreten. Einige häufige Ursachen sind:\n- Syntax-Fehler: Ein kleiner Fehler im Code, wie ein fehlendes Semikolon oder ein falscher Variablenname, kann dazu führen, dass die Pipeline fehlschlägt.\n- Fehlgeschlagene Tests: Unit- oder Integrationstests können aufgrund von fehlerhaftem Code, falschen Konfigurationen oder nicht übereinstimmenden Abhängigkeiten fehlschlagen.\n- Fehlkonfigurationen: Falsche Pipeline-Einstellungen oder Umgebungskonfigurationen können zu fehlgeschlagenen Builds oder Bereitstellungen führen.\n\nEs gibt auch komplexere Probleme, die das Ganze etwas komplizierter machen:\n- Probleme mit Infrastructure-as-Code [IaC](https://about.gitlab.com/de-de/topics/gitops/infrastructure-as-code/): Probleme bei der Bereitstellung der Cloud-Infrastruktur, wie Fehler in Terraform-Skripten oder CloudFormation-Vorlagen, können eine erfolgreiche Bereitstellung verhindern.\n- Kubernetes- und GitOps-Herausforderungen: Fehlkonfigurationen in [Kubernetes-Clustern (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/kubernetes-the-container-orchestration-solution/) oder Probleme mit [GitOps-Workflows](https://about.gitlab.com/de-de/topics/gitops/) (z. B. das Synchronisieren von Kubernetes-Status mit Git-Repositories) können zu Pipeline-Fehlern führen, die nur schwer zu diagnostizieren sind.\n- Lange, unübersichtliche Stack Traces: Wenn ein Fehler tief im System auftritt, können Stack Traces lang werden und somit schwer zu entziffern sein, insbesondere wenn sie mehrere Komponenten oder Dienste umfassen.\n\nDurch diese Herausforderungen wird die Fehlerbehebung schwieriger und zeitaufwändiger, da man sich oft durch komplexe Protokolle arbeiten, Konfigurationsdateien überprüfen und verschiedene Lösungen testen muss, um die Grundursache zu finden.\n\n## Die tatsächlichen Auswirkungen fehlgeschlagener Pipelines\n\nWenn eine Pipeline fehlschlägt, verzögert dies nicht nur die Bereitstellung, sondern sorgt auch für Stress und Frustration. Die Entwickler(innen) müssen ihre Arbeit unterbrechen und den Fehler beheben, was oft zu einer Kettenreaktion an Störungen führen kann. Dies macht es schwieriger, Fristen einzuhalten, und erhöht den Druck auf das gesamte Team. Aber warum ist die manuelle Fehlerbehebung so aufwendig?\n\n### Manuelle Fehlerbehebung \n\nDie Zeit, die benötigt wird, um eine defekte Pipeline zu beheben, variiert. Das hängt unter anderem von folgenden Faktoren ab:\n- Wie gut kennen die Entwickler(innen) das Projekt?\n- Wie erfahren sind sie mit ähnlichen Problemen?\n- Was sind ihre allgemeinen Problemlösungsfähigkeiten?\n\nDas manuelle Durchsuchen von Protokollen, um herauszufinden, was schief gelaufen ist, ist schwierig und mühsam. Protokolle können von überall herkommen, unter anderem von Anwendungsfehlern und Systemnachrichten, und sind oft unübersichtlich und schwierig zu interpretieren. Darüber hinaus müssen die Entwickler(innen) bei der Korrektur von Pipelines oft zwischen verschiedenen Aufgaben hin und her wechseln, wodurch der ganze Vorgang zeitaufwändiger wird.\n\nHier kommt [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) ins Spiel. GitLab Duo kann diesen unübersichtlichen Berg an Daten durchsuchen und Fehler viel schneller finden. So wird der Prozess vereinfacht, sodass du kein besonderen Kenntnisse brauchst, um herauszufinden, was falsch gelaufen ist. Mit KI kannst du deine Pipelines schneller, einfacher und mit weniger Stress reparieren.\n\n\u003Cimg src=\"//images.ctfassets.net/r9o86ar0p03f/1xqlcaw03wyfGf2BcdxsXq/ca7756369094e21e1eef35082368f2fb/image1.png\" alt=\"broken pipeline\">\n\n\u003Cimg src=\"//images.ctfassets.net/r9o86ar0p03f/4N4etB22oizwJwuwzrKejb/e0d9442d2bb646c70a512f7ade703bbd/image4.png\" alt=\"fix suggestions for broken pipelines\">\n\n## GitLab Duo Root Cause Analysis mit generativer KI\n\nWenn deine CI/CD-Pipeline fehlschlägt, musst du Fehler nicht mehr stundenlang manuell beheben. Dafür gibt es die [GitLab Duo Root Cause Analysis (RCA) (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/gitlab_duo/#root-cause-analysis). Dieses KI-gestützte Tool identifiziert schnell die genaue Ursache des Fehlers und schlägt Korrekturen vor – direkt in der DevSecOps-Plattform. Egal, wie lang oder kompliziert deine Stack Traces sind: Die RCA analysiert alle Daten, schlüsselt sie auf und gibt dir klare, umsetzbare Einblicke.\n\n**Sie sagt dir genau, was den Fehler verursacht hat, schlägt Schritte zur Behebung hervor und nennt dir sogar die Dateien und Codezeilen, die bearbeitet werden müssen.** Damit das Ganze noch einfacher wird, schlägt sie Code-Korrekturen vor, damit alles wieder einwandfrei läuft. Dadurch wird die Fehlerbehebung viel schneller und unkomplizierter.\n\n\u003Cimg src=\"//images.ctfassets.net/r9o86ar0p03f/3nGxUgeCHDHA2fpbYlbo7q/985fd1837c1c7ca32113b58109acd436/image5.png\" alt=\"root cause of failure\">\n\n\u003Cimg src=\"//images.ctfassets.net/r9o86ar0p03f/2wXq68cMkFXgLPa6h9RlsW/5ae9a5225d464cd474e721aa9711f5ec/image6.png\" alt=\"example fix\">\n\n## Halte das Gespräch mit Folgefragen am Laufen\n\nMit GitLab Duo RCA erhältst du nicht nur Antworten, sondern kannst auch Folgefragen stellen, um tiefer in das Problem einzutauchen. Möchtest du alternative Lösungen erkunden? Kein Problem. Du kannst [mehr Kontext (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/gitlab_duo_chat/index.html#the-context-chat-is-aware-of) hinzufügen, indem du andere Dateien, Tickets oder Epics in deinem Repo verlinkst. Du könntest zum Beispiel deine Datei `.gitlab-ci.yml` in der IDE öffnen und den Chat fragen: „Based on this file, and the analyzed CI/CD pipeline, how would you propose to optimize the pipeline?“ \n\n## Datenschutz steht an erster Stelle – alles bleibt in GitLab\nEiner der wichtigsten Vorteile der GitLab Duo RCA ist, dass sie in GitLab sofort einsatzbereit ist. Du musst nicht das Tool wechseln oder nach externer Hilfe suchen. Außerdem bleiben deine [Protokolle und sensiblen Daten geschützt](https://about.gitlab.com/de-de/privacy/), denn du musst sie nicht an externe KI-Lösungen senden. RCA ist nahtlos in GitLab integriert und bietet wertvolle Einblicke, ohne gegen den Datenschutz zu verstoßen.\n\n![Beschädigte Pipeline – Bild 6](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097363/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097362773.png)\n\n## Starte noch heute\n\nMöchtest du sehen, wie KI deinen Entwicklungsprozess beschleunigen und ihn reibungsloser und schneller machen kann? Sieh dir unten unsere Produkt-Tour für GitLab Duo Enterprise an und entdecke, wie GitLab Duo mit seinen KI-basierten Informationen jede Phase deines Entwicklungsprozesses transformieren kann – von der Planung und der Programmierung bis hin zur Fehlerbehebung und Bereitstellung. Klicke auf das Bild unten, um die englischsprachige Tour zu starten!\n\n[![Tour durch GitLab Duo Enterprise](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097363/Blog/Content%20Images/Blog/Content%20Images/Screenshot_2024-12-02_at_12.41.10_PM_aHR0cHM6_1750097362774.png)](https://gitlab.navattic.com/duo-enterprise)\n\n> [Starte jetzt eine kostenlose 60-tägige Testversion von GitLab Duo!](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/)",[683,686,688,685],"2025-02-18",{"slug":917,"featured":6,"template":692},"quickly-resolve-broken-ci-cd-pipelines-with-ai","content:de-de:blog:quickly-resolve-broken-ci-cd-pipelines-with-ai.yml","Quickly Resolve Broken Ci Cd Pipelines With Ai","de-de/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai.yml","de-de/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai",{"_path":923,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":924,"content":930,"config":935,"_id":937,"_type":16,"title":938,"_source":18,"_file":939,"_stem":940,"_extension":21},"/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests",{"title":925,"description":926,"ogTitle":925,"ogDescription":926,"noIndex":6,"ogImage":927,"ogUrl":928,"ogSiteName":674,"ogType":675,"canonicalUrls":928,"schema":929},"Automatisierung mit GitLab Duo, Teil 1: Generierung von Tests","Hier erfährst du, wie wir die KI-gestützte DevSecOps-Plattform genutzt haben, um automatisierte Tests zu erstellen und unsere Entwicklungsgeschwindigkeit und -qualität zu verbessern.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097480/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750097480784.png","https://about.gitlab.com/blog/automating-with-gitlab-duo-part-1-generating-tests","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Automatisierung mit GitLab Duo, Teil 1: Generierung von Tests\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Byron Boots\"}],\n        \"datePublished\": \"2024-12-02\",\n      }\n                  ",{"title":925,"description":926,"authors":931,"heroImage":927,"date":932,"body":933,"category":14,"tags":934,"updatedDate":877},[853],"2024-12-02","Automatisierte Tests sind zeitaufwändig und können das Gefühl vermitteln, ein Projekt nicht voranzubringen. Doch wie viele Entwickler(innen) wahrscheinlich schon erlebt haben, machen sich automatisierte Tests insgesamt positiv bemerkbar. Für die Entwicklung eines benutzerdefinierten Moduls (in diesem Artikel nennen wir es gitlab-helper) traf dies besonders zu.\n\nZu Beginn der Entwicklung konzentrierten wir uns darauf, bewährte Funktionen aus bestehenden Skripts in ein neues Modul zu migrieren, dessen einziger Zweck es war, als Grundlage für zukünftige Funktionen zu dienen. Obwohl die bestehenden Skripts nicht automatisiert getestet wurden, war ihre konsequente Nutzung ein deutlicher Beweis dafür, dass die Funktionen wie erwartet funktionierten.\n\nUnser Ziel war es, eine ausgereiftere Lösung für dieses Problem zu entwickeln, sodass automatisierte Tests unumgänglich wurden. Das stellte uns vor die Herausforderung, die Entwicklung effizient zu gestalten und gleichzeitig die Zeit für das Testen und die Sicherstellung eines robusten Produkts unter einen Hut zu bringen; mit insgesamt nur drei Teammitgliedern war das gar nicht mal so einfach. Deshalb entschied sich das Team, für die Testerstellung die Vorteile unserer KI-Suite [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) zu nutzen und so die Entwicklungsgeschwindigkeit und Qualität des fertigen Produkts zu verbessern.\n\nIn dieser dreiteiligen Serie zur Automatisierung mit GitLab Duo behandeln wir die folgenden Punkte:\n\n1. Wie wir GitLab Duo verwendet haben, um Tests für unseren Code zu erstellen  \n2. Wie wir bei komplexeren Situationen interaktiv mit GitLab Duo gearbeitet haben  \n3. Die Ergebnisse, die wir erzielen konnten (Spoiler: 1 Person + GitLab Duo = 84 % Testabdeckung in 2 Tagen)\n\n## GitLab Duo zur Erstellung von Tests für Code verwenden\n\nDieser Artikel behandelt die Verwendung von GitLab Duo in VS Code mit der [GitLab Workflow Extension for VS Code](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) (nur in englischer Sprache verfügbar), um Tests zu generieren. Diese Funktionalität ist in mehreren Tools verfügbar. Links zu anderen GitLab-Duo-Optionen findest du in den [Referenzen](#Referenzen) weiter unten.\n\n### GitLab Duo installieren und aktivieren\n\nUm GitLab Duo nutzen zu können, benötigen wir ein Konto, auf dem GitLab Duo aktiviert ist. Wenn du GitLab Duo noch nicht aktiviert hast, kannst du dich für eine [kostenlose 60-tägige Testversion anmelden](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/?type=free-trial).Um GitLab Duo Chat in VS Code zu verwenden, folgten wir den [Anweisungen zur Installation](https://docs.gitlab.com/ee/user/gitlab_duo_chat/#use-gitlab-duo-chat-in-vs-code) (nur in englischer Sprache verfügbar). Dann war die GitLab-Duo-Chat-Erweiterung in der Seitenleiste verfügbar und wir konnten das Chat-Fenster öffnen.\n\n![Stelle-eine-Frage-Fenster](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097489/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097488918.png)\n\n### Tests mit Chat generieren\n\ngitlab-helper ist ein benutzerdefiniertes Modul, das für die Standardisierung der Interaktion mit der GitLab-API innerhalb des Teams entwickelt wurde und andere Bibliotheksfunktionen erweitert, um die Entwicklungs- und Skriptarbeit zu vereinfachen. Sobald eine Methode oder Funktion in gitlab-helper migriert wurde und angemessen implementiert zu sein schien, konnten ganz einfach Tests dafür erstellt werden:\n- Wir wählten die Methode, die Klasse oder die gesamte Datei in der IDE aus.\n- Wir öffneten das Menü für den ausgewählten Code mit der rechten Maustaste.\n- Unter **GitLab Duo Chat** wählten wir **Tests generieren** aus.\n\n![Reihenfolge für die Erstellung von Tests, einschließlich der Auswahl-Liste für die Erstellung von Tests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097489/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097488919.png)\n\nInnerhalb weniger Sekunden waren die Tests erstellt und im GitLab-Duo-Chat-Fenster angezeigt. Diese Tests können überprüft und/oder durch Kopieren/Einfügen in bestehende oder neue Testdateien zur Codebase hinzugefügt werden. Wie bei den meisten Ergebnissen von linguistischer Datenverarbeitung, vor allem wenn es um den Kontext geht, schlugen einige der ersten von GitLab Duo erstellten Tests fehl, so dass eine Feinabstimmung erforderlich war (z. B. beim Umgang mit verschachtelten Abhängigkeiten).\n\n> **Profi-Tipp:** GitLab Duo erstellt nicht automatisch Dateien, in die generierte Tests eingefügt werden können. Wir haben festgestellt, dass es hilfreich ist, neue Testdateien zu erstellen und sie mit dem Kommentar `# Tests Generated by Duo` zu versehen und ihnen den Zusatz `_duo.py` hinzuzufügen, um anzugeben, woher die Tests stammen.\n\nGitLab Duo war ein großartiger Ausgangspunkt für die Entwicklung der automatisierten Tests von gitlab-helper und hat die Effizienz beim Schreiben von Tests und die Testabdeckung erheblich verbessert, was den Entwicklungsprozess erheblich beschleunigt hat. Neben GitLab Duo wurden zahlreiche sinnvolle Tests unter menschlicher Aufsicht in das gitlab-helper-Modul integriert.\n\nIm nächsten Teil dieser Serie erfährst du, [was wir bei der Verwendung von GitLab Duo für die Erstellung automatisierter Tests und die interaktive Arbeit mit KI für komplexere Situationen gelernt haben](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing/).\n\n## Referenzen\n\nEs gibt mehr als eine Möglichkeit, GitLab Duo zu verwenden, um Tests zu generieren. Sieh dir die anderen Optionen unten an:\n\n* Die GitLab-Benutzeroberfläche  \n* [Die GitLab-Web-IDE (VS Code in der Cloud)](https://docs.gitlab.com/ee/user/project/web_ide/index.html) (nur in englischer Sprache verfügbar) \n* VS Code, mit der [GitLab Workflow Extension for VS Code](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) (nur in englischer Sprache verfügbar)\n* JetBrains IDEs, mit dem [GitLab-Duo-Plugin für JetBrains](https://plugins.jetbrains.com/plugin/22325-gitlab-duo)  (nur in englischer Sprache verfügbar) \n* Visual Studio für Windows mit der [GitLab-Erweiterung für Visual Studio](https://marketplace.visualstudio.com/items?itemName=GitLab.GitLabExtensionForVisualStudio) (nur in englischer Sprache verfügbar)\n",[683,688,857,686,685],{"slug":936,"featured":6,"template":692},"automating-with-gitlab-duo-part-1-generating-tests","content:de-de:blog:automating-with-gitlab-duo-part-1-generating-tests.yml","Automating With Gitlab Duo Part 1 Generating Tests","de-de/blog/automating-with-gitlab-duo-part-1-generating-tests.yml","de-de/blog/automating-with-gitlab-duo-part-1-generating-tests",{"_path":942,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":943,"content":949,"config":956,"_id":958,"_type":16,"title":959,"_source":18,"_file":960,"_stem":961,"_extension":21},"/de-de/blog/gitlab-duo-enterprise-is-now-available",{"title":944,"description":945,"ogTitle":944,"ogDescription":945,"noIndex":6,"ogImage":946,"ogUrl":947,"ogSiteName":674,"ogType":675,"canonicalUrls":947,"schema":948},"GitLab Duo Enterprise ist jetzt verfügbar","Mit Gitlab Duo Enterprise haben Unternehmen jetzt einen durchgängigen KI-Partner für schnellere, sicherere Softwareentwicklung! Erfahre, wie GitLab Duo Enterprise den gesamten DevSecOps-Lebenszyklus unterstützt.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665660/Blog/Hero%20Images/Untitled__1800_x_945_px_.png","https://about.gitlab.com/blog/gitlab-duo-enterprise-is-now-available","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Enterprise ist jetzt verfügbar\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David DeSanto, Chief Product Officer, GitLab\"}],\n        \"datePublished\": \"2024-09-03\",\n      }\n                  ",{"title":944,"description":945,"authors":950,"heroImage":946,"date":952,"body":953,"category":14,"tags":954,"updatedDate":955},[951],"David DeSanto, Chief Product Officer, GitLab","2024-09-03","[GitLab Duo Enterprise](https://about.gitlab.com/de-de/gitlab-duo/) ist der durchgängige KI-Partner, der für den gesamten Software-Entwicklungsprozess konzipiert wurde. Die leistungsstarke Suite aus KI-Tools steigert die Produktivität der Entwickler(innen), verbessert die Sicherheit, optimiert die Zusammenarbeit und beschleunigt deine DevSecOps-Prozesse.\n\nDie wichtigsten Funktionen auf einen Blick:\n- Intelligente Codeunterstützung in über 25 Programmiersprachen\n- KI-basierte Details und Lösungen zu Sicherheitslücken\n- Automatisierte Testgenerierung und Ursachenanalyse\n- Verbesserte Teamzusammenarbeit mit KI-gesteuerten Zusammenfassungen\n- ROI-Quantifizierung durch ein KI-Impact-Dashboard\n\n## Warum wir GitLab Duo Enterprise entwickelt haben \n\nUnternehmen, die versuchen, bessere Software schneller bereitzustellen und so einen höheren Nutzen für Kund(inn)en zu schaffen, stehen meist vor erheblichen Herausforderungen, die ihren Fortschritt verlangsamen. [Unsere Forschung](http://about.gitlab.com/de-de/developer-survey/2024/ai) zeigt, dass 95 % der Unternehmen KI gerade entweder evaluieren oder bereits im Lebenszyklus der Softwareentwicklung einsetzen. 55 % der Befragten gaben jedoch an, dass sie den Einsatz von KI für die Softwareentwicklung für zu riskant halten.\n\nDie Skepsis der Unternehmen basiert auf suboptimalen Erfahrungen in Zusammenhang mit der Produktivität der Entwickler(innen), steigenden Sicherheits- und Compliance-Anforderungen, ineffizienter Zusammenarbeit zwischen Teams und Schwierigkeiten bei der Bewertung des ROI von KI-Technologieinvestitionen. GitLab Duo Enterprise geht direkt auf diese Herausforderungen ein und ist ein sicherer, effizienter und leistungsstarker KI-Partner für deine Entwicklungsteams.\n\n**Sehen wir uns an, wie GitLab Duo Enterprise die Art und Weise verändern kann, wie dein Unternehmen Software entwickelt und bereitstellt.**\n\n## Steigere die Produktivität deiner Entwickler(innen) mit intelligenter Codeunterstützung\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252678?h=83f35171b6&badge=0&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Code Suggestions clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nEine der Haupthürden in der Softwareentwicklung sind routinemäßige Programmieraufgaben, die sehr zeitaufwendig sind. Hier schafft Gitlab Duo Enterprise Abhilfe – denn mit den folgenden Tools erledigst du die wichtigsten Aufgaben jetzt deutlich schneller:\n\n- __Codevorschläge__ in mehr als 25 Programmiersprachen. Dieses KI-basierte Tool beschleunigt die Codeerstellung, verbessert die Codequalität und reduziert den Zeitaufwand für Boilerplate-Aufgaben.\n\nAber es geht nicht nur darum, neuen Code zu schreiben. \n\n- Die __Code-Erklärung__ von GitLab Duo Enterprise ermöglicht es Entwickler(inne)n, komplexen oder unbekannten Code schnell zu verstehen, während \n\n- __Code-Refactoring__ es Entwickler(inne)n ermöglicht, [bestehenden Code zu verbessern und zu modernisieren](https://about.gitlab.com/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo/). \n\n- __Testgenerierung__ automatisiert die Erstellung umfassender Unit-Tests. Das Ergebnis? Entwickler(innen) können sich auf hochwertige Aufgaben konzentrieren, die Innovationen vorantreiben und zu schnelleren Entwicklungszyklen und verbesserter Softwarequalität führen.\n\n> Erfahre, wie [das europäische Technologieunternehmen Cube](https://about.gitlab.com/de-de/customers/cube/) Codevorschläge, Testgenerierung und andere Funktionen von GitLab Duo einsetzt, um Geschwindigkeit und Effizienz zu verbessern. \n\n## Verbessere die Zusammenarbeit und Kommunikation im Team\n\nEine effektive Zusammenarbeit ist ausschlaggebend für eine erfolgreiche Softwareentwicklung. Allerdings stehen dem Erfolg im Team oft langwierige Diskussionen, komplexe Merge Requests und zeitaufwändige Code Reviews im Weg. GitLab Duo Enterprise geht mit seinen Zusammenfassungs- und Vorlagen-Tools auf diese Herausforderungen ein:\n- __Zusammenfassung von Diskussionen:__ Ermöglicht es Teammitgliedern, einen schnellen Überblick über die wichtigsten Punkte umfangreicher Konversationen in Tickets zu erhalten.\n- __Merge-Request-Zusammenfassungen:__ Verschafft allen Beteiligten einen klaren, prägnanten Überblick über die vorgeschlagenen Änderungen.\n- __Zusammenfassungen der Code Reviews:__ Optimiert den Review-Prozess, um bessere Übergaben zwischen Autor(inn)en und Prüfer(inne)n zu ermöglichen.\n\nDurch eine klarere Kommunikation und schnellere Entscheidungsfindung hilft GitLab Duo Enterprise Teams, effizienter zu arbeiten und schneller Ergebnisse zu liefern.\n\n## Optimiere die Problembehandlung und Fehlersuche\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252688?h=fc6c048bfd&badge=0&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Root Cause Analysis clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nWenn Entwicklungspipelines fehlschlagen, können die Auswirkungen auf die Projektzeitpläne erheblich sein. Die Grundursachenanalyse von GitLab Duo Enterprise schafft hier entscheidende Abhilfe. Durch die automatische Analyse von Protokollen und detaillierte Erklärungen zu den Ausfällen sowie vorgeschlagenen potenziellen Fixes reduziert die Grundursachenanalyse die Zeit, die für die Problembehandlung aufgewendet wird, deutlich.\n\nDie Vorteile gehen über die reine Zeitersparnis hinaus. Mit [schnelleren Lösungen für CI/CD-Build-Probleme](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/) können Teams die Dynamik aufrechterhalten, Ausfallzeiten reduzieren und letztendlich Softwareupdates häufiger und zuverlässiger bereitstellen.\n\n## Erhöhe die Sicherheit über den gesamten Entwicklungslebenszyklus\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252706?h=73e568b89c&badge=0&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Vulnerability Explanation and Resolution clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nCybersicherheitsbedrohungen sind allgegenwärtig, daher ist robuste Anwendungssicherheit unerlässlich. GitLab Duo Enterprise reagiert auf diese Herausforderung mit den Funktionen __Erläuterung von Sicherheitslücken__ und __Behebung von Sicherheitslücken__. Diese KI-basierten Tools helfen [Entwickler(inne)n, Sicherheitslücken vollständig zu verstehen](https://about.gitlab.com/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities/), und generieren dann automatisch Merge Requests mit vorgeschlagenen Fixes.\n\n## Quantifiziere die KI-Auswirkungen für die strategische Entscheidungsfindung\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252663?h=d35106288b&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"AI Impact Dashboard clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nEs ist entscheidend, den ROI von Technologieinvestitionen zu demonstrieren. In GitLab Duo Enterprise ist dies direkt mit dem __KI-Impact-Dashboard__ möglich. Dieses Analysetool, das auf der Wertstromanalyse und DORA4-Metriken aufbaut, bietet übersichtliche Kennzahlen zu Verbesserungen der Bearbeitungszeit und einer höheren Häufigkeit der Bereitstellung. Dadurch können Unternehmen die greifbaren Vorteile der KI-Einführung in ihren Entwicklungsprozessen quantifizieren.\n\nDurch Einblicke in die Korrelation der KI-Nutzung mit wichtigen Produktivitätsmetriken ermöglicht das [KI-Impact-Dashboard](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/) Führungskräften, datengesteuerte Entscheidungen über die Ressourcenzuweisung und strategische Technologieinvestitionen zu treffen.\n\n## Erlebe die Zukunft KI-gesteuerter DevSecOps\n\nNeben der Vorstellung von GitLab Duo Enterprise möchten wir auch darauf hinweisen, dass GitLab als Leader im ersten [Gartner® Magic Quadrant™ für KI-Programmierassistenten](https://about.gitlab.com/de-de/gartner-mq-ai-code-assistants/) ausgezeichnet wurde – und das freut uns wirklich sehr. Diese Auszeichnung unterstreicht, wie intensiv wir an KI-Lösungen arbeiten, die einen echten kommerziellen Mehrwert bieten.\n\nDie Zukunft der Softwareentwicklung ist da und wird von KI angetrieben. Wir helfen dir dabei, intelligente, skalierbare KI über den gesamten DevSecOps-Lebenszyklus hinweg zu integrieren, damit du deinen Kund(inn)en schneller Ergebnisse liefern kannst.\n\n> [Lege jetzt mit GitLab Duo Enterprise los und teste es 60 Tage lang kostenlos!](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/?type=free-trial&toggle=gitlab-duo-pro)\n",[683,687,686,685,684],"2024-09-23",{"slug":957,"featured":93,"template":692},"gitlab-duo-enterprise-is-now-available","content:de-de:blog:gitlab-duo-enterprise-is-now-available.yml","Gitlab Duo Enterprise Is Now Available","de-de/blog/gitlab-duo-enterprise-is-now-available.yml","de-de/blog/gitlab-duo-enterprise-is-now-available",{"_path":963,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":964,"content":970,"config":978,"_id":980,"_type":16,"title":981,"_source":18,"_file":982,"_stem":983,"_extension":21},"/de-de/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo",{"title":965,"description":966,"ogTitle":965,"ogDescription":966,"noIndex":6,"ogImage":967,"ogUrl":968,"ogSiteName":674,"ogType":675,"canonicalUrls":968,"schema":969},"Code mit KI-gestütztem GitLab Duo in moderne Sprachen refaktorisieren ","In diesem detaillierten Tutorial erfahren Entwickler(innen), wie sie Code mithilfe von KI modernisieren können, indem sie zu einer neuen Programmiersprache wechseln und mehr über neue Funktionen in dieser Sprache lernen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662465/Blog/Hero%20Images/GitLab_Duo_Workflow_Unified_Data_Store__1_.png","https://about.gitlab.com/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Code mit KI-gestütztem GitLab Duo in moderne Sprachen refaktorisieren \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"}],\n        \"datePublished\": \"2024-08-26\",\n      }\n                  ",{"title":965,"description":966,"authors":971,"heroImage":967,"date":973,"body":974,"category":14,"tags":975,"updatedDate":977},[972],"Michael Friedrich","2024-08-26","Egal, ob es deine Aufgabe ist, die Codebase oder das Framework zu modernisieren, indem du zu einer neuen Programmiersprache wechselst, oder ob du mehr über neue Funktionen in dieser Sprache erfahren möchtest: das KI-gestützte [GitLab Duo](https://about.gitlab.com/gitlab-duo/) kann dir dabei helfen. Hier erfährst du anhand von Beispielen aus meiner 20-jährigen Berufserfahrung als Programmier(in), wie du Herausforderungen beim Code-Refactoring am besten meisterst.\n\nDie Prompts und Beispiele in diesem Artikel werden in verschiedenen IDEs gezeigt: VS Code und JetBrains (IntelliJ IDEA, PyCharm und CLion) mit den jeweiligen installierten (GitLab-Duo-Erweiterungen/Plugins]https://docs.gitlab.com/ee/user/project/repository/code_suggestions/supported_extensions.html). Die Entwicklungsumgebung nutzt GitLab.com, darunter Updates auf Anthropic Claude 3.5 als großes Sprachmodell (LLM) für [Codevorschläge](https://docs.gitlab.com/ee/user/gitlab_duo/#code-suggestions) und den [Chat](https://docs.gitlab.com/ee/user/gitlab_duo/#gitlab-duo-chat) von GitLab Duo. Spoiler: Sie sind noch leistungsstärker und effizienter.\n\nDu kannst zu den einzelnen Abschnitten dieses Artikels springen oder ihn von Anfang bis Ende lesen. Der Quellcode und die Herausforderungen mit den jeweiligen Übungen sind zum Selbststudium geeignet.\n\n- [Code in moderne Programmiersprachen-Standards refaktorieren](#refactor-code-to-modern-programming-language-standards)\n    - [Java 7 generieren und zu Java 8 refaktorisieren](#generate-java-7-and-refactor-to-java-8)\n    - [Über C++-Standards refaktorisieren](#refactor-across-c%2B%2B-standards)\n        - [Migration: C++03 zu C++14 refaktorisieren](#migration-refactor-c%2B%2B03-into-c%2B%2B14)\n        - [Downgrade: C++23 zu C++11 refaktorisieren](#downgrade-refactor-c%2B%2B23-to-c%2B%2B11)\n    - [COBOL erklären und refaktorisieren](#explain-and-refactor-cobol)\n- [Eine Sprache in eine andere refaktorisieren](#refactor-a-language-into-another-language)\n    - [C zu Rust refaktorisieren](#refactor-c-to-rust)\n    - [Perl zu Python refaktorisieren](#refactor-perl-to-python)\n- [Weitere Tipps zum Refaktorisieren](#more-refactoring-hands-on)\n    - [JavaScript refaktorisieren](#refactor-javascript)\n    - [Bash zu ZSH oder SH refaktorisieren](#refactor-bash-to-zsh-or-sh)\n    - [Weitere Anwendungsfälle und Tutorials](#more-use-cases-and-tutorials)\n- [Wichtige Erkenntnisse](#key-takeaways)\n\n## Code in moderne Programmiersprachen-Standards refaktorisieren\n\nIm nächsten Abschnitt erfährst du, wie du die sprachspezifischen Unterschiede einer Programmiersprache refaktorisierst, erklärst und verstehst. \n\n### Java 7 generieren und auf Java 8 refaktorisieren \n\nEin Kunde wollte wissen, ob GitLab Duo Java 7 unterstützt. Beim Testen von Codevorschlägen und Chat-Prompts, um spezifischen Code für Java 7 zu erstellen, dachte ich auch über Hilfe bei der Migration nach. Anthropic Claude 3.5 kann die sprachspezifischen Unterschiede verstehen, ebenso wie GitLab Duo.\n\nDas folgende Beispiel zeigt eine Aufforderung zum Generieren von Java-7-Code mit Codevorschlägen.\n\n```java\n// Generate a new class for a File Manager. Use Java 7 features only.\nimport java.io.*;\nimport java.nio.file.*;\nimport java.util.*;\n\npublic class FileManager {\n    private Path rootDirectory;\n\n    public FileManager(String rootPath) throws IOException {\n        this.rootDirectory = Paths.get(rootPath);\n        if (!Files.exists(rootDirectory)) {\n            Files.createDirectories(rootDirectory);\n        }\n    }\n\n    public void createFile(String fileName, String content) throws IOException {\n        Path filePath = rootDirectory.resolve(fileName);\n        Files.write(filePath, content.getBytes(), StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);\n    }\n\n    public String readFile(String fileName) throws IOException {\n        Path filePath = rootDirectory.resolve(fileName);\n        return new String(Files.readAllBytes(filePath));\n    }\n\n    public void deleteFile(String fileName) throws IOException {\n        Path filePath = rootDirectory.resolve(fileName);\n        Files.delete(filePath);\n    }\n\n    public List\u003CString> listFiles() throws IOException {\n        List\u003CString> fileList = new ArrayList\u003C>();\n        try (DirectoryStream\u003CPath> stream = Files.newDirectoryStream(rootDirectory)) {\n            for (Path file : stream) {\n                fileList.add(file.getFileName().toString());\n            }\n        }\n        return fileList;\n    }\n\n    public void copyFile(String sourceFileName, String destinationFileName) throws IOException {\n        Path sourcePath = rootDirectory.resolve(sourceFileName);\n        Path destinationPath = rootDirectory.resolve(destinationFileName);\n        Files.copy(sourcePath, destinationPath, StandardCopyOption.REPLACE_EXISTING);\n    }\n\n    public void moveFile(String sourceFileName, String destinationFileName) throws IOException {\n        Path sourcePath = rootDirectory.resolve(sourceFileName);\n        Path destinationPath = rootDirectory.resolve(destinationFileName);\n        Files.move(sourcePath, destinationPath, StandardCopyOption.REPLACE_EXISTING);\n    }\n\n    public long getFileSize(String fileName) throws IOException {\n        Path filePath = rootDirectory.resolve(fileName);\n        return Files.size(filePath);\n    }\n\n    public boolean fileExists(String fileName) {\n        Path filePath = rootDirectory.resolve(fileName);\n        return Files.exists(filePath);\n    }\n}\n```\n\nDu kannst mit folgenden Schritten in deinem IDE fortfahren:\n\n1. Lerne und verstehe den generierten Code: Wähle den Code im Editor aus (im Screenshot blau), wechsle zum GitLab-Duo-Chat und sende den Slash-Befehl `/explain` als Prompt.\n\n![Validiere den generierten Code mit dem Slash-Befehl `/explain` im GitLab-Duo-Chat](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/intellij_java7_generate_refactor.png)\n\n2. Wandle den Java-7-Code in Java 8 um: Wähle den Code im Editor aus, wechsle zum Chat und sende `/refactor using Java 8 features` als detaillierteren Prompt.\n3. Übe eine Alternative zum Refactoring: Erstelle die neue Datei `java8.java` und generiere Java-8-spezifischen Code mit Codevorschlägen mit dem Prompt `// Generate a new class for a File Manager. Use Java 8 features only.`.\n4. Schreibe weiter Java-8-Code im gleichen Kontext mit KI-basierter Code-Vervollständigung.\n\nDu kannst dir alle Schritte in dieser Aufnahme ansehen.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/XKRv6uBkD2I\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nDer Quellcode ist in der [GitLab-Duo-Challenge – Java 7 generieren und auf Java 8 refaktorisieren](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-generate-refactor-java-7-to-8) verfügbar.\n\n### Über C++-Standards refaktorisieren\n\nDer C++-Standard hat eine lange Geschichte und gilt als stabil und ausgereift. Je nach Zielarchitektur und Plattformen hängt der unterstützte Standard vom Compiler des Host-Betriebssystems ab.\n\nIn meiner Karriere musste ich bereits 25 verschiedene Linux- und Windows-Distributionen in Open-Source-Projekten supporten und habe unterschiedlichsten Compiler-Support für neuere Sprachfunktionen und C++-Standards erlebt. Im Jahr 2015 haben wir uns für C++11-Funktionen entschieden und später C++14 oder C++17 nie mehr angerührt. \n\nDie Refaktorisierung von Funktionen und Algorithmen zu einem neuen C++-Standard wäre zu aufwändig gewesen und es wäre Hilfe beim Erklären der Unterschiede nötig gewesen. Damals haben wir in Büchern, über Online-Suche, Stack Overflow und manchmal Tools Hilfe zum Refactoring gesucht.Mit KI-basierten Assistenten und GitLab Duo hat sich das alles geändert: Du kannst Codevorschläge und den Chat nutzen, um Quellcode in einem bestimmten C++-Standard bereitzustellen. Dann ist es auch möglich, die verschiedenen Ausgaben zu vergleichen. \n\nDas folgende Beispiel verwendet einen Prompt, um speziell Quellcode für den C++03-Standard zu generieren. Es implementiert einen einfachen Konfigurations-Parser für das Konfigurationsformat `.ini`.\n\n```c++\n/* Create a config parser which can parse an ini format\nUse C++03 standard only\n */\n\n#include \u003Ciostream>\n#include \u003Cfstream>\n#include \u003Cstring>\n#include \u003Cmap>\n#include \u003Csstream>\n\nclass ConfigParser {\nprivate:\n    std::map\u003Cstd::string, std::map\u003Cstd::string, std::string> > config;\n\npublic:\n    ConfigParser() {}\n\n    bool parse(const std::string& filename) {\n        std::ifstream file(filename.c_str());\n        if (!file.is_open()) {\n            return false;\n        }\n\n        std::string line;\n        std::string currentSection;\n\n        while (std::getline(file, line)) {\n            // Trim whitespace\n            size_t first = line.find_first_not_of(\" \\t\");\n            size_t last = line.find_last_not_of(\" \\t\");\n            if (first == std::string::npos) continue; // Skip empty lines\n            line = line.substr(first, (last - first + 1));\n\n            if (line[0] == '[' && line[line.length() - 1] == ']') {\n                // This is a section\n                currentSection = line.substr(1, line.length() - 2);\n            } else {\n                // This is a key-value pair\n                size_t delimiterPos = line.find('=');\n                if (delimiterPos != std::string::npos) {\n                    std::string key = line.substr(0, delimiterPos);\n                    std::string value = line.substr(delimiterPos + 1);\n                    config[currentSection][key] = value;\n                }\n            }\n        }\n\n        file.close();\n        return true;\n    }\n\n    std::string getValue(const std::string& section, const std::string& key) const {\n        std::map\u003Cstd::string, std::map\u003Cstd::string, std::string> >::const_iterator sectionIt = config.find(section);\n        if (sectionIt != config.end()) {\n            std::map\u003Cstd::string, std::string>::const_iterator keyIt = sectionIt->second.find(key);\n            if (keyIt != sectionIt->second.end()) {\n                return keyIt->second;\n            }\n        }\n        return \"\";\n    }\n\n    void printConfig() const {\n        std::map\u003Cstd::string, std::map\u003Cstd::string, std::string> >::const_iterator sectionIt;\n        for (sectionIt = config.begin(); sectionIt != config.end(); ++sectionIt) {\n            std::cout \u003C\u003C \"[\" \u003C\u003C sectionIt->first \u003C\u003C \"]\" \u003C\u003C std::endl;\n            std::map\u003Cstd::string, std::string>::const_iterator keyIt;\n            for (keyIt = sectionIt->second.begin(); keyIt != sectionIt->second.end(); ++keyIt) {\n                std::cout \u003C\u003C keyIt->first \u003C\u003C \" = \" \u003C\u003C keyIt->second \u003C\u003C std::endl;\n            }\n            std::cout \u003C\u003C std::endl;\n        }\n    }\n};\n\nint main() {\n    ConfigParser parser;\n    if (parser.parse(\"config.ini\")) {\n        std::cout \u003C\u003C \"Config file parsed successfully.\" \u003C\u003C std::endl;\n        parser.printConfig();\n\n        std::cout \u003C\u003C \"Value of 'key1' in 'section1': \" \u003C\u003C parser.getValue(\"section1\", \"key1\") \u003C\u003C std::endl;\n    } else {\n        std::cout \u003C\u003C \"Failed to parse config file.\" \u003C\u003C std::endl;\n    }\n    return 0;\n}\n```\n\nThe same prompts can be applied to [explaining code](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#explain-code-in-the-ide), [generating tests](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#write-tests-in-the-ide), and even [refactoring code](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#refactor-code-in-the-ide): `/explain focus on C++03 features`, `/tests for C++03 features`, `/refactor into C++03`. \n\nDie folgenden C+ -Standards wurden für die Arbeit mit GitLab Duo Codevorschläge getestet:\n\n- C++03\n- C++11\n- C++14\n- C++17\n- C++20\n- C++23\n\nDen Quellcode findest du in der [Challenge –  Cpp-Standards Konfigurations-Parser refaktorisieren](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-refactor-cpp-standards-config-parser). \n\nEs gibt viele verschiedene Kombinationen, um den Quellcode zwischen den C++-Standards zu refaktorisieren. Die folgenden Beispiele zeigen eine Modernisierung des C++-Codes mit Versionsupgrades, testen aber auch ein Downgrade, als ambitionierte Entwickler(innen) C++20 verwenden wollten, aber C++11 verwenden mussten, um den Umgebungen ihrer Geschäftskund(inn)en zu entsprechen.#### Migration: C++03 in C++14 refaktorisieren \n\nDas Ziel ist es, den Code zu modernisieren und die Veränderungen zwischen C++03 und C++14 zu verstehen. Öffne den [03.cpp](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-refactor-cpp-standards-config-parser/-/blob/main/03.cpp?ref_type=heads)-Quellcode in der IDE, wähle ihn aus und gib den folgenden Chat-Prompt ein: \n\n```markdown\n/refactor into C++14 and explain the changes\n```\n\nPotentielle Antwort des Chats: \n\n```markdown\n…\n\nExplanations of the changes:\n\n1. Default constructor: Changed `ConfigParser() {}` to `ConfigParser() = default;` to use the default constructor.\n2. File opening: Removed `.c_str()` when opening the file, as C++11 and later support `std::string` directly.\n3. Lambda functions: Introduced a lambda function trim to handle string trimming, making the code more readable and reusable.\n4. Auto keyword: Used `auto` for type deduction in various places, improving code readability.\n5. Range-based for loops: In the `printConfig` method, replaced traditional for loops with range-based for loops, which are more concise and less error-prone.\n6. Structured bindings: Used structured bindings in the range-based for loops to directly access key-value pairs.\n7. If statements with initializers: In the `getValue` method, used if statements with initializers to combine the find operation and the check in a single line.\n8. String member functions: Used `front()` and `back()` instead of array-style access for the first and last characters of strings.\n9. Uniform initialization: Used uniform initialization `{}` instead of parentheses `()` for object creation.\n10. Removed `std::endl`: Replaced `std::endl` with `'\\n'` for better performance, as `std::endl` forces a flush of the output buffer.\n\nThese changes make the code more modern, concise, and potentially more efficient while maintaining the same functionality.\n\n```\n\n![Änderungen im Code](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/duo_refactor_cpp_clion_chat_cpp03_to_14_01.png)\n\n![Änderungen im Code 2](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675060/Blog/Content%20Images/duo_refactor_cpp_clion_chat_cpp03_to_14_02.png)\n\n#### Downgrade: C++23 zu C++11 refaktorisieren\n\nManchmal starten Entwickler(innen) einen neuen Proof of Concept in einem modernen C++-Standard wie C++20. Die aktuell unterstützten Versionen für Geschäftskundenumgebungen erfordern ältere Compiler mit C++11-Unterstützung. Ein Downgrade der Versionen ist mit Kosten verbunden und erfordert eine Bewertung, welche Sprachfunktionen noch unterstützt werden und welche anderen Nachteile auftreten könnten.\n\nÖffne den [23.cpp](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-refactor-cpp-standards-config-parser/-/blob/main/23.cpp?ref_type=heads)-Quellcode in der IDE, wähle ihn aus und gib den folgenden Chat-Prompt ein: \n\n```markdown\n/refactor into C++11, explain the necessary changes and potential problems\n```\n\nPotenzielle Antwort des Duo Chat: \n\n```markdown\nThe main changes required to make this code compatible with C++11 are:\n\n1. Remove the C++23 standard comment, as it's no longer applicable.\n2. Replace `std::string::find_first_not_of` and `std::string::find_last_not_of` with C++11 compatible alternatives in the trim function.\n3. Use `const auto&` instead of `auto` for loop variables to avoid unnecessary copying.\n\nPotential problems in the original code:\n\n1. The original code used C++23 features, which might not be widely supported yet.\n2. The `trim` function used `std::string::find_first_not_of` and `std::string::find_last_not_of`, which are not available in C++11.\n3. The use of `auto` instead of `const auto&` in some loops could lead to unnecessary copying of complex objects.\n\nThese issues have been addressed in the refactored version. The `trim` function now uses `std::find_if_not` with lambda functions to achieve the same result in a C++11 compatible way. The use of `const auto&` ensures that no unnecessary copying occurs when iterating over the config map.\n```\n\n![The `trim` function now uses `std::find_if_not` with lambda functions to achieve the same result in a C++11 compatible way](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/duo_refactor_cpp_clion_chat_cpp23_to_11_01.png)\n\n![The use of `const auto&` ensures that no unnecessary copying occurs when iterating over the config map](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/duo_refactor_cpp_clion_chat_cpp23_to_11_02.png)\n\n**Asynchronisierungsübung**: Teste weitere Refactoring-Szenarios.\n\n### COBOL erklären und umgestalten\n\nDu kannst GitLab Duo verwenden, um den Quellcode zu erklären, zu analysieren, zu reparieren und für COBOL-Programme zu refaktorisieren. Ich habe COBOL nie geschrieben oder gelernt und fand diesen [COBOL-Programmierkurs](https://github.com/openmainframeproject/cobol-programming-course) mit vielen Beispielen hilfreich.\n\nIch habe dann den Chat gefragt, wie man mit COBOL beginnt, ein COBOL-Programm erstellt und ein COBOL-Programm auf macOS kompiliert.\n\n```markdown\nPlease explain what COBOL is and its syntax\n\nPlease create a COBOL program that shows the first steps\n\nTell me more about the COBOL compiler. Which system do I need? Can I do it on my macOS?\n\n```\n\n![Bitte an GitLab Duo Chat, die Sprache und ihre Syntax zu erklären](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/vscode_chat_cobol_generate_example.png)\n\nÖffne ein COBOL-Programm, wähle den Quellcode aus, gehe zum Duo Chat und sende den Prompt `/explain`, um Zweck und Funktion des Codes zu erklären. \n\nDu kannst die Prompts auch verfeinern, um allgemeinere Zusammenfassungen zu erhalten, zum Beispiel:\n\n```markdown\n/explain like I am five\n```\n\n> Tipp: Programmiersprachen haben ähnliche Algorithmen und Funktionen. Für COBOL bot der Chat an, es mit Python zu erklären. Deshalb habe ich die folgenden Prompts angepasst, um in Python nach einer Erklärung zu fragen.\n\n```markdown\n/explain in a different programming language\n```\n\nDu kannst auch den Slash-Befehl `/refactor` im Chat verwenden, um die Codequalität zu verbessern, potenzielle Probleme zu beheben und zu versuchen, COBOL in Python zu refaktorisieren.\n\n```markdown\n/refactor fix the environment error\n\n/refactor fix potential problems\n\n/refactor into Python\n```\n\nDie Aufzeichnung [GitLab Duo Coffee Chat – Herausforderung: COBOL-Programme erklären und refaktorisieren](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-explain-refactor-cobol-program) zeigt die Schritte, die ich oben erklärt habe, anhand eines praktischen Beispiels. Hier siehst du auch, wie man einen fehlenden Punkt finden kann: \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/pwlDmLQMMPo\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Eine Sprache in eine andere Sprache refaktorisieren\n\nModernisierung und Verbesserungen der Codequalität erfordern manchmal den Wechsel einer Programmiersprache. Ähnliche Refactoring-Prompts mit GitLab Duo können den Migrationsprozess beschleunigen. Das COBOL-Beispiel mit Python ist nur eine von vielen Anforderungen in Unternehmensumgebungen. Sehen wir uns nun weitere Anwendungsfälle an.\n\n### C in Rust refaktorisieren\n\nAnfang 2024 wurden mehrere Programmiersprachen, darunter C, als nicht speichersicher bezeichnet. Die Empfehlungen für zukünftige Projekte umfassen [speichersichere Sprachen](https://about.gitlab.com/blog/memory-safe-vs-unsafe/) wie Rust. Aber wie startet man eine Migration und welche Herausforderungen gibt es dabei?\n\nVersuchen wir es mit einem einfachen Beispiel in C. Der Code wurde mithilfe von Codevorschlägen generiert und sollte die grundlegenden Betriebssysteminformationen wie Name, Version und Plattform ausdrucken. Der C-Code kompiliert plattformübergreifend unter Windows, Linux und macOS.\n\n```c\n// Read OS files to identify the platform, name, versions\n// Print them on the terminal\n#include \u003Cstdio.h>\n#include \u003Cstdlib.h>\n#include \u003Cstring.h>\n\n#ifdef _WIN32\n    #include \u003Cwindows.h>\n#elif __APPLE__\n    #include \u003Csys/utsname.h>\n#else\n    #include \u003Csys/utsname.h>\n#endif\n\nvoid get_os_info() {\n    #ifdef _WIN32\n        OSVERSIONINFOEX info;\n        ZeroMemory(&info, sizeof(OSVERSIONINFOEX));\n        info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);\n        GetVersionEx((OSVERSIONINFO*)&info);\n\n        printf(\"Platform: Windows\\n\");\n        printf(\"Version: %d.%d\\n\", info.dwMajorVersion, info.dwMinorVersion);\n        printf(\"Build: %d\\n\", info.dwBuildNumber);\n    #elif __APPLE__\n        struct utsname sys_info;\n        uname(&sys_info);\n\n        printf(\"Platform: macOS\\n\");\n        printf(\"Name: %s\\n\", sys_info.sysname);\n        printf(\"Version: %s\\n\", sys_info.release);\n    #else\n        struct utsname sys_info;\n        uname(&sys_info);\n\n        printf(\"Platform: %s\\n\", sys_info.sysname);\n        printf(\"Name: %s\\n\", sys_info.nodename);\n        printf(\"Version: %s\\n\", sys_info.release);\n    #endif\n}\n\nint main() {\n    get_os_info();\n    return 0;\n}\n```\n\nÖffne den Quellcode in [`os.c`](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-refactor-c-to-rust/-/blob/897bf57a14bb7be07d842e7f044f93a61456d611/c/os.c), beispielsweise in JetBrains CLion. Wähle den Quellcode aus und gib den Chat-Prompt `/explain` ein, um Zweck und Funktion erklären zu lassen. Gib als Nächstes `/refactor` in den Chat ein, um den C-Code zu refaktorisieren, und gehe dann einen Schritt weiter: `/refactor into Rust`. \n\nInitialisiere ein neues Rust-Projekt (Tipp: Frage den Duo Chat) und kopiere den generierten Quellcode in die Datei `src/main.rs`. Führe `cargo build` aus, um den Code zu kompilieren.\n\n![Initialisiere ein neues Rust-Projekt und kopiere den generierten Quellcode in die Datei `src/main.rs`. Führe `cargo build` aus, um den Code zu kompilieren.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/jetbrains_clion_c_rust.png)\n\nIn der Aufzeichnung von [GitLab Duo Coffee Chat: Herausforderung – C zu Rust refaktorisieren](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-refactor-c-to-rust) lernst du alle Schritte kennen und siehst außerdem einen Kompilierungsfehler, der mithilfe des Chats und des Slash-Vefehls `/refactor` behoben wird. Die Aufzeichnung zeigt auch, wie man die Wartbarkeit des neuen Rust-Codes verbessern kann, indem man mehr Fehlerbehandlung hinzufügt. \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/nf8g2ucqvkI\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Perl zu Python refaktorisieren \n\nDieses eine Skript, das auf Produktionsservern läuft, seinen Job macht und dessen Autor(in) schon seit zehn Jahren nicht mehr im Unternehmen arbeitet – und das niemand anfassen will. Dieses Problem kann es auch für mehrere Skripte oder sogar für eine ganze Anwendung geben. Dann wird beschlossen, alles auf das moderne Python 3 zu migrieren, mit dem Ziel, den Code zu modernisieren und die Veränderungen zwischen Perl und Python zu verstehen.\n\nEin(e) Kund(in) hat kürzlich in einem GitLab-Duo-Workshop gefragt, ob eine direkte Migration mit GitLab Duo möglich ist. Die kurze Antwort: Ja, das ist es. Die längere Antwort: Du kannst mithilfe verfeinerter Chat-Prompts Perl-Code in Python refaktorisieren, ähnlich wie bei anderen Beispielen in diesem Artikel.\n\nÖffne den Quellcode `script.pl` in der IDE, wähle ihn aus und öffne den Chat.\n\n```perl\n#!/usr/bin/perl\nuse strict;\nuse warnings;\n\nopen my $md_fh, '\u003C', 'file.md' or die \"Could not open file.md: $!\";\n\nmy $l = 0;\nmy $e = 0;\nmy $h = 0;\n\nwhile (my $line = \u003C$md_fh>) {\n  $l++;\n  if ($line =~ /^\\s*$/) {\n    $e++;\n    next;\n  }\n  if ($line =~ /^#+\\s*(.+)/) {\n    print \"$1\\n\";\n    $h++; \n  }\n}\n\nprint \"\\nS:\\n\"; \nprint \"L: $l\\n\";\nprint \"E: $e\\n\"; \nprint \"H: $h\\n\";\n```\n\nYou can use the following prompts to:\n\n1. `/explain` its purpose, and `/refactor` to improve the code.\n2. `/refactor into Python`, um ein funktionierendes Python-Skript zu erhalten.\n\n![Refaktorisierung in Python](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/pycharm_duo_refactor_perl_python.png)\n\n> Tipp: Du kannst Perl-Code in mehrere Zielsprachen refaktorisieren. Die Aufzeichnung von [GitLab Duo Coffee Chat: Herausforderung – Perl zu Python refaktorisieren](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-refactor-perl-python) zeigt Refaktorisierungen zu PHP, Ruby, Rust, Go, Java, VB.NET, C# und mehr.\n> \n> Wenn du Perl-Skripts weiterhin verwenden möchtest, kannst du [Perl als zusätzliche Sprache](https://docs.gitlab.com/ee/user/project/repository/code_suggestions/supported_extensions.html#add-support-for-more-languages) in Duo Codevorschläge konfigurieren. Der Chat versteht bereits Perl und kann bei Fragen und Slash-Befehlen helfen, wie du in der folgenden Aufnahme sehen kannst.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/03HGhxXg9lw\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Weitere Tipps zum Refaktorisieren \n\n### JavaScript refaktorisieren \n\nEddie Jaoude zeigt in einem praktischen Beispiel, wie er JavaScript refaktorisiert, um die Codequalität zu verbessern oder Funktionen hinzuzufügen. \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/mHn8KOzpPNY\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Bash zu ZSH oder SH refaktorisieren\n\nIch benutze Bash seit 20 Jahren als Shell und bin zuletzt auf macOS auf ZSH umgestiegen. Dies führte dazu, dass das Skript nicht funktionierte oder unbekannte Fehler in meinem Terminal auftraten. Ein weiterer Anwendungsfall für das Refactoring sind Shell-Einschränkungen – einige Betriebssysteme oder Linux-/Unix-Distributionen bieten kein Bash, sondern nur SH, z. B. Alpine.\n\n![Shell-Skripte refaktorisieren](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675059/Blog/Content%20Images/intellj_refactor_shell_scripts.png)\n\nDer [GitLab Duo Coffee Chat: Herausforderung – Shell-Skripte refaktorisieren](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/code-challenges/challenge-refactor-shell-scripts) zeigt ein Beispiel mit einem C-Programm, das Syslog-Dateien bearbeiten kann, und einem in Bash geschriebenen Build-Skript. Während der gesamten Challenge wird der Chat mit den Prompts `/explain` und `/refactor` abgefragt, um den Code zu verbessern. Es ist auch möglich, Bash in POSIX-konformes SH oder ZSH zu refaktorisieren. Die Sitzung endet mit der Bitte an den Chat, fünf verschiedene Shell-Skriptimplementierungen bereitzustellen und die wichtigsten Zusammenfassungen zu erläutern. \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/mssqYjlKGzU\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Weitere Anwendungsfälle und Tutorials\n\n- [Dokumentation: GitLab-Duo-Anwendungsfälle](https://docs.gitlab.com/ee/user/gitlab_duo/use_cases.html)\n- [Tutorial: Top-Tipps für effiziente KI-basierte Codevorschläge mit GitLab Duo](https://about.gitlab.com/blog/top-tips-for-efficient-ai-powered-code-suggestions-with-gitlab-duo/)\n- [Tutorial: 10 Best Practices für den Einsatz des KI-basierten GitLab Duo Chat](https://about.gitlab.com/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat/)\n\n## Wichtigste Erkenntnisse \n\n1. GitLab Duo bietet effiziente Hilfe beim Erklären und Refaktorisieren von Code. \n1. Du kannst Code zwischen den Sprachstandards refaktorisieren und im Chat weitere Fragen stellen.\n1. Prompts für Codevorschläge können bestimmte Sprachstandards generieren, und die Code-Vervollständigung geht auf den aktuellen Codekontext ein. \n1. Das Refaktorisieren von Code in neue Programmiersprachen hilft bei längerfristigen Migrations- und Modernisierungsvorhaben.\n1. Code kann auf die unterstützten Sprachstandards älterer Systeme „herabgestuft“ werden.\n1. GitLab Duo kann komplexe Code- und Programmiersprachen mit Beispielen in verschiedenen Programmiersprachen erklären.\n1. Das Update auf Anthropic Claude 3.5 auf GitLab.com hat die Qualität und Geschwindigkeit der Codevorschläge und des Chats noch einmal verbessert (Self-Managed-Upgrade auf 17.3 empfohlen).\n1. Es gibt keine Grenzen, außer deiner Vorstellungskraft und deinen Produktionsschwierigkeiten.\n\nErfahre mehr über effiziente Codevorschläge und Chat-Workflows und beginne jetzt deine KI-basierte Code-Refactoring-Reise mit GitLab Duo!\n\n> [Starte deine 60-tägige kostenlose Testversion von GitLab Duo!](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/?type=free-trial&toggle=gitlab-duo-pro_)\n",[683,688,976],"DevSecOps","2024-11-13",{"slug":979,"featured":6,"template":692},"refactor-code-into-modern-languages-with-ai-powered-gitlab-duo","content:de-de:blog:refactor-code-into-modern-languages-with-ai-powered-gitlab-duo.yml","Refactor Code Into Modern Languages With Ai Powered Gitlab Duo","de-de/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo.yml","de-de/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo",{"_path":985,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":986,"content":992,"config":1000,"_id":1002,"_type":16,"title":1003,"_source":18,"_file":1004,"_stem":1005,"_extension":21},"/de-de/blog/gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants",{"title":987,"description":988,"ogTitle":987,"ogDescription":988,"noIndex":6,"ogImage":989,"ogUrl":990,"ogSiteName":674,"ogType":675,"canonicalUrls":990,"schema":991},"GitLab zum Leader im Gartner Magic Quadrant für KI-Programmierassistenten 2024 ernannt","Im ersten Gartner® Magic Quadrat™ in dieser Kategorie wurde GitLab für seine „Ability to execute sowie die „Completeness of vision“ im Bereich der KI-Programmierassistent-Technologie ausgezeichnet.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749664458/Blog/Hero%20Images/Gartner_AI_Code_Assistants_Blog_Post_Cover_Image_1800x945.png","https://about.gitlab.com/blog/gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab zum Leader im Gartner Magic Quadrant für KI-Programmierassistenten 2024 ernannt\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Dave Steer\"}],\n        \"datePublished\": \"2024-08-22\",\n      }\n                  ",{"title":987,"description":988,"authors":993,"heroImage":989,"date":995,"body":996,"category":14,"tags":997,"updatedDate":999},[994],"Dave Steer","2024-08-22","Wir freuen uns, dass GitLab als Leader im [Gartner® Magic Quadrant™ für KI-Programmierassistenten](https://about.gitlab.com/de-de/gartner-mq-ai-code-assistants/) ausgezeichnet wurde – und das im ersten Jahr, in dem diese Kategorie vergeben wird. Wir sind angesichts dieser wichtigen Auszeichnung geehrt und sind überzeugt, dass dies der beste Beweis dafür ist, wie intensiv wir an KI-gestützten Fähigkeiten arbeiten, die die Softwarebereitstellung beschleunigen, die Sicherheit verbessern und Innovationen unserer Kund(inn)en vorantreiben.\n\nKI-Codeassistenten gehen über die reine Codeerstellung und -vervollständigung hinaus. Sie sind unterstützende Partner, die die Effizienz der Entwickler(innen) steigern, indem sie die Codequalität verbessern und kontinuierlich lernen. Durch die Automatisierung von Routineaufgaben und das Bereitstellen intelligenter Vorschläge verschaffen Assistenten wie GitLab Duo – unsere Suite von KI-gestützten Funktionen – den Entwickler(innen) mehr Zeit, um sich auf Problemlösungen auf höherer Ebene zu konzentrieren.\n\n![Bild von Gartner MQ KI-Programmierassistenten](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675964/Blog/Content%20Images/AI_Code_Assistants_MQ_graphic__1_.png)\n\n> Lade den [Bericht des Gartner® Magic Quadrant™ für KI-Programmierassistenten 2024](https://about.gitlab.com/de-de/gartner-mq-ai-code-assistants/) herunter.\n\n## KI-Programmierassistent: Geschwindigkeit, Sicherheit und nahtlose Integration\n\nKI-Programmierassistenten sind für Unternehmen jeder Größe unentbehrlich und helfen DevSecOps-Teams, sichere Software schneller zu entwickeln und bereitzustellen. Der wahre Wert von KI zeigt sich jedoch, wenn sie in den gesamten Lebenszyklus der Softwareentwicklung integriert wird. Anders als punktuelle KI-Lösungen, die zu fragmentierten Toolchains und Datensilos führen können, bettet die umfassende Plattform von GitLab die KI von der Planung bis zur Produktion ein. So bietet die Lösung umfassende Sichtbarkeit sowie Informationen über Metriken und Dashboards.\n\n## Die Stärke von GitLab Duo\n\n[GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) ist eine umfassende Toolbox mit KI-Funktionen, die entwickelt wurde, um das Erlebnis für Entwickler(innen) zu verbessern, die Sicherheit an den Beginn des Entwicklungszyklus zu verlagern und die Zusammenarbeit zwischen den Teams in den Bereichen Dev, Sec und Ops zu stärken. Zu den wichtigsten Funktionen gehören: \n\n* Codevorschläge für die Codeerstellung und Code-Vervollständigung\n* Chat für kontextsensitive In-App-Unterstützung für Codeerläuterung, Code-Refactoring und Testgenerierung\n* Erklärung von Sicherheitslücken, um diese im Code besser zu verstehen\n* Beheben von Sicherheitslücken\n* Grundursachenanalyse zur Behebung von Pipeline-Problemen\n* KI-Impact-Analyse-Dashboard, um Informationen in Echtzeit zu erhalten und den KI-ROI eines Unternehmens zu bewerten\n\n## Maximierung des ROI mit KI \n\nFührungskräfte aus Wirtschaft und Technik benötigen einen Überblick darüber, wie KI im gesamten Lebenszyklus der Softwareentwicklung eingesetzt wird, um den ROI ihrer Technologieinvestitionen zu bewerten. Das [KI-Impact-Analyse-Dashboard](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/) von GitLab bietet nicht nur Sichtbarkeit, sondern auch Metriken, um KI-Annahmeraten, Leistungsverbesserungen und noch vieles mehr zu messen.\n\n## Flexibilität, Datenschutz und Transparenz im Fokus\n\nGitLab-Kund(inn)en, die KI-basierte Funktionen entdecken möchten, können mit GitLab Duo die Leistung der KI sicher in einer IDE ihrer Wahl oder in einem GitLab Remote Development Workspace ausprobieren. Dabei erwartet sie eine flexible Preisstruktur sowie eine 60-tägige, kostenlose Testversion. Außerdem bietet das [GitLab AI Transparency Center](https://about.gitlab.com/ai-transparency-center/) einen vollständigen Einblick in unsere Governance- und Transparenzpraktiken. \n\nBald können Unternehmen ihre [KI-Erfahrung](https://about.gitlab.com/de-de/blog/meet-gitlab-duo-workflow-the-future-of-ai-driven-development/) durch Modellpersonalisierungen und Bereitstellung über ein selbstgehostetes Modell an ihre strategischen und regulatorischen Anforderungen anpassen. Durch die Modellpersonalisierung können Unternehmen GitLab Duo anpassen und das volle Potenzial der KI ausschöpfen, behalten dabei aber gleichzeitig ihre Geschäftsziele, betrieblichen Anforderungen und Erwartungen der Kund(inn)en im Blick. Die Bereitstellung über ein selbst gehostetes Modell stellt sicher, dass Daten die sichere Umgebung eines Unternehmens nicht verlassen. So kann das Risiko für Verstöße verringert und die Compliance in Branchen mit hohen regulatorischen Anforderungen sichergestellt werden.\n\n## Wir bereiten den Weg in die Zukunft der KI in DevSecOps\n\nGitLab ist dein Partner für KI-gestützte Softwareentwicklung. Wir statten Teams mit den Tools aus, die sie brauchen, um Software schneller zu entwickeln, zu sichern und bereitzustellen. Innovation ist Teil unserer DNA – das heißt, dass unsere Kunden jederzeit von den neuesten Entwicklungen im Bereich der KI profitieren! Wir haben uns nicht weniger vorgenommen, als den Bereich DevSecOps kontinuierlich zu revolutionieren, also bleib dran und entdecke in unserer Roadmap jede Menge spannende Updates.\n\n> [Lade den Bericht des Gartner® Magic Quadrant™ für KI-Programmierassistenten 2024 jetzt herunter](https://about.gitlab.com/de-de/gartner-mq-ai-code-assistants/).\n\n***Quelle: Gartner, Magic Quadrant für KI-Programmierassistenten, Arun Batchu, Haritha Khandabattu, Philip Walsh, Matt Brasier, August 2024***\n\n***GARTNER ist eine eingetragene Marke und Dienstleistungsmarke von Gartner, Inc. und/oder seinen verbundenen Unternehmen in den USA und international, und MAGIC QUADRANT ist eine eingetragene Marke von Gartner, Inc. und/oder seinen verbundenen Unternehmen und wird hierin mit Genehmigung verwendet. Alle Rechte vorbehalten.***\n\n***Gartner empfiehlt keine Anbieter, Produkte oder Dienstleistungen, die in seinen Forschungspublikationen abgebildet sind, und rät Technologiebenutzer(inne)n nicht, nur die Anbieter mit den höchsten Bewertungen oder anderen Bezeichnungen auszuwählen. Gartner-Forschungspublikationen bestehen aus den Meinungen der Forschungsorganisation von Gartner und sollten nicht als Tatsachenbehauptungen ausgelegt werden. Gartner lehnt alle ausdrücklichen oder stillschweigenden Gewährleistungen in Bezug auf diese Studie ab, einschließlich aller Gewährleistungen der Marktgängigkeit oder Eignung für einen bestimmten Zweck.***\n\n***Diese Grafik wurde von Gartner Inc. als Teil eines umfassenderen Berichts veröffentlicht und sollte im Kontext des gesamten Dokuments bewertet werden. Das Gartner-Dokument ist auf Anfrage bei Gartner B.V. erhältlich.***\n",[684,683,976,998],"research","2024-09-05",{"slug":1001,"featured":93,"template":692},"gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants","content:de-de:blog:gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants.yml","Gitlab Named A Leader In 2024 Gartner Magic Quadrant For Ai Code Assistants","de-de/blog/gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants.yml","de-de/blog/gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants",{"_path":1007,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1008,"content":1014,"config":1022,"_id":1024,"_type":16,"title":1025,"_source":18,"_file":1026,"_stem":1027,"_extension":21},"/de-de/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities",{"title":1009,"description":1010,"ogTitle":1009,"ogDescription":1010,"noIndex":6,"ogImage":1011,"ogUrl":1012,"ogSiteName":674,"ogType":675,"canonicalUrls":1012,"schema":1013},"Die Entwicklung von GitLab Duo: KI zur Behebung von Sicherheitslücken nutzen ","Dieses Tutorial zeigt, wie dir die GitLab-Duo-Funktionen zur Erläuterung und Behebung von Sicherheitslücken zusammen mit unseren anderen KI-basierten Funktionen helfen können, Sicherheitslücken schnell zu beheben.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098106/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098106040.png","https://about.gitlab.com/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Die Entwicklung von GitLab Duo: KI zur Behebung von Sicherheitslücken nutzen \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"},{\"@type\":\"Person\",\"name\":\"Alana Bellucci\"}],\n        \"datePublished\": \"2024-07-15\",\n      }\n                  ",{"title":1009,"description":1010,"authors":1015,"heroImage":1011,"date":1017,"body":1018,"category":14,"tags":1019,"updatedDate":1021},[972,1016],"Alana Bellucci","2024-07-15","Du hast gerade eine neue Stelle angetreten, und gleich an deinem ersten Tag gibt es einen schwerwiegenden Vorfall in der Produktion, bei dem alle verfügbaren Arbeitskräfte benötigt werden. Eine Reihe kritischer neuer Sicherheitslücken erfordert sofortige Aufmerksamkeit, Analyse, Schadensbegrenzung und Behebung. Aber wo genau fängst du mit deiner Untersuchung an?\n\nErfahre, wie du mit den GitLab-Duo-Funktionen zur Erläuterung von Sicherheitslücken und Behebung von Sicherheitslücken zusammen mit anderen KI-basierten Funktionen innerhalb weniger Minuten mit der Behebung von Sicherheitslücken beginnen kannst. Anhand eines praktischen Beispiels erfährst du, wie du von der KI-basierten Unterstützung bei der Analyse und Erläuterung von Sicherheitslücken profitieren kannst. Zusätzliche Abhilfemaßnahmen stehen in Form von KI-generierten Codekorrekturen in MRs im Vordergrund, um Sicherheitslücken schneller zu beheben.\n\n> Starte [eine kostenlose Testversion von GitLab Duo](https://about.gitlab.com/gitlab-duo/#free-trial), um diese leistungsstarken Vorteile bei der Behebung von Sicherheitslücken auch in deinem Unternehmen zu nutzen.\n\n## So gehst du vor: Analyse\n\nDer erste Schritt besteht darin, die Auswirkungen und den Schweregrad der Sicherheitslücke zu analysieren. Öffne die GitLab-Benutzeroberfläche und navigiere zum [Sicherheitslückenbericht](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/) im Menü `Schützen > Sicherheitslückenbericht`. Filtere die Liste der Sicherheitslücken nach `SAST` und identifiziere die kritischsten Sicherheitslücken, an denen du arbeiten musst.\n\n![Übersicht über Sicherheitslückenberichte](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/vulnerability_reports_overview_aHR0cHM6_1750098116056.png)\n\nDie Ergebnisse des SAST-Scanners werden in der Detailansicht zusammengefasst und mit dem Quellcode verknüpft. Sie enthalten Details aus öffentlich zugänglichen Sicherheitshinweisen. Für Entwickler(innen) ist es oft schwierig, direkt aus dem Sicherheitsbericht heraus mit der Analyse zu beginnen, es sei denn, sie kennen den Umfang des Angriffs, die technischen Details und die Sicherheitslücken genau.\n\n## Verstehen und Entschärfen mit der Erläuterung von Sicherheitslücken\n\nEs ist unerlässlich, dass du die Sicherheitslücke verstehst und weißt, wie du sie am besten und effizientesten beheben kannst. Die Korrekturen dürfen bestehende Funktionen nicht beeinträchtigen. Falls doch, ist eine Besprechung mit den zuständigen Betreuer(inne)n und Product Ownern mit einer Zusammenfassung und möglichen Abhilfemaßnahmen erforderlich. Code, den ein(e) ehemalige(r) Mitarbeiter(in) geschrieben hat, oder Code, für den es keine Tests gibt, kann die Planung eines Fixes noch schwieriger machen.\n\nDie KI-basierte Erläuterung von Sicherheitslücken bietet eine Zusammenfassung, wie ein(e) Angreifer(in) die Sicherheitslücke ausnutzen könnte, und liefert weitere Erklärungen zu den Auswirkungen und möglichen Abhilfemaßnahmen.\n\nDas folgende Beispiel zeigt eine OS-Command-Injection-Sicherheitslücke unter Verwendung dieses Codeschnipsels:\n\n```php\n\u003C?php \n\n// Read variable name from GET request\n$name = $_GET['name'];\n\n// Use the variable name to call eval and print its value \neval('echo $' . $name . ';');\n```\n\nDer Sicherheitslückenbericht ist nicht sehr detailliert und setzt voraus, dass du den gesamten Kontext und die Auswirkungen verstehst. Wähle oben rechts `Sicherheitslücke erläutern`, um den GitLab Duo Chat mit einem vordefinierten Prompt zu öffnen. Dieser bietet eine zusätzliche Zusammenfassung der Sicherheitslücke, eine Beschreibung, wie die Sicherheitslücke ausgenutzt werden kann, und einen Lösungsvorschlag.\n\n![Unsachgemäße Neutralisierung von\nspeziellen Elementen, die in einem Betriebssystembefehl verwendet werden\n(„OS Command Injection“) ](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750098116057.png)\n\n### Erläuterung von Sicherheitslücken in einem Gespräch mit Kontext \n\nDu wirst auch eine Änderung in der Benutzeroberfläche sehen: Das vorherige Overlay der Erläuterung von Sicherheitslücken wurde durch einen GitLab-Duo-Chat-Workflow ersetzt. Manchmal benötigt eine komplexe Sicherheitslücke mehrere Abhilfemaßnahmen oder sie führt zu unklaren Quellcodepfaden.\n\nDu kannst zum Quellcodebaum navigieren und mit demselben Chat-Kontext fortfahren, um dir den Code erläutern zu lassen, ihn zu reparieren, zu überarbeiten und zu testen. \n\nProbieren wir den kompletten Workflow anhand eines Beispiels in C aus, bei dem die Sicherheitsscans einen Pufferüberlauf entdeckt haben.\n\n1. Öffne die Detailansicht der Sicherheitslücke und wähle oben rechts auf der Schaltfläche „Sicherheitslücke erläutern“. Dies öffnet den Chat-Prompt mit einer Zusammenfassung des Problems, potenziellen Angriffsvektoren und einem Lösungsvorschlag.\n\n![KI für Sicherheitslücken – Bild 4](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750098116059.png)\n\n2. Überprüfe den Lösungsvorschlag und bitte Duo Chat in einem Folge-Prompt, dir alternative Lösungsmöglichkeiten anzuzeigen, indem du den folgenden Text eingibst: `Can you show an alternative fix using a different function`. Der Sinn dahinter ist, etwas über Alternativen zur Funktion `strcpy()` zu erfahren, die sicherer zu verwenden sind.\n\n![KI für Sicherheitslücken – Bild 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098116060.png)\n\n3. Duo Chat bietet im folgenden Beispiel eine alternative Lösung mit `strlcpy()`. Die Funktion kopiert nur so viele Zeichen, wie in der Zielzeichenfolge erlaubt sind, und beendet die Zeichenfolge immer mit Null. Sie gibt auch die Länge der Quellzeichenfolge zurück, um festzustellen, ob die Zeichenfolge abgeschnitten wurde.\n\n![KI für Sicherheitslücken – Bild 5](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750098116062.png)\n\n4. Klicke auf die URL der Datei `Location`, um zur Quellcodeansicht zu gelangen. Öffne Duo Chat erneut und vergewissere dich, dass der vorherige Kontext zur Erläuterung der Sicherheitslücke noch vorhanden ist. Als Nächstes möchten wir Tests hinzufügen, bevor wir mit einem Lösungsvorschlag fortfahren. So vermeiden wir, dass Funktionen kaputt gehen oder Regressionen eingeführt werden. Verwende zum Beispiel den folgenden Chat-Prompt: `Based on the vulnerability context and opened source code, how would you add tests for it?`.\n\n![KI für Sicherheitslücken – Bild 7](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750098116063.png)\n\n5. Nachdem du Tests erstellt hast (und angenommen, sie wurden jetzt hinzugefügt), kannst du Duo Chat mit dem Prompt `Can you refactor the source code too?` in der gleichen Sitzung auch darum bitten, den Quellcode zu überarbeiten.\n\n![KI für Sicherheitslücken – Bild 6](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098116063.png)\n\nDer Workflow zeigt dir, wie du Sicherheitslücken analysierst, verstehst, entschärfst, alternative Ansätze findest, Tests hinzufügst und sogar Refactoring durchführst. \n\nDu kannst diesen Weg mit Duo Chat fortsetzen und dann in die Web IDE wechseln, um den Quellcode zu ändern, nachdem du gelernt hast, wie es geht. Zu den weiteren fortlaufenden Workflows gehören das Committen von Änderungen und das Auslösen der CI/CD-Pipeline und von Sicherheitsscans für den gesamten DevSecOps-Lebenszyklus. \n\n## Beheben mit KI-unterstützter Behebung von Sicherheitslücken \n\nUm eine Sicherheitslücke zu verstehen und zu beheben, sind immer noch Entwicklerfähigkeiten notwendig, um in einem neuen Merge Request eine Lösung für das Problem zu erstellen, Pipelines auszuführen und Sicherheitsscans durchzuführen. Es kann auch erforderlich sein, die Fixes in einer Staging-Umgebung bereitzustellen und über einen längeren Zeitraum zu testen.\n\nDie KI kann dir dabei helfen, einen Lösungsvorschlag auf der Grundlage des bereitgestellten Kontexts der Sicherheitslücke und des Quellcodes zu generieren.\n\nTipp: Denke an die ärgerlichste Sicherheitslücke, die du in deiner Karriere bisher beheben musstest, und erstelle das Anwendungsbeispiel erneut für GitLab Duo. Die [Mitre CWE Top 25 der gefährlichsten Software-Sicherheitslücken](https://cwe.mitre.org/top25/archive/2023/2023_top25_list.html) bietet ebenfalls einen guten Ausgangspunkt.  \n\nDas folgende Beispiel implementiert [CWE-328: Use of a weak hash function (Verwendung einer schwachen Hash-Funktion)](https://cwe.mitre.org/data/definitions/328.html) unter Verwendung von `md5`. Die Sicherheitslücke wird von [SAST-Scannern](https://docs.gitlab.com/ee/user/application_security/sast/) korrekt identifiziert. \n\n```python\nimport hashlib\n\nclass User:\n    def __init__(self, username, password):\n        self.username = username\n        self.password = password\n\n    def set_password(self, password):\n        self.password = hashlib.md5(password.encode()).hexdigest()\n```\n\n![KI für Sicherheitslücken – Bild 8](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750098116064.png)\n\nKlicke oben rechts auf die Schaltfläche `Mit Merge Request lösen`.  Dies öffnet einen MR, der KI verwendet, um eine Lösung vorzuschlagen. Eine mögliche Lösung für diese Sicherheitslücke könnte die Verwendung einer anderen Hash-Funktion sein.\n\n![KI für Sicherheitslücken – Bild 9](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098116065.png)\n\nEin weiteres häufiges Beispiel für eine Sicherheitslücke ist die Nichtüberprüfung von Funktionsfehlercodes oder möglichen Exceptions. Die folgenden C-Codeschnipsel implementieren ein Beispiel für Timing-Angriffe auf Dateivorgänge mit [CWE-362](https://cwe.mitre.org/data/definitions/362.html) für die Aufrufe `fopen()` und `chmod()`. \n\n```c\n#include \u003Cstdio.h>\n#include \u003Cstring.h>\n#include \u003Csys/mman.h>\n#include \u003Csys/stat.h>\n#include \u003Cunistd.h>\n\nint main(int argc, char **argv) {\n\n    // File operations\n    char *fname = \"gitlab.keksi\";\n\n    FILE *fp;\n    fp = fopen(fname, \"r\");\n    fprintf(fp, \"Hello from GitLab Duo Vulnerability Resolution Challenge\");\n    fclose(fp);\n\n    // Potential chmod() timing attacks    \n\n    // Make the file world readable\n    chmod(fname, S_IRWXU|S_IRWXG|S_IRWXO);\n\n    return 0;\n}\n```\n\nDer SAST-Bericht für `chmod()` kann wie folgt aussehen: \n\n![KI für Sicherheitslücken – Bild 10](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750098116065.png)\n\nDer vorgeschlagene Merge Request für `chmod()` beinhaltet die Fehlerbehandlung. Zusätzlich wird ein weiteres potenzielles Problem behoben, durch das Dateien öffentlich beschreibbar sind, indem die Berechtigungen von `777` auf `600` geändert werden.\n\n![KI für Sicherheitslücken – Bild 11](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098116066.png)\n\n> Probiere diese asynchrone Übung aus: Finde, analysiere und behebe die Sicherheitslücke für die Funktion `fopen()`.\n\n## Mehr KI-Unterstützung von GitLab Duo erforderlich \n\nOft lässt sich ein Sicherheitsproblem mit einer schnellen Lösung oder einem Workaround beheben, der den Entwicklungsteams Zeit gibt, eine längerfristige Lösung zu diskutieren und zu planen. In anderen Fällen wird das Problem komplexer und erfordert die Deaktivierung von Funktions-APIs oder die Behebung von Problemen der Firewall, bis eine angemessene Lösung in die Produktion eingeführt werden kann.\n\nGitLab Duo bietet zusätzliche KI-basierte Funktionen, die bei der Lösung dieser Probleme helfen können. \n\n**Codeerläuterung:** Als Entwickler(in) oder Sicherheitsingenieur(in) ist es wichtig, dass du dich auf deine Änderungen verlassen kannst. In der IDE kannst du die [Funktion „Codeerläuterung“](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#explain-code-in-the-ide) verwenden, um die von der KI vorgeschlagene Lösung für die Sicherheitslücke besser zu verstehen. So ist sichergestellt, dass du genau weißt, welche Anpassungen vorgenommen wurden und warum.\n\n**Grundursachenanalyse:** Wenn die Lösung deine Pipeline beschädigt, kannst du die [Grundursachenanalyse](https://about.gitlab.com/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/) verwenden. Dieses Tool hilft dir bei der Identifizierung des zugrunde liegenden Problems und erklärt es dir, damit du es effektiv angehen kannst. Nachdem du die erforderlichen Korrekturen vorgenommen hast, kannst du die Tests erneut ausführen, um eine erfolgreiche Lösung zu gewährleisten.\n\n**Refactoring:** Auch wenn die Sicherheitslücke behoben wurde, lohnt es sich zu überlegen, ob der Code nicht sicherer geschrieben werden kann. In der IDE kannst du GitLab Duo Chat öffnen und die [Refactoring-Aktion](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#refactor-code-in-the-ide) verwenden, um alternative, sicherere Möglichkeiten zum Schreiben deines Codes zu finden. Dieser proaktive Ansatz trägt zur Aufrechterhaltung einer robusten und sicheren Codebase bei.\n\nMit diesen Funktionen von GitLab Duo kannst du Sicherheitslücken selbstbewusst erkennen und beheben und so sicherstellen, dass dein Code sicher und effizient bleibt.\n\n## Wie geht es weiter?\n\nWir planen, sowohl die Erläuterung von Sicherheitslücken als auch die Behebung von Sicherheitslücken „nach links“ zu verschieben, indem wir sie direkt in den MR-Prozess integrieren. Diese Integration stellt sicher, dass du Sicherheitslücken früher im Entwicklungszyklus angehen und beheben kannst, was deinen Workflow optimiert und die Codesicherheit von Anfang an erhöht.\n\n## Erste Schritte mit GitLab Duo\n\nIn unserer [Dokumentation](https://docs.gitlab.com/ee/user/gitlab_duo/turn_on_off.html) findest du Informationen dazu, wie du die Funktion für unsere GitLab-Ultimate-Kund(inn)en aktivieren kannst. Außerdem sind die GitLab-Duo-Funktionen [Erläuterung von Sicherheitslücken](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#explaining-a-vulnerability) und [Behebung von Sicherheitslücken](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#vulnerability-resolution) bald in GitLab Self-Managed und GitLab Dedicated verfügbar.\n\nIn [der Blog-Serie „Entwicklung von GitLab Duo“](https://about.gitlab.com/blog/developing-gitlab-duo-series/) erfährst du regelmäßig, was es Neues in GitLab Duo gibt.\n\n> Starte [eine kostenlose Testversion von GitLab Duo](https://about.gitlab.com/gitlab-duo/#free-trial), um diese leistungsstarken Vorteile bei der Behebung von Sicherheitslücken auch in deinem Unternehmen zu nutzen!\n",[683,1020,687,685,688],"security","2024-11-29",{"slug":1023,"featured":93,"template":692},"developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities","content:de-de:blog:developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities.yml","Developing Gitlab Duo Use Ai To Remediate Security Vulnerabilities","de-de/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities.yml","de-de/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities",{"_path":1029,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1030,"content":1036,"config":1043,"_id":1045,"_type":16,"title":1046,"_source":18,"_file":1047,"_stem":1048,"_extension":21},"/de-de/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements",{"title":1031,"description":1032,"ogTitle":1031,"ogDescription":1032,"noIndex":6,"ogImage":1033,"ogUrl":1034,"ogSiteName":674,"ogType":675,"canonicalUrls":1034,"schema":1035},"GitLab Duo: Ein Überblick über die neuesten Verbesserungen im Chat","Entdecke die neusten Verbesserungen beim Chat von GitLab Duo, darunter eine neue Integration, der Abbruch von Prompts sowie Architektur-Upgrades.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098374/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098374059.png","https://about.gitlab.com/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo: Ein Überblick über die neuesten Verbesserungen im Chat\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Jannik Lehmann\"},{\"@type\":\"Person\",\"name\":\"David O'Regan\"}],\n        \"datePublished\": \"2024-07-10\",\n      }\n                  ",{"title":1031,"description":1032,"authors":1037,"heroImage":1033,"date":1040,"body":1041,"category":14,"tags":1042,"updatedDate":977},[1038,1039],"Jannik Lehmann","David O'Regan","2024-07-10","GitLab ist bestrebt, [den Chat von GitLab Duo](https://gitlab.com/gitlab-org/gitlab/-/issues/430124), unseren KI-Assistenten, kontinuierlich zu verbessern, um den sich wandelnden Bedürfnissen unserer Benutzer(innen) gerecht zu werden. Hier findest du einige neue Verbesserungen, die deinen Workflow optimieren und deine Produktivität steigern werden.\n\n> Entdecke die Zukunft von KI-gestützter Softwareentwicklung mit unserem virtuellen Launch-Event zu GitLab 17.  [Sieh es dir jetzt an](https://about.gitlab.com/seventeen/)!\n\n## Erklärung von Sicherheitslücken: neue Integration\n\nWir haben einen wichtigen Meilenstein bei der Evolution des Chats erreicht: die Integration der [Erklärung von Sicherheitslücken in GitLab Duo](https://about.gitlab.com/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/). Dies ist die erste Funktion in [GitLab Duo](https://about.gitlab.com/gitlab-duo/), die von einem Team außerhalb unserer KI-Gruppe in den Chat integriert wurde. Dies zeigt, wie großen Wert man bei GitLab auf Zusammenarbeit und funktionsübergreifende Fähigkeiten legt.\n\n### Die wichtigsten Höhepunkte dieser Integration:\n\n- **Rasche Ausführung:** Das Team schaffte es in nur drei Wochen von einer Nachfragespitze zur Implementierung und bewies dadurch Agilität und Ausführungsstärke.\n- **Teamübergreifende Zusammenarbeit:** Diese Integration wurde von Teams außerhalb der KI-Gruppe geleitet und ebnete so den Weg für weitere, unterschiedliche Funktionsintegrationen, die die Zukunft bringen könnte.\n- **Verbesserte Sicherheitseinblicke:** Benutzer(innen) können demnächst den Chat nutzen, um ein tieferes Verständnis für Sicherheitslücken zu erhalten, die in ihren Projekten gefunden wurden.\n\nDiese Integration ist ein wichtiger Schritt, um den Chat zu einem noch leistungsstärkeren und vielseitigeren Tool für Entwickler(innen) zu machen, insbesondere im Bereich der Sicherheit.\n\n## Verbessertes Kontextbewusstsein\n\nWir haben erhebliche Fortschritte darin gemacht, das Kontextbewusstsein des Chats zu verbessern. Dadurch wurde er in verschiedenen Szenarien intelligenter und hilfreicher.\n\n### Immer verfügbares Wissen\n\nGitLab Duo Chat hat immer Zugriff auf:\n- GitLab-Dokumentation\n- Allgemeine Programmier- und Codierkenntnisse \n\nEs ist wichtig zu verstehen, dass der Chat keinen uneingeschränkten Zugriff auf deine gesamte GitLab-Instanz oder Codebase hat. Er verarbeitet nur die spezifischen Informationen, die du in deiner Abfrage angibst, bzw. das, was in der UI oder IDE in GitLab in deiner derzeitigen Ansicht unmittelbar relevant ist.\n\nWir arbeiten kontinuierlich daran, das Kontextbewusstsein des Chats auszubauen und weitere Inhaltstypen zu integrieren. Natürlich achten wir dabei immer auf die Privatsphäre der Benutzer(innen) sowie den Datenschutz. Durch diese schrittweise Erweiterung wird der Chat nach und nach zu einem immer leistungsstärkeren Assistenten für deinen Entwicklungs-Workflow, während die nötigen Einschränkungen für den Datenzugriff beibehalten werden.\n\n### Erweitertes Kontextwissen\n\nGitLab Duo Chat bietet jetzt [ein besseres Verständnis des Kontexts, in dem du arbeitest](https://docs.gitlab.com/ee/user/gitlab_duo_chat/#the-context-chat-is-aware-of), sowohl in der GitLab-UI als auch in IDEs. Hier haben wir für dich aufgeschlüsselt, was der Chat erkennt.\n\nIn der GitLab-UI:\n- **Epics** - Der Chat versteht, wenn du dich auf „dieses Epic“ beziehst oder die URL des Epics verwendest.\n- **Tickets** - Ähnlich wie bei Epics erkennt der Chat „dieses Ticket“ oder die URL des Tickets.\n- **Codedateien** - Beim Anzeigen einer einzelnen Datei kann der Chat Anfragen zu „diesem Code“ oder „dieser Datei“ interpretieren.\n\nIn IDEs:\n- **Ausgewählter Code** - Der Chat kann den von dir ausgewählten Code analysieren, wenn du nach „diesem Code“ oder „dieser Datei“ fragst.\n- **Epics und Tickets** -  Der Chat kann den Kontext verstehen, wenn du die URL angibst.\n\nWenn du in IDEs Slash-Befehle wie `/explain`, `/refactor`, oder `/tests` verwendest, hat der Chat außerdem Zugriff auf den ausgewählten Code.\n\n![Screenshot des GitLab Duo Chat-Fensters](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750098382107.png)\n\n### Chatverlauf und Caching\nDer GitLab Duo Chat behält die letzten 50 Nachrichten im Chat-Verlauf bei. Dieser Verlauf läuft drei Tage nach der letzten Verwendung ab. Wenn du deinen Browser oder deine IDE schließt, wird dein Chat-Verlauf innerhalb dieses Zeitraums nicht dauerhaft gelöscht. Bitte beachte jedoch, dass die langfristige Speicherung von Chat-Daten derzeit nicht unterstützt wird.\n\n## Abbruch von Prompts: Antworten bei Bedarf stoppen\n\nEine der am sehnlichsten erwarteten Funktionen ist jetzt verfügbar: [der Abbruch von Prompts](https://gitlab.com/groups/gitlab-org/-/epics/13662). Benutzer(innen) können jetzt laufende Prompts im Chat auf GitLab.com abbrechen und haben so [mehr Kontrolle über ihre Interaktionen](https://gitlab.com/gitlab-org/gitlab/-/issues/458397).- Jetzt verfügbar: Diese Funktion wurde auf GitLab.com eingeführt.\n- Demnächst verfügbar: Diese Funktion wird in unserer nächsten Version für selbstverwaltete Instanzen verfügbar sein. Benutzer(innen) von GitLab Dedicated erhalten sie im monatlichen Upgrade.\n- Offen: [Integration für Editor-Erweiterungen](https://docs.gitlab.com/ee/editor_extensions/) – [folge den Neuheiten im Ticket](https://gitlab.com/gitlab-org/editor-extensions/gitlab-jetbrains-plugin/-/issues/335).\n\nMit dieser Erweiterung kannst du eine Antwort stoppen, wenn du einen Prompt zu früh gesendet hast oder während des Wartens eine Änderung vorgenommen hast. Es ist eine kleine, aber leistungsstarke Funktion, die dir Zeit und Frust sparen kann.\n\nUm einen Prompt im GitLab Duo Chat abzubrechen, gehe wie folgt vor:\n1. Öffne den GitLab Duo Chat auf GitLab.com.\n2. Gib einen Prompt oder eine Frage ein, z. B. `What is this issue about?`.\n\n![Bildschirm mit dem Abbruch von Prompts im GitLab Duo Chat](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098382108.png)\n\n3. Wenn du nach dem Senden des Prompts die Antwort abbrechen möchtest, suche nach der neuen Schaltfläche „Abbrechen“, die angezeigt wird, während der Chat eine Antwort generiert.\n\n![Screenshot der Schaltfläche „Abbrechen“ im Chat](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098382110.png)\n\n4. Klicke auf die Schaltfläche „Abbrechen“, um die Antwortgenerierung sofort zu stoppen.\n\n![Screenshot zeigt, dass die Antwort abgebrochen wurde](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098382112.png)\n\n## Architekturverbesserungen\n\nHinter den Kulissen haben wir an Architekturverbesserungen gearbeitet, um den GitLab Duo Chat robuster und effizienter zu machen:\n\n- Umstieg auf das Language Server Protocol ([LSP](https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp)): Dadurch wird die Integration des Chats in verschiedene Entwicklungsumgebungen verbessert. \n- GitLab Language Server ist ein experimentelles TypeScript-Projekt, das eine gemeinsame Schnittstelle für IDE-Erweiterungen zum Erstellen von GitLab-Funktionen bietet. Es unterstützt derzeit Codevorschläge für GitLab Duo und wird in Kürze auch GitLab Duo Chat unterstützen.\n\nObwohl diese Änderung hauptsächlich die zugrunde liegende Architektur betrifft, bemerken Benutzer(innen) vielleicht Folgendes:\n- Verbesserte Reaktion und Leistung bei der Nutzung des Chats in verschiedenen IDEs und Editoren.\n- Konsistenteres Verhalten der Chat-Funktionen in verschiedenen Entwicklungsumgebungen.\n- Verbesserte Möglichkeit, in Zukunft neue Funktionen und Verbesserungen hinzuzufügen.\n\nSieh dir in diesem Video eine Einführung dazu an, wie GitLab Language Server Codevorschläge ermöglicht:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/VQlWz6GZhrs?si=_G5mOyYqEGAmnRv4\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Wie geht es weiter?\n\nWir arbeiten kontinuierlich daran, GitLab Duo Chat zu verbessern. Hier sind einige Highlights:\n\n- Wir sind dabei, unsere KI-Funktionen auf [Claude 3.5 Sonnet](https://gitlab.com/gitlab-org/gitlab/-/issues/468334) zu migrieren. Dieses Upgrade bringt eine verbesserte Leistung und Funktionen für den Chat und andere KI-gestützte Funktionen.\n- Wir arbeiten aktiv daran, dass der [Chat auch mit benutzerdefinierten, selbst gehosteten Modellen funktioniert](https://gitlab.com/groups/gitlab-org/-/epics/13760). Dadurch können Unternehmen ihre eigenen KI-Modelle mit dem Chat nutzen und haben so mehr Kontrolle über die Wissensdatenbank der KI. Außerdem wird die Leistung bei domain-spezifischen Aufgaben potenziell verbessert.\n- Wir sind derzeit dabei, die [Synchronisierung von Nachrichten über alle Clients hinweg](https://gitlab.com/gitlab-org/gitlab/-/issues/418760), einschließlich WebUI, abzuschließen, um eine nahtlose Kommunikation zu gewährleisten und alle deine Clients synchron zu halten und so deine Zusammenarbeit zu verbessern.\n- Wir [migrieren die Funktion „Kommentare zusammenfassen“ in den Chat](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/156650). Du kannst mehrere Kommentare direkt im Chat zu einem Ticket zusammenfassen, um die wichtigsten Punkte und Erkenntnisse aus Diskussionen schnell zu verstehen und so deine Zusammenarbeit zu verbessern.\n\nWir freuen uns auf [dein Feedback zu diesen Verbesserungen](https://gitlab.com/gitlab-org/gitlab/-/issues/430124). Bleib dran, während wir GitLab Duo Chat weiterentwickeln.\n\n> Erfahre in unserer laufenden Serie noch mehr darüber, [wie wir GitLab Duo entwickeln](https://about.gitlab.com/blog/developing-gitlab-duo-series/).\n",[683,685,687],{"slug":1044,"featured":93,"template":692},"developing-gitlab-duo-a-roundup-of-recent-chat-enhancements","content:de-de:blog:developing-gitlab-duo-a-roundup-of-recent-chat-enhancements.yml","Developing Gitlab Duo A Roundup Of Recent Chat Enhancements","de-de/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements.yml","de-de/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements",{"_path":1050,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1051,"content":1056,"config":1061,"_id":1063,"_type":16,"title":1064,"_source":18,"_file":1065,"_stem":1066,"_extension":21},"/de-de/blog/meet-gitlab-duo-workflow-the-future-of-ai-driven-development",{"title":1052,"description":1053,"ogTitle":1052,"ogDescription":1053,"noIndex":6,"ogImage":703,"ogUrl":1054,"ogSiteName":674,"ogType":675,"canonicalUrls":1054,"schema":1055},"Lerne GitLab Duo Workflow kennen – die Zukunft der KI-gestützten Entwicklung","Workflow, unser autonomer KI-Agent, wird die Art und Weise verändern mit der Teams Software entwickeln und ausliefern – unser erster kühner Schritt in Richtung KI-gestützte DevSecOps.","https://about.gitlab.com/blog/meet-gitlab-duo-workflow-the-future-of-ai-driven-development","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Lerne GitLab Duo Workflow kennen – die Zukunft der KI-gestützten Entwicklung\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David DeSanto, Chief Product Officer, GitLab\"}],\n        \"datePublished\": \"2024-06-27\",\n      }\n                  ",{"title":1052,"description":1053,"authors":1057,"heroImage":703,"date":1058,"body":1059,"category":14,"tags":1060},[951],"2024-06-27","Stell dir vor, Software würde sich selbst schreiben. Das hört sich jetzt zunächst einmal nach Zukunftsmusik an, aber mit den kontinuierlichen Fortschritten bei LLMs und den Neuerungen, die GitLab in einer einzigen DevSecOps Plattform zusammen gefasst hat, rückt diese Zukunft in greifbare Nähe. Während unseres [GitLab 17 Launch-Event](https://about.gitlab.com/de-de/seventeen/) haben wir GitLab Duo Workflow angekündigt, einen autonomen KI-Agenten, der die Art und Weise verändern wird, wie Teams Software entwickeln, sichern, bereitstellen und überwachen.\n\nGitLab Duo Workflow geht über die derzeitigen reaktiven, prompt-basierten KI-Assistenten hinaus. Es ist ein autonomes Teammitglied, das aktiv dazu beiträgt, jeden Aspekt deines SDLC zu optimieren. Workflow zeichnet sich durch die Nutzung des einheitlichen Datenspeichers von GitLab aus, der alle relevanten Daten, Projekte, Repositories und Dokumentationen nahtlos miteinander verknüpft. Dadurch wird Workflow zu einem intelligenten, immer verfügbaren Agenten, der deine Projekte ständig überwacht, potenzielle Probleme in der Produktivumgebung vorhersieht, Sicherheitslücken automatisch identifiziert und behebt, deine Anwendungen für Spitzenleistungen optimiert und die Einarbeitung neuer Teammitglieder durch den schnellen Aufbau individueller Remote-Entwicklungsumgebungen vereinfacht.\n\nKI verändert wie sichere Software erstellt, gepflegt, aktualisiert, bereitgestellt und überwacht wird, und ermöglicht es Unternehmen, mehr Software als je zuvor zu entwickeln. GitLab Duo Workflow ist unser erster mutiger Schritt in Richtung KI-gestützter DevSecOps. Unser Ziel ist es, Entwickler(innen) dazu zu befähigen, sich auf Problemlösungen, Innovationen und Wertschöpfung auf höchster Ebene zu konzentrieren, während [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) repetitive Aufgaben und Optimierungen im Hintergrund erledigt.\n\n## Die Vision für GitLab Duo Workflow\nMit GitLab Duo Workflow arbeiten wir hochkonzentriert an mehreren wichtigen Anwendungsfällen, um den Prozess der Softwareentwicklung von Anfang bis Ende zu automatisieren und zu optimieren.\n### 1. Automatisierte Entwicklung\n\nDirekt in der IDE ermöglicht GitLab Duo Workflow die Planung und Priorisierung von Aufgaben, die auf einzelne Projekte und definierte Unternehmensprozesse zugeschnitten sind. Anhand der Anforderungen eines bestimmten Workitems (sei es ein Epic, ein Issue oder ein Task) erstellt Workflow einen Implementierungsplan, den die Entwickler(innen) überprüfen und individuell anpassen können. Dann arbeitet sich Workflow durch den Plan und generiert oder schreibt den Code um, um die definierten Anforderungen zu erreichen und zu erfüllen. Workflow bedient sich bei der Umsetzung eines [GitLab Remote Development Workspaces](https://about.gitlab.com/blog/quick-start-guide-for-gitlab-workspaces/), der es ermöglicht, Codeänderungen sicher zu bewerten, zu schreiben und zu testen. Das bedeutet auch, dass genau der Code produziert wird, der sowohl die Anforderungen erfüllt als auch alle Tests der CI-Pipeline, einschließlich Sicherheitsscans, besteht. Wenn die Pipeline fehlschlägt, kümmert sich Workflow automatisch um die Behebung der Probleme und stellt sicher, dass nur qualitativ hochwertiger Code, der den Standards deines Unternehmens entspricht, erstellt und für deine Projekte verwendet wird.\n\nSobald die Pipeline fertig ist, erstellt Workflow automatisch einen Merge Request mit den Codeänderungen und durchläuft die Approvalprozesse für Merge Requests, einschließlich der Kommunikation mit Code-Prüfer(inne)n oder -Verantwortlichen. Du kannst Workflow sogar damit beauftragen, deinen Code zu überprüfen und deine Merge Requests zu kommentieren, so wie es auch menschliche Code-Prüfer(innen) tun würden. Das Beste ist, dass Workflow diese Vorschläge sogar für dich umsetzt, wenn du das möchtest. Und das ist erst der Anfang.\n\n### 2. Intelligente kontinuierliche Verbesserung\nGitLab Duo Workflow analysiert deine Codebase in Echtzeit und schlägt dir architektonische Optimierungen für mehr Effizienz, Leistung und Kosteneinsparungen vor. Außerdem identifiziert es proaktiv Möglichkeiten für Code-Refactoring, um die Skalierbarkeit zu verbessern und technical debt zu beseitigen, indem es den Entwickler(inne)n Änderungen vorschlägt oder sie automatisch in einer Sandbox-Umgebung implementiert. Darüber hinaus verwaltet Workflow die Cloud-Ressourcen dynamisch, um eine Überbelegung zu verhindern und sicherzustellen, dass deine Anwendungen stets ihre Leistungsziele erreichen.\n\n### 3. Proaktive Sicherheit und Konformität\nSicherheit und Compliance Konformität sind für jedes Unternehmen von höchster Priorität. GitLab Duo Workflow fordert Entwickler(innen) automatisch und in Echtzeit auf, Patches anzuwenden, unsicheren Code zu überarbeiten und sich an neue Bedrohungen anzupassen. Es bewertet außerdem kontinuierlich die Sicherheitsrisiken deiner Anwendungen und Produktionsumgebungen und unterstützt dich bei der Implementierung von Maßnahmen zur Risikominderung.\n\n### 4. Selbstoptimierende Leistung\nGitLab Duo Workflow verfügt über ausgeklügelte Feedbackschleifen für kontinuierliches Lernen und Verbesserung. Durch die Analyse von Daten aus Überwachungstools, Benutzerinteraktionen und Geschäftsergebnissen wird die Sicht auf deine Codebase kontinuierlich verbessert, um sicherzustellen, dass deine Anwendungsarchitekturen immer auf deine Geschäftsanforderungen abgestimmt sind. Wie alle KI-Systeme wird sich auch Workflow ständig verbessern, indem es seine eigenen Fehler erkennt und korrigiert, während es lernt, ein Partner für dein Unternehmen zu sein.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://player.vimeo.com/video/967982166?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allowfullscreen=\"true\" title=\"GitLab Duo Workflow the future of AI-driven DevSecOps\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Die Zukunft der KI ist jetzt\nGitLab Duo Workflow ist ein großer Schritt nach vorn: weg von der KI, die ständig von Menschen gesteuert werden muss, hin zu einer KI, die eigenständig Entwicklungsworkflows und -prozesse vorantreibt und bei Bedarf menschliche Hilfe in Anspruch nimmt. Mit der einheitlichen, KI-gestützten Schnittstelle von GitLab, die den DevSecOps-Lebenszyklus abdeckt, können Unternehmen eine neue Generation von KI-gestützten Anwendungen mit beispielloser Geschwindigkeit, Effizienz und Innovation erstellen und dabei die höchsten Sicherheits- und Compliance-Standards einhalten. Ohne Kompromisse.\n\nBegleite uns, während wir die Grenzen dessen, was mit KI in der Softwareentwicklung möglich ist, immer weiter verschieben. Lasst uns gemeinsam die Zukunft der KI-gestützten DevSecOps angehen und das volle Potenzial eurer Teams und Unternehmen ausschöpfen.\n\n> Wenn du neugierig auf KI-gestützte DevSecOps bist und diese Entwicklung miterleben möchtest, [melde dich für unsere GitLab Duo Workflow-Warteliste an](https://forms.gle/5ppRuNVb8LwSPNVJA) und erhalte Zugang zum Pre-Release-Programm. ",[683,686,976,684,836],{"slug":1062,"featured":93,"template":692},"meet-gitlab-duo-workflow-the-future-of-ai-driven-development","content:de-de:blog:meet-gitlab-duo-workflow-the-future-of-ai-driven-development.yml","Meet Gitlab Duo Workflow The Future Of Ai Driven Development","de-de/blog/meet-gitlab-duo-workflow-the-future-of-ai-driven-development.yml","de-de/blog/meet-gitlab-duo-workflow-the-future-of-ai-driven-development",{"_path":1068,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1069,"content":1075,"config":1081,"_id":1083,"_type":16,"title":1084,"_source":18,"_file":1085,"_stem":1086,"_extension":21},"/de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd",{"title":1070,"description":1071,"ogTitle":1070,"ogDescription":1071,"noIndex":6,"ogImage":1072,"ogUrl":1073,"ogSiteName":674,"ogType":675,"canonicalUrls":1073,"schema":1074},"Entwicklung von GitLab Duo: mit KI und Ursachenanalyse zur Problembehebung bei CI/CD-Pipelines","Entdecke, wie wir die Ursachenanalyse mit KI aufgepeppt haben, um fehlerhafte CI/CD-Pipelines wieder zum Laufen zu bringen. Dabei erwarten dich Beispiele und Übungen, die du selbst ausprobieren kannst.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097321/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750097321081.png","https://about.gitlab.com/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: mit KI und Ursachenanalyse zur Problembehebung bei CI/CD-Pipelines\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Rutvik Shah\"},{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"}],\n        \"datePublished\": \"2024-06-06\",\n      }",{"title":1070,"description":1071,"authors":1076,"heroImage":1072,"date":1078,"body":1079,"category":14,"tags":1080},[1077,972],"Rutvik Shah","2024-06-06","___Generative KI bedeutet einen monumentalen Wandel in der Softwareindustrie, da sie die Entwicklung, die Sicherheit und den Betrieb von Software vereinfacht. Unsere neue Blog-Reihe, von unseren Produkt- und Entwicklungsteams, gibt einen Einblick darin, wie wir die KI-Funktionalitäten entwickeln, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und erfahre, wie diese DevSecOps-Teams dabei helfen werden, bessere Ergebnisse für Kund(inn)en zu erzielen.___\n\nHattest du schon einmal eine defekte [CI/CD-Pipeline](https://about.gitlab.com/topics/ci-cd/benefits-continuous-integration/) und musstest deinen DevSecOps-Workflow unterbrechen oder sogar das Deployment verzögern, um die Ursache herauszufinden? Wenn bei der Entwicklung von Software etwas schief läuft, müssen Entwickler(innen) traditionellerweise die Fehler selbst beheben, Logdatei über Logdatei durchforsten und oft viele Behebungsversuche durchführen. Mit der [Ursachenanalyse von GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), die Teil unserer Suite aus KI-Funktionen ist, hat das Rätselraten nun ein Ende, denn diese findet für dich die Ursache einer defekten CI/CD-Pipeline. In diesem Artikel erfährst du, was die Ursachenanalyse ist und wie du die KI-Funktionen von GitLab Duo in deinen DevSecOps-Workflow einbauen kannst.\n\n> Entdecke die Zukunft von KI-gestützter Softwareentwicklung mit unserem virtuellen Launch-Event zu GitLab 17. [Jetzt ansehen!](https://about.gitlab.com/de-de/seventeen/)\n\n## Was ist eine Ursachenanalyse?\n\nDie Ursachenanalyse von GitLab Duo ist eine KI-Funktionalität, die dir dabei hilft, die Grundursache eines fehlerhaften CI/CD-Joblauf herauszufinden. Sie analysiert die Protokolle und schlägt dir dann Möglichkeiten zur Behebung vor. Während die Ursachenanalyse oft im Incident Management angesiedelt ist, sind ihre Workflows und die Fehlersuche Teil eines jeden DevSecOps-Workflows. Ops-Teams, Adminstrator(inn)en und Plattformentwickler(innen) stehen durch Bereitstellungsprobleme, die durch Infrastructure as Code (IaC) entstehen, Kubernetes- und GitOps-Probleme oder durch die lange Nachverfolgung von Stacktraces und Untersuchung von Pipeline-Fehlschlägen vor Herausforderungen.\n\nMit der Ursachenanalyse von GitLab Duo nutzen alle dasselbe Interface. Mit Hilfe von KI werden Fehler zusammengefasst, analysiert und Lösungsvorschläge gemacht, damit Unternehmen schneller sichere Software veröffentlichen können.\n\nEine Pipeline kann aus verschiedensten Gründen Fehler aufweisen, darunter Syntax-Fehler im Code, fehlende Abhängigkeiten, auf denen die Pipeline basiert, Testfehler während des Build-Vorgangs, Zeitüberschreitungen bei Kubernetes- und IaC-Bereitstellungen sowie zahlreiche weitere Probleme. Wenn solche Probleme auftreten, liegt es in der Verantwortung von allen, die durch die Pipeline erstellten Logs genauestens zu überprüfen. Bei der Überprüfung der Logs wird dann der detaillierte Output untersucht, um spezifische Fehlschläge aufzudecken und die Ursache der defekten Pipeline zu finden. Die folgende Pipeline hat beispielsweise mehrere fehlgeschlagene Jobs, die untersucht und repariert werden müssen.\n\n![Bild mit mehreren Job-Ausfällen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097332601.png)\n\nEs kann unterschiedlich lange dauern, diese Probleme zu beheben. Das hängt zum Großteil von Faktoren wie den folgenden ab:\n- Wie vertraut die Entwickler(innen) mit dem Projekt sind\n- Ihr Erfahrungsniveau beim Umgang mit ähnlichen Problemen\n- Ihr allgemeines Kenntnislevel in der Fehlerbehebung im Kontext der Pipeline.\n\nDie manuelle Analyse kann unglaublich herausfordernd und zeitaufwändig sein, da die Logs aus Anwendungsprotokollen und Systemmeldungen mit einer Vielzahl an Fehlerquellen bestehen. Die typische Behebung einer Pipeline besteht aus mehreren Iterationen und Kontextwechseln. Aufgrund der Komplexität und der unstrukturierten Natur der Protokolle ist dies ein idealer Bereich, in dem generative KI die Arbeit beschleunigen kann. Durch den Einsatz von KI können Fehler in einer Pipeline signifikant schneller erkannt und behoben werden. Außerdem ist weniger Expertise für die Behebung einer Pipeline wie im obigen Beispiel erforderlich.Sieh dir die Ursachenanalyse von GitLab Duo in Aktion an:\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n\n \u003Ciframe src=\"https://www.youtube.com/embed/sTpSLwX5DIs?si=J6-0Bf6PtYjrHX1K\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\n\u003C/figure>\n\n\u003C!-- blank line -->\n\n## Wie funktioniert die Ursachenanalyse?\n\nBei der [Ursachenanalyse](https://docs.gitlab.com/ee/user/ai_experiments.html#root-cause-analysis) wird ein Teil des CI/CD-Stacktraces an ein [GitLab-KI-Gateway](https://docs.gitlab.com/ee/architecture/blueprints/ai_gateway/) weitergeleitet. GitLab stellt sicher, dass der weitergeleitete Teil in die Limitierungen des umfangreichen Sprachmodells (LLM) passt und erstellt einen vorgefertigten Prompt, um herauszufinden, warum der Job fehlgeschlagen sein könnte. Der Prompt weist das LLM außerdem an, ein Beispiel aufzuzeigen, wie ein(e) Benutzer(in) den fehlerhaften Job beheben könnte. Nachfolgend sind zwei Beispielszenarien, in denen die Ursachenanalyse hilfreich sein kann.\n\n#### 1. Analyse eines Abhängigkeitsfehlers in Python\n\nEine Python-Anwendung kann zusätzliche Bibliotheken mit Funktionen importieren, die nicht in der Standardbibliothek enthalten sind. Das Projekt [Ursachenanalyse – Python-Konfiguration](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-python-config) implementiert eine Anwendung, die die Konfiguration parst und eine SQLite-Datenbank initialisiert, wobei beide auch ohne zusätzlich installierte Abhängigkeiten funktionieren. Das Beispiel verwendet Best Practices in CI/CD mit einer Python-Umgebung sowie Cashing. Zuletzt wurde nun ein Redis-Caching-Client hinzugefügt, und jetzt schlägt der CI/CD-Build aus irgendeinem Grund fehl. \n\nDurch die Ursachenanalyse erfährst du sofort, dass `ModuleNotFoundError` bedeutet, dass das Modul tatsächlich nicht in der Python-Umgebung installiert ist. GitLab Duo schlägt außerdem einen Fix vor: Installiere das Redis-Modul über den PIP-Paketmanager.\n\n![Bild mit „modulenotfounderror“ und Lösungsvorschlag von GL Duo](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097332602.png)\n\nDie fehlerhafte Pipeline kann [hier](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-python-config/-/jobs/6992716398) eingesehen werden. \n\nDas Ergebnis der Ursachenanalyse gibt eine Zusammenfassung des Problems aus, das offensichtlich ein Fehler mit einem fehlenden `redis`-Modul ist. Versuchen wir nun, das Problem zu beheben, indem das `redis`-Modul installiert wird. Du kannst entweder `pip install redis` im Abschnitt `script` des CI/CD-Jobs aufrufen oder einen generellen Weg über die Datei `requirements.txt` wählen. Letztere ist nützlich für eine Single Source of Truth (einzige Quelle der Wahrheit) für Abhängigkeiten, die in der Entwicklungsumgebung und in CI/CD-Pipelines installiert wurden.\n\n```yaml\ntest:\n  extends: [.python-req]\n  stage: test \n  before_script:\n    # [🦊] hint: Root cause analysis. # Solution 1: Install redis using pip\n    - pip install redis\n    # Solution 2: Add redis to requirements.txt, use pip\n    - pip install -r requirements.txt \n\n  script:\n    - python src/main.py\n```\n\nNachdem du die fehlende Python-Abhängigkeit behoben hast, schlägt der CI/CD-Job erneut fehl. Führe erneut eine Ursachenanalyse durch, um zu erfahren, dass kein Redis-Service den Job ausführt. Wechsle zum GitLab Duo Chat und gib den Prompt `How to start a Redis service in CI/CD` ein, um zu erfahren, wie du das Attribut `services` im CI/CD-Job konfigurierst.\n\n![Zeigt die Aufforderung zum Starten eines Redis-Dienstes](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097333/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097332602.png)\n\nÄndere `.gitlab-ci.yml` mit dem Job `test` und gib unter service den Dienst `redis` an.\n\n```yaml\ntest:\n  extends: [.python-req]\n  stage: test \n  before_script:\n    # [🦊] hint: Root cause analysis.\n    # Solution 1: Install redis using pip\n    - pip install redis\n    # Solution 2: Add redis to requirements.txt, use pip\n    - pip install -r requirements.txt \n\n  script:\n    - python src/main.py\n\n  # Solution 3 - Running Redis\n  services:\n    - redis\n```\n\nWenn der Redis-Server ausgeführt wird, kannst du die Python-Anwendung erfolgreich ausführen und die Ausgabe im CI/CD-Log sehen.\n\n![Ausgabe der Python-Anwendung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097332603.png)\n\nDie Lösung kann auch im Unterordner in [/solution](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-python-config/-/tree/main/solution?ref_type=heads) eingesehen werden.\n\n**Tipp:** Du kannst den [GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) auch bitten, zukünftige Probleme zu verfolgen:\n\n```markdown\nHow to lint Python code? Which tools are recommended for CI/CD.\nHow to pin a package version in Python requirements file?\t\nWhat are possible ways that this exception stacktrace is triggered in the future?\nAre there ways to prevent the application from failing?\n``` \n\nDas nächste Beispiel ist fortgeschrittener und umfasst mehrere Probleme.\n\n#### 2. Fehlende Go-Laufzeit analysieren\n\nCI/CD-Jobs können in Containern ausgeführt werden, die über das Attribut `image` konfiguriert werden. Wenn der Container keine Programmiersprachen-Laufzeit bereitstellt, schlagen die ausgeführten Kommandos in `script`, die auf die Binärdatei `go` referenzieren, fehl. Beispielsweise muss dann die Fehlermeldung `/bin/sh: eval: line 149: go: not found` verstanden und behoben werden. \n\nWenn der Befehl `go` nicht im Laufzeit Kontext des Containers gefunden wird, kann dies mehrere Gründe haben:\n\n1. Der Job verwendet ein minimales Container-Image, z. B. `alpine`, und die Go-Laufzeit wurde nicht installiert.\n1. Der Job verwendet das falsche Standard-Container-Image, z. B. das oben in der CI/CD-Konfiguration angegebene oder das Schlüsselwort `default`.\n1. Der Job verwendet kein Container-Image, sondern den Shell Executor. Auf dem Host-Betriebssystem ist die Go-Laufzeit nicht installiert oder ist anderweitig defekt/nicht konfiguriert.\n\nDas Projekt [Ursachenanalyse – Go GitLab Release Fetcher](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-go-gitlab-release-fetcher) bietet ein Übungsprojekt zur Analyse und Behebung von CI/CD-Problemen mit einer in Go geschriebenen GitLab-Release-Fetcher-Anwendung. Die CI/CD-Jobs `build` und `docker-build` schlagen fehl. Für die Behebung des Problems sind verschiedene Voraussetzungen erforderlich: Du musst verstehen, warum die Go-Laufzeit nicht installiert ist, und etwas über die Syntax `Dockerfile` erfahren.\n\n![Screenshot zeigt den fehlgeschlagenen Job „Change Docker Label“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097332603.png)\n\nDas [`solution/`-Verzeichnis](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-go-gitlab-release-fetcher) bietet nach der Ursachenanalyse zwei mögliche Lösungen.\n\n## Probiere die Ursachenanalyse aus\n\nDie folgenden Szenarien kannst du verwenden, um die Ursachenanalyse auszuprobieren.\n\n- Wenn du auf Kubernetes-Bereitstellungsfehler oder Zeitüberschreitungen stößt. \n\n- Wenn OpenTofu- oder Terraform-IAC-Pipelines die Cloud-Ressourcen nicht bereitstellen können.\n\n- Wenn das Ansible-Playbook mit einem kryptischen Berechtigungsfehler in CI/CD fehlschlägt.\n\n- Wenn der Java Stacktracer 10 Seiten lang ist.\n\n- Mit einem Shell-Skript, das einen Ausführungsfehler provoziert.\n\n- Wenn ein Perl-Skript in einer Zeile fehlschlägt, die die einzige Zeile im Skript ist.\n\n- Wenn der CI/CD-Job eine Zeitüberschreitung aufweist und nicht klar ist, welcher Abschnitt diese verursacht.\n\n- Wenn eine Zeitüberschreitung der Netzwerkverbindung erreicht wird und du denkst, dass es kein DNS sein kann.\n\n### Wie geht es mit der Ursachenanalyse von GitLab Duo in Zukunft weiter?\n\nWir wollen unseren Nutzer(inne)n langfristig helfen, ihre Pipelines in weniger Iterationen und schneller zu reparieren. Die Ursachenanalyse wird dabei in GitLab Duo Chat, unserem KI Assistenten, geöffnet und zeigt die Antwort dort. Benutzer(innen) können die Empfehlung dann direkt verwenden oder weiter mit dem Chat agieren, indem sie spezifische, weiterführende Fragen stellen (z. B. spezifische Fixes für eine bestimmte Programmiersprache) oder indem sie je nach Ursache nach alternativen Lösungen fragen.\n\nZum Beispiel ist hier die Ursachenanalyse für einen fehlgeschlagenen Job:\n\n![Antwort auf die Grundursachenanalyse](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097332603.png)\n\nBenutzer(innen) können Folgefragen stellen, die auf der von der KI generierten Antwort basieren.\n\n- Ich möchte kein eigenes Docker Image erstellen. Bitte erkläre mir andere Möglichkeiten, das Problem zu beheben.\n\n- Ich habe keinen Zugriff auf die Docker-Image-Erstellung. Es sieht so aus, als würde die Go-Binärdatei fehlen. Gibt es alternative Images, die du vorschlagen kannst?\n\nGitLab führt außerdem Qualitäts-Vergleiche für die erstellten Antworten durch, um das Nutzererlebnis langfristig zu verbessern.\n\nWeitere Informationen findest du in unserem [Epic zur Ursachenanalyse](https://gitlab.com/groups/gitlab-org/-/epics/13080). Wir würden uns auch über dein Feedback zu dieser Funktionalität freuen. Bitte hinterlasst dafür einen Kommentar in unserem [Feedback-Ticket zur Ursachenanalyse](https://gitlab.com/groups/gitlab-org/-/epics/13872).\n\n## Erste Schritte mit der Ursachenanalyse\n\nIn unserer [Dokumentation](https://docs.gitlab.com/ee/user/ai_experiments.html#root-cause-analysis) findest du Informationen dazu, wie du die Funktion als GitLab-Ultimate-Kund(inn)en aktivieren kannst. Außerdem ist die Ursachenanalyse von GitLab Duo bald in GitLab Self-Managed und GitLab Dedicated verfügbar.\n\nBist du kein(e) GitLab-Ultimate-Kunde/Kundin? Starte jetzt [deine 30-tägige kostenlose Testversion](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial). ",[683,688,976,686,685],{"slug":1082,"featured":93,"template":692},"developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd","content:de-de:blog:developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd.yml","Developing Gitlab Duo Blending Ai And Root Cause Analysis To Fix Ci Cd","de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd.yml","de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd",{"_path":1088,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1089,"content":1095,"config":1100,"_id":1102,"_type":16,"title":1103,"_source":18,"_file":1104,"_stem":1105,"_extension":21},"/de-de/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code",{"title":1090,"description":1091,"ogTitle":1090,"ogDescription":1091,"noIndex":6,"ogImage":1092,"ogUrl":1093,"ogSiteName":674,"ogType":675,"canonicalUrls":1093,"schema":1094},"Entwicklung von GitLab Duo: Sicheres und gründliches Testen von KI-generiertem Code","Erfahre Schritt für Schritt, wie du die Zuverlässigkeit und Sicherheit von KI-generiertem Code mithilfe von GitLab Duo und GitLab Pages (einschließlich Codebeispielen und Prompts) verbessern kannst.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097183/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750097183481.png","https://about.gitlab.com/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: Sicheres und gründliches Testen von KI-generiertem Code\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David O'Regan\"}],\n        \"datePublished\": \"2024-05-30\",\n      }\n                  ",{"title":1090,"description":1091,"authors":1096,"heroImage":1092,"date":1097,"body":1098,"category":14,"tags":1099,"updatedDate":680},[1039],"2024-05-30","___Generative KI bedeutet einen monumentalen Wandel in der Softwareentwicklungsbranche, da sie die Entwicklung, die Sicherheit und den Betrieb von Software vereinfacht. Die neue Blog-Reihe unserer Produkt- und Entwicklungsteams zeigt, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und erfahre, wie diese DevSecOps-Teams dabei helfen, bessere Ergebnisse für ihre Kund(inn)en zu erzielen.___\n\n## Inhaltsverzeichnis\n\n- [Herausforderungen bei der Verwendung von KI-generiertem Code](#herausforderungen-bei-der-verwendung-von-ki-generiertem-code)\n- [Der Ansatz von GitLab für die Sicherheit und das Testen von KI](#der-ansatz-von-gitlab-für-die-sicherheit-und-das-testen-von-ki)\n  - [1. Ein neues Projekt auf GitLab.com erstellen](#1.-ein-neues-projekt-auf-gitlab.com-erstellen)\n  - [2. GitLab Duo-Codevorschläge aktivieren](#2.-gitlab-duo-codevorschläge-aktivieren)\n  - [3. Einen Flask Webserver erstellen](#3.-einen-flask-webserver-erstellen)\n  - [4. Tests mit GitLab Duo generieren](#4.-tests-mit-gitlab-duo-generieren)\n  - [5. Probleme mit KI-generiertem Code mithilfe von GitLab Duo Chat identifizieren](#5.-probleme-mit-ki-generiertem-code-mithilfe-von-gitlab-duo-chat-identifizieren)\n  - [6. Testberichte erstellen](#6.-testberichte-erstellen)\n  - [7. Den Testbericht mit GitLab Pages bereitstellen](#7.-den-testbericht-mit-gitlab-pages-bereitstellen)\n  - [8. Testberichte in MR-Widgets einbetten](#8.-testberichte-in-mr-widgets-einbetten)\n- [Fallstudie: Zuverlässigkeit von KI mit Sicherheitsrichtlinien und Scannern](#fallstudie-zuverlässigkeit-von-ki-mit-sicherheitsrichtlinien-und-scannern)\n- [Lege noch heute los](#lege-noch-heute-los)\n- [Lies mehr über die Reihe „Entwicklung von GitLab Duo\"](#lies-mehr-über-die-reihe-„entwicklung-von-gitlab-duo“)\n\nDa KI zunehmend Bestandteil der Softwareentwicklung wird, ist die Gewährleistung der Sicherheit und das gründliche Testen von KI-generiertem Code von größter Bedeutung. Dieser Artikel ist eine Schritt-für-Schritt-Anleitung zur Kombination von [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), unserer Suite von KI-Funktionen zur Unterstützung des DevSecOps-Workflows, und [GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/), um KI-generierten Code zu sichern und gründlich zu testen. Du erfährst, wie du typische Risiken minimieren kannst und wie du automatisch Tests generierst, Code testest und Testberichte erstellst, um die Zuverlässigkeit deines KI-generierten Codes zu verbessern.\n\n## Herausforderungen bei der Verwendung von KI-generiertem Code\n\nKI-generierter Code steht häufig vor folgenden Problemen:\n\n- Nicht übereinstimmende Algorithmen: Es können falsche oder suboptimale Algorithmen generiert werden.\n- Probleme mit Abhängigkeiten: KI-generierter Code kann Abhängigkeiten enthalten, die veraltet oder inkompatibel sind.\n- Sicherheitslücken: KI kann Code mit potenziellen Sicherheitsschwachstellen generieren.\n\nKI-generierter Code hat oft mit Problemen wie nicht übereinstimmenden Algorithmen, Abhängigkeitsproblemen und Sicherheitslücken zu kämpfen. Eine [kürzlich von der Association of Computing Machinery veröffentlichte Studie](https://dl.acm.org/doi/pdf/10.1145/3613904.3642596) zu den Antworten von ChatGPT auf Programmierfragen ergab, dass 52 % der Antworten falsche Informationen enthielten und 77 % zu ausführlich waren. Trotz dieser Mängel bevorzugten die Benutzer(innen) in 35 % der Fälle die umfassenden und gut formulierten Antworten von ChatGPT, wobei sie in 39 % der Fälle sogar Fehlinformationen übersahen. Die Bewältigung dieser Herausforderungen erfordert den Einsatz fortschrittlicher Tools und Frameworks.\n\n## Der Ansatz von GitLab für die Sicherheit und das Testen von KI\n\nGitLab hat eine umfassende Inhaltsstrategie, die sich auf die Integration von Sicherheitsmaßnahmen in den Entwicklungsworkflow konzentriert. Durch die Nutzung von GitLab Duo für die KI-gestützte Codegenerierung und GitLab Pages für die Einbettung von Testberichten können Entwickler(innen) sicherstellen, dass ihr KI-generierter Code sowohl sicher als auch zuverlässig ist.\n\nHier ist eine Schritt-für-Schritt-Anleitung für die Kombination von GitLab Duo und GitLab Pages, um durch die Implementierung eines [Flask-Webservers](https://flask.palletsprojects.com/en/3.0.x/) sicheren und gründlich getesteten KI-generierten Code zu gewährleisten.\n\n### 1. Ein neues Projekt auf GitLab.com erstellen\n\n- Gehe zu [GitLab.com](http://GitLab.com).\n- Klicke auf die Schaltfläche „Neues Projekt“.\n- Wähle „Leeres Projekt erstellen“ aus.\n- Gib einen Projektnamen ein (z. B. AI_Code_Security).\n- Lege die Sichtbarkeitsebene fest (öffentlich, intern oder privat).\n- Klicke auf „Projekt erstellen“.\n\n### 2. GitLab Duo-Codevorschläge aktivieren\n\n- Navigiere zu deinem Projekt.\n- Klicke auf die Schaltfläche „Web IDE“, um die Web IDE zu öffnen.\n- Stelle sicher, dass GitLab Duo-Funktionen wie Codevorschläge und Duo-Chat aktiviert sind. \n- Beginne mit der Programmierung in der [Web IDE](https://docs.gitlab.com/ee/user/project/web_ide/). Während du tippst, liefert GitLab Duo Codevorschläge, die dir helfen, effizienter zu programmieren.\n\n### 3. Einen Flask Webserver erstellen\n\nDu kannst mithilfe des Kommentars im Screenshot unten (grün hervorgehoben) einen Flask Webserver erstellen.\n\n![DGD-Testing – Bild 1](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097192520.png)\n\n### 4. Tests mit GitLab Duo generieren\n\nUnit-Tests sind für die Validierung der Funktionalität des generierten Codes unerlässlich. Verwende den Befehl `/tests` von GitLab Duo, um [Testvorschläge direkt in der Web IDE zu generieren](https://docs.gitlab.com/ee/user/gitlab_duo_chat_examples.html#write-tests-in-the-ide). Dieser Befehl kann mit zusätzlichen Anweisungen angepasst werden, um einen Fokus auf bestimmte Aspekte wie Leistung, Regression oder die Verwendung bestimmter Frameworks zu erreichen.\n\n#### Beispiel für die Verwendung in Web IDE:\n\n- Wähle den Code aus, für den du Tests generieren möchtest.\n- Verwende den Befehl `/tests` und füge bei Bedarf zusätzliche Anweisungen hinzu.\n\n![DGD-Testing – Bild 2](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097192521.png)\n\n### 5. Probleme mit KI-generiertem Code mithilfe von GitLab Duo Chat identifizieren \n\nVerwende GitLab Duo Chat, um KI-generierten Code zu überprüfen und zu optimieren. Wir können zum Beispiel den Code für unseren Flask Webserver auf Sicherheitslücken überprüfen:\n\n```unset\nPrompt: Überprüfe diesen Code auf potenzielle Sicherheitslücken und Abhängigkeitsprobleme.\n\n```\n\n![DGD-Testing – Bild 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097192523.png)\n\nGitLab Duo Chat kann helfen, die Sicherheitslücken im oben gezeigten Code zu identifizieren.\n\n### 6. Testberichte erstellen\nNachdem du deine Tests durchgeführt hast, erstellst du einen Testbericht, der mit GitLab Pages bereitgestellt wird.\n\n```unset\n\nPrompt: Schreibe mir ein Python-Skript, das einen Testbericht erstellt, der mit GitLab Pages bereitgestellt wird.\n\n```\n\n![DGD-Testing – Bild 4](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097192/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097192525.png)\n\nWas passiert hier?\n\n- Das Skript stellt sicher, dass das Verzeichnis test_reports existiert.\n- Es führt die Datei `test_server.py` mit `subprocess.run()` aus und erfasst die Ausgabe.\n- Die Rohausgabe wird in `test_reports/test_output.txt` gespeichert.\nEs wird ein HTML-Bericht erstellt, der die Testausgabe aus Gründen der Lesbarkeit in die `\u003Cpre>`-Tags einbettet und als `test_reports/index.html` gespeichert wird.\n\n### 7. Den Testbericht mit GitLab Pages bereitstellen\n\nVerwende [GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/), um den Testbericht zu hosten und anzuzeigen. Hier ist die Konfiguration für unsere Datei `.gitlab-ci.yml`, um den Testbericht bereitzustellen.\n\n```python\n\nstages:\n  - test\n  - deploy\ntest_job:\n  stage: test\n  script:\n    - python generate_test_report.py\n  artifacts:\n    paths:\n      - test_reports/\npages:\n  stage: deploy\n  script:\n    - mv test_reports public\n  artifacts:\n    paths:\n      - public\n\n ```\n\nBei dieser Konfiguration führt die Phase `test_job` das Python-Skript aus, um den Testbericht zu erstellen. Die Phase `pages` verschiebt das Verzeichnis `test_reports` in den Pfad `public`, wo GitLab Pages den Inhalt bereitstellt.\n\n### 8. Testberichte in MR-Widgets einbetten\n\nDie Einbettung der [Testberichte in MR-Widgets](https://docs.gitlab.com/ee/ci/testing/unit_test_reports.html) bietet einen sofortigen Einblick in die Testergebnisse und gewährleistet Transparenz und Zuverlässigkeit. Dazu kannst du den Testbericht als Artefakt in die Konfiguration deiner CI/CD-Pipeline aufnehmen:\n\n```python\n\nstages:\n  - build\n  - test\n  - deploy\n\nbuild_job:\n  stage: build\n  script:\n    - echo \"Building the project...\"\n    - # Your build commands here\n\ntest_job:\n  stage: test\n  script:\n    - mkdir -p test-reports\n    - python test_server.py > test-reports/results.xml\n  artifacts:\n    when: always\n    reports:\n      junit: test-reports/results.xml\n    paths:\n      - test-reports/results.xml\n\npages:\n  stage: deploy\n  script:\n    - mkdir .public\n    - mv test-reports .public/\n  artifacts:\n    paths:\n      - .public\n\n```\nIndem du den Testbericht als Artefakt einfügst und ihn im Abschnitt „reports“ angibst, zeigt GitLab die Testergebnisse automatisch in den MR-Widgets an, was einen sofortigen Einblick in die Testergebnisse ermöglicht und die Transparenz und Zuverlässigkeit erhöht.\n\n## Fallstudie: Zuverlässigkeit von KI mit Sicherheitsrichtlinien und Scannern\n\nStell dir ein Szenario vor, in dem ein KI-generierter Codeschnipsel eine Abhängigkeit verwendet, die bekannte Sicherheitslücken aufweist. Durch die Verwendung von GitLab Duo und den integrierten Sicherheitsrichtlinien würde diese Abhängigkeit bei der Codeerstellung gekennzeichnet. Das folgende Beispiel wurde von der KI erstellt:\n\n```python\n\nimport os\nfrom flask import Flask, request\n\napp = Flask(__name__)\n\n@app.route('/search')\ndef search():\n    query = request.args.get('query')\n    execute_os_command(query)\n    return 'You searched for: ' + query\n\ndef execute_os_command(command):\n    os.system(command)\n\nif __name__ == '__main__':\n    app.run()\n\n```\n\nDer Suchendpunkt in diesem Beispiel ist anfällig für OS Command Injection. Durch den Einsatz der GitLab-Komponente Statische Anwendungssicherheitstests ([SAST](https://docs.gitlab.com/ee/user/application_security/sast/)) würde diese Sicherheitslücke bereits in der CI/CD-Pipeline entdeckt werden.\n\n#### SAST-Scans integrieren, um Sicherheitslücken zu erkennen\n\nGitLab SAST analysiert deinen Code automatisch auf Sicherheitslücken. So kannst du es in deine `.gitlab-ci.yml`-Datei integrieren, um nach Problemen zu suchen:\n\n```python\n\nstages:\n  - build\n  - test\n  - sast\n  - deploy\n\nbuild_job:\n  stage: build\n  script:\n    - echo \"Building the project...\"\n    - # Your build commands here\n\ntest_job:\n  stage: test\n  script:\n    - python test_server.py > test-reports/results.xml\n  artifacts:\n    when: always\n    reports:\n      junit: test-reports/results.xml\n    paths:\n      - test-reports/results.xml\n\nsast_job:\n  stage: sast\n  script:\n    - echo \"Running SAST...\"\n  artifacts:\n    reports:\n      sast: gl-sast-report.json\n  only:\n    - branches\n\npages:\n  stage: deploy\n  script:\n    - mv test-reports public\n  artifacts:\n    paths:\n      - public\n\n```\n\nIn dieser Konfiguration wird SAST in der Phase `sast_job` ausgeführt, um Sicherheitslücken im Code zu erkennen, und einen Bericht (`gl-sast-report.json`) zu erstellen, der in die Pipeline-Artefakte aufgenommen wird. Durch die Integration von Sicherheitsrichtlinien und robusten Test-Frameworks hilft GitLab Duo Kund(inn)en dabei, sicherzustellen, dass ihr KI-generierter Code sowohl effizient als auch sicher ist.\n\n## Lege noch heute los\nDie Integration von KI in die Softwareentwicklung bringt erhebliche Vorteile, aber auch neue Herausforderungen mit sich. Durch die Verwendung von Tools wie GitLab Duo und GitLab Pages können Entwickler(innen) sicherstellen, dass ihr KI-generierter Code sicher, gut getestet und zuverlässig ist. Erkunde diese Tools noch heute und beteilige dich an der Diskussion über die Verbesserung der Sicherheit und des Testens von KI.\n\n> [Starte noch heute eine 30-tägige Testversion von GitLab Ultimate](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial), um GitLab Duo und GitLab Pages auszuprobieren.\n\n## Lies mehr über die Reihe „Entwicklung von GitLab Duo“\n\n- [Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale/)\n- [Entwicklung von GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n- [Entwicklung von GitLab Duo: Dogfooding unserer KI-Funktionen](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features/)\n",[683,976,688,1020],{"slug":1101,"featured":6,"template":692},"how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code","content:de-de:blog:how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code.yml","How Gitlab Duo Helps Secure And Thoroughly Test Ai Generated Code","de-de/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code.yml","de-de/blog/how-gitlab-duo-helps-secure-and-thoroughly-test-ai-generated-code",{"_path":1107,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1108,"content":1114,"config":1120,"_id":1122,"_type":16,"title":1123,"_source":18,"_file":1124,"_stem":1125,"_extension":21},"/de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features",{"title":1109,"description":1110,"ogTitle":1109,"ogDescription":1110,"noIndex":6,"ogImage":1111,"ogUrl":1112,"ogSiteName":674,"ogType":675,"canonicalUrls":1112,"schema":1113},"Entwicklung von GitLab Duo: Dogfooding unserer KI-Funktionen","Im Rahmen unserer Blog-Reihe zeigen wir mithilfe von Beispielen aus der Praxis, wie wir KI in den Lebenszyklus unserer Softwareentwicklung integrieren und ihren Erfolg anhand von Metriken messen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098360/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098360821.png","https://about.gitlab.com/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: Dogfooding unserer KI-Funktionen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David O'Regan\"}],\n        \"datePublished\": \"2024-05-20\",\n      }\n                  ",{"title":1109,"description":1110,"authors":1115,"heroImage":1111,"date":1116,"body":1117,"category":14,"tags":1118},[1039],"2024-05-20","***Generative KI bedeutet einen monumentalen Wandel in der Softwareentwicklungsbranche, da sie es einfacher macht, Software zu entwickeln, zu sichern und zu betreiben. Unsere neue Blog-Serie von unseren Produkt- und Entwicklungsteams gibt einen Einblick darin, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und erfahre, wie diese DevSecOps-Teams dabei helfen werden, bessere Ergebnisse für Kund(inn)en zu erzielen.***\n\n[GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), unsere Suite von KI-gestützten Funktionen, hat unsere internen technischen Workflows verändert und die Effizienz in unserem gesamten Entwicklungsprozess gesteigert. Da wir völlig überzeugt sind von Dogfooding und Transparenz, möchten wir zeigen, wie unsere Teams täglich KI einsetzen, einschließlich hervorragender Produkte wie GitLab Duo Codevorschläge und GitLab Duo Chat, um Entwicklungsprozesse zu rationalisieren, den manuellen Aufwand zu reduzieren und die Produktivität zu steigern. Du wirst mehr über die Vorteile erfahren, von denen hochtechnische Teams wie das Engineering-Team und auch weniger technische Teams wie das Dokumentations- und das Produktmanagementteam profitiert haben.\n\n> Live-Demo! Entdecke die Zukunft von KI-gesteuerter Softwareentwicklung mit unserer virtuellen Produktpräsentation zu GitLab 17. [Registriere dich noch heute!](https://about.gitlab.com/seventeen/)\n\n## Anwendungsfälle aus der Praxis\n\nUnsere Teams haben die [vielen Funktionen von GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/#features) in ihre täglichen Abläufe integriert. Hier sind einige Beispiele dafür, wie GitLab Duo den verschiedenen Teams bei der Durchführung alltäglicher Aktivitäten hilft.\n\n### Zusammenfassung und Dokumentation\n\n- **Code-Review-Prozess optimieren:** Teammitglied und Backend-Entwicklerin [Gosia Ksionek](https://about.gitlab.com/company/team/#mksionek) zeigt die praktischen Vorteile von KI in ihrem Workflow auf. Zur Optimierung des Code-Review-Prozesses verwendet sie GitLab Duo. Sie nutzt GitLab Duo effektiv, um [Merge Requests zusammenzufassen](https://youtu.be/3SIhe8dgFEc). Dadurch können Codeänderungen einfacher und schneller geprüft werden. Gosia fasst mit GitLab Duo nicht nur Merge Requests zusammen, sondern setzt es auch ein, um [Fragen zur Programmierung zu beantworten](https://www.youtube.com/watch?v=6n0I53XsjTc) und [komplexe Code-Schnipsel zu erklären](https://www.youtube.com/watch?v=3m2YRxa1SCY). So steigert sie ihre Produktivität und kann komplizierte Codebases besser verstehen und verwalten. Anhand dieser Demonstrationen zeigt Gosia, wie GitLab Duo die Effizienz und Klarheit im Entwicklungsprozess deutlich verbessern kann und damit unschätzbar wertvoll für Entwickler(innen) ist.\n\n\u003Ccenter>\n\nSieh dir an, wie Gosia die GitLab Duo Merge Request-Zusammenfassung verwendet:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/3SIhe8dgFEc?si=Q8JG3Ix3K_THhbpv\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nSieh dir an, wie Gosia GitLab Duo verwendet, um Fragen zur Programmierung zu beantworten: \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/6n0I53XsjTc?si=LA9VBHrgXpfJImSL\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nSieh dir an, wie Gosia mit GitLab Duo komplexe Code-Schnipsel erklärt:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/3m2YRxa1SCY?si=oms3szKwZoz-4yeq\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n\u003C/center>\n\n- **Kommentar-Threads zusammenfassen:** [Bartek Marnane](https://about.gitlab.com/company/team/#bmarnane), Vice President of Expansion Software Development, fasst mit GitLab Duo lange Kommentar-Threads kompakt zusammen und stellt dabei sicher, dass alle relevanten Details bei der Aktualisierung der Ticketbeschreibungen erfasst werden.\n\n- **Neue Dokumentation erstellen:** [Taylor McCaslin](https://about.gitlab.com/company/team/#tmccaslin), Group Manager, Product – Data Science Section, hat GitLab Duo genutzt, um [für GitLab Duo selbst neue Dokumentation zu erstellen](https://docs.gitlab.com/ee/user/ai_features.html). Dies ist ein Beispiel für einen Meta-Anwendungsfall, der die Klarheit und Konsistenz verbessert und die Zeit für die Dokumentation neuer Funktionen erheblich reduziert.\n\n- **Versionshinweise erstellen:** [Amanda Rueda](https://about.gitlab.com/company/team/#amandarueda), Senior Product Manager des Produktplanungsteams, verwendet GitLab Duo, um [kurze, wirkungsvolle Zusammenfassungen für Versionshinweise zu erstellen](https://gitlab.com/groups/gitlab-org/-/epics/10267) und dabei die Änderungen und deren Wert für die Benutzer(innen) hervorzuheben. Durch die Verwendung gut formulierter Prompts wie den folgenden stärkt Amanda ihren Workflow und stellt sicher, dass jeder Versionshinweis klar, prägnant und benutzerorientiert ist. Dadurch werden die gesamte Kommunikation und das Benutzererlebnis verbessert:\u003Cbr>\u003Cbr>\n*„Bitte erstelle eine Zusammenfassung dieser Änderung in zwei Sätzen, die für unsere Versionshinweise verwendet werden kann. Der Ton sollte umgangssprachlich sein und in der zweiten Person verfasst werden. Die Zusammenfassung sollte eine Beschreibung des Problems oder der Änderung enthalten und mit dem Wert verbunden sein, den wir für euch, die Benutzer(innen), schaffen.“*\n\u003Cbr>\u003Cbr>\n\n- Hier sind einige Beispiele für Versionshinweise, die gemeinsam mit GitLab Duo erstellt wurden:\n  - [Erweiterte Optionen zum Sortieren eurer Roadmap](https://gitlab.com/gitlab-org/gitlab/-/issues/460492)\n  - [Jetzt Ticketübersicht-Klarheit mit Meilenstein und Iteration](https://gitlab.com/gitlab-org/gitlab/-/issues/25758)\n  - [Design-Management-Funktionen auf Produktteams erweitert](https://gitlab.com/gitlab-org/gitlab/-/issues/438829)\n\n- **Optimierung der Navigation auf der Seite des Dokumentationsteams:** [Suzanne Selhorn](https://about.gitlab.com/company/team/#sselhorn), Teammitglied und Technische Redakteurin, setzte GitLab Duo ein, um [die linke Navigationsseite der Dokumentationsabteilung zu optimieren](https://docs.gitlab.com/ee/user/get_started/get_started_projects.html). Dazu stellte sie eine workflowbasierte Reihenfolge der Seiten bereit. Suzanne stellte GitLab Duo eine Liste von Funktionen zur Verfügung, womit die optimale Reihenfolge generiert und die linke Navigation entsprechend aktualisiert wurde. GitLab Duo hat auch einen Entwurf der Dokumentation für die [Ersten Schritte](https://docs.gitlab.com/ee/user/get_started/get_started_planning_work.html) viel schneller erstellt, als wenn Suzanne mit traditionellen, manuellen Methoden arbeiten würde.\n\n### Zielsetzung und Teamausrichtung\n\n- **Entwerfen und Verfeinern von OKRs:** [François Rosé](https://about.gitlab.com/company/team/#francoisrose), Engineering Manager, Entwicklung: Code-Review-Backend, betrachtet [GitLab Duo Chat](https://about.gitlab.com/blog/gitlab-duo-chat-now-generally-available/) als unschätzbar wertvoll für den Entwurf und die Verfeinerung von OKRs. Indem er Ziele klarer und effektiver formuliert, verbessert François die Zielsetzung und die Ausrichtung des Teams. Mit Chat stellt François sicher, dass alle OKRs präzise, umsetzbar und auf die Ziele des Teams ausgerichtet sind. Dadurch werden die Gesamtleistung und der Zusammenhalt des Teams verbessert. Hier ist ein Beispiel für einen Prompt, den er verwendet:\u003Cbr>\u003Cbr>\n\n    *„Hier ist ein OKR, das ich erstellen möchte:*\n\n    *Ziel: Rückblick auf Retrospektiven, um ein erfolgreiches Team zu fördern*\n\n    *Schlüsselergebnis: Messe die rückwirkende Zufriedenheit von 100 % der Teammitglieder*\n\n    *Schlüsselergebnis: Identifiziere 3 Verbesserungen für die asynchronen Retrospektiven*\n\n    *Schlüsselergebnis: Setze 1 Verbesserung um*\n\n    *Bitte stelle direktes Feedback bereit, wie die Formulierung dieses Ziels und dieser Schlüsselergebnisse verbessert werden können.“*\n\u003Cbr>\u003Cbr>\n\n- **Optimierte Einstellungs- und Rekrutierungsprozesse:** Sieh dir Chat in Aktion an, wie die Funktion [Denys Mishunov](https://about.gitlab.com/company/team/#dmishunov), Teammitglied und Frontend Engineer, dabei geholfen hat, einen klaren und prägnanten Text für [die Aktualisierung der E-Mail-Vorlage für technische Bewerber(innen)](https://gitlab.com/gitlab-com/people-group/hiring-processes/-/merge_requests/2165#note_1904898688) zu formulieren. Sieh dir an, wie das Team bei der Verbesserung der Kommunikation zusammenarbeitet, um so sicherzustellen, dass die Bewerber(innen) alle notwendigen Informationen mithilfe eines Merge Request erhalten. Dieses Beispiel zeigt die praktische Anwendung von KI-Tools zur Verbesserung der Kommunikationsprozesse innerhalb des Einstellungsworkflows.\n\n### Reaktion auf Vorfälle und Konfiguration\n- **Zusammenfassen von Produktionsvorfällen:** [Steve Xuereb](https://about.gitlab.com/company/team/#sxuereb), Site Reliability Engineer im Team, verwendet GitLab Duo, um Produktionsvorfälle zusammenzufassen und detaillierte Vorfall-Reviews zu erstellen und so den Dokumentationsprozess zu optimieren.\n\n- **Boilerplate für ‚.gitlab-ci.yml‘-Dateien erstellen:**  Steve verwendet Chat auch, um eine Boilerplate für ‚.gitlab-ci.yml‘ -Dateien zu erstellen, was seinen Workflow erheblich beschleunigt hat. [Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) dient als wertvoller Partner für Ideenvorschläge. Darüber hinaus bietet [Code-Erklärung](https://docs.gitlab.com/ee/user/ai_features.html#code-explanation) detaillierte Antworten, die bei Vorfällen hilfreich sind und seine Produktivität und sein Verständnis der Codebase verbessern.\n\n### Codegenerierung und Tests\n- **Full-Stack-Entwicklung:** [Peter Hegman](https://about.gitlab.com/company/team/#peterhegman), Senior Frontend Engineer, hat [Codevorschläge für seine JavaScript- und Ruby-Entwicklung](https://gitlab.com/gitlab-org/gitlab/-/issues/435783#note_1731321963) verwendet. Dies zeigt, dass Codevorschläge zu einem leistungsstarken Tool für Entwickler(innen) bei technischen Fullstacks geworden sind. \n\n- **Generieren von Python-Skripten:** Denys hat [ein Experiment mit GitLab Duo für eine nicht zu GitLab gehörende Aufgabe](https://gitlab.com/gitlab-org/ai-powered/ai-framework/ai-experimentation) durchgeführt. Dieses Beispiel verdeutlicht die Flexibilität und den Nutzen unserer KI-Tools über typische Softwareentwicklungsaufgaben hinaus.\n\n\u003Ccenter>\nSieh dir an, wie Denys mit GitLab Duo Python-Skripte generiert, um Inhaltsdaten abzurufen und lokal zu speichern:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/30ZTtk4K5yU?si=p5ZcFLg6dTZL5gFE\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n\u003C/center>\n\n### Forschung und Support\n- **Generieren von Test-Quellcode:**  [Michael Friedrich](https://about.gitlab.com/company/team/#dnsmichi), Senior Developer Advocate, verwendet GitLab Duo, um Test-Quellcode für CI/CD-Komponenten zu generieren. Dieser Ansatz wurde in verschiedenen Vorträgen und Präsentationen wie bei der jüngsten Veranstaltung „Open Source @ Siemens“ ([öffentliche Folien](https://go.gitlab.com/duA2Fc)) vorgestellt. Die Verwendung von GitLab Duo auf diese Weise trägt dazu bei, dass der Code konsistent und gut dokumentiert ist und mit unseren Best Practices übereinstimmt. Sieh dir sein [Rust-Beispiel](https://gitlab.com/components/rust#contributing) an.\n\n![Beispiel für Rust](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098367/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098367547.png)\n\n- **Optimieren von Forschungsaufgaben:** Unsere Teammitglieder nutzen bei Fragen zu GitLab-Funktionen regelmäßig Chat, und optimieren so ihre Forschungs- und Supportaufgaben. Michael teilte mit: „Wenn ich eine Frage zu GitLab-Funktionen habe, verwende ich standardmäßig Chat, anstatt 100 Browser-Tabs zu öffnen. Dieser Workflow hilft mir dabei, die Benutzer(innen) in unserem Community-Forum effizient zu unterstützen. Zum Beispiel habe ich kürzlich mit dieser Methode [einem/r Benutzer(in) bei der SSH-Bereitstellung geholfen](https://forum.gitlab.com/t/how-to-make-ssh-deployment-more-clear-in-gitlab/102051/4?u=dnsmichi).“ Die Verwendung von Chat spart nicht nur Zeit, sondern wir erhalten auch schnell genaue Informationen und verbessern so den Support, den wir unserer Community anbieten.\n\n### Funktionstests\n- **Testen neuer Funktionen:** Unsere Ingenieure verwenden GitLab Duo, um neue Funktionen wie [Markdown-Unterstützung in Codevorschlägen](https://gitlab.com/gitlab-org/gitlab/-/issues/443365) zu testen. Eines unserer Teammitglieder merkte an: „Ich muss die Markdown-Unterstützung in Codevorschlägen testen, um Blog-Posts und GitLab-Dokumente in VS Code zu schreiben. Ich habe gesehen, dass die Unterstützung für Version 17.0 zusammengeführt wurde.“ Indem wir diese Funktionen vor der Veröffentlichung intern testen, stellen wir sicher, dass sie unseren Qualitätsstandards entsprechen.\n\n### Verständnis externer Codebases\n- **Erklären externer Projekte:** Die Funktion ‚/explain‘ von GitLab Duo ist besonders nützlich, um externe Projekte zu verstehen, die in GitLab importiert wurden. Diese Fähigkeit hat er kürzlich in einem Livestream mit dem Open-Source-Experten Eddie Jaoude hervorgehoben. Michael teilte uns mit: „Ich verwende ‚/explain` bei externen Projekten, um den Quellcode zu verstehen. Ich habe diese Idee für das Lernen über Open-Source-Projekte, Abhängigkeiten usw. während des Livestreams vorgestellt.“ Diese Funktion ist von unschätzbarem Wert für Entwickler(innen), die die Funktionalität und Abhängigkeiten unbekannter Codebases schnell erfassen müssen. So sind sie bedeutend effizienter und ihr Verständnis ist sehr viel besser.\n\n\u003Ccenter>\nSieh dir an, wie Michael ‚/explain` während eines Livestreams mit Eddie Jaoude vorstellt:\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/L2Mx8hOhkEE?si=R7W3v4EDqeJCaPOw\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n\u003C/center>\n\n## Vorteile von GitLab Duo\n\nDie Integration von GitLab Duo hat zahlreiche positive Auswirkungen mit sich gebracht und unsere Workflows in den Bereichen Engineering und Produktentwicklung erheblich verbessert:\n\n- Viele Aufgaben, bei denen zuvor manuell eingegriffen werden musste, werden jetzt automatisiert, wodurch unsere Ingenieure wertvolle Zeit gewinnen. Zum Beispiel sind das Zusammenfassen langer Threads und das Erstellen von Boilerplate-Code jetzt effizienter, sodass sich unser Team auf komplexere Probleme konzentrieren kann.\n\n- Die Zeit, die für die Dokumentation und Zusammenfassung von Tickets benötigt wird, hat sich verringert, was eine schnellere Verbreitung von Informationen und Entscheidungsfindung ermöglicht.\n\n- Mit KI-gestützten Codevorschlägen und -erklärungen erstellen unsere Teams qualitativ hochwertigeren Code mit weniger Fehlern und schnelleren Debugging-Prozessen. Die Integration von GitLab Duo in Vorfall-Reviews und die Unterstützung bei der Programmierung hat zu effizienteren und effektiveren Code-Reviews geführt.\n\n- Administrative Aufgaben wie der Entwurf von OKRs und das Erstellen von Versionshinweisen wurden optimiert. \n\nGitLab Duo hat nicht nur dazu beigetragen, unsere Effizienz zu steigern, sondern auch die Qualität und Geschwindigkeit unserer Entwicklungsprozesse zu verbessern, was die transformationelle Kraft von KI in der Softwareentwicklung verdeutlicht.\n\n## Wie geht es weiter?\n\nWir werden weiter KI in unsere Workflows integrieren und die Funktionen von GitLab Duo basierend auf internem Feedback und neuen Bedürfnissen kontinuierlich verbessern. Die fortlaufende Erfassung von Anwendungsfällen und Metriken mit dem [KI-Impact-Analyse-Dashboard](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/) wird zu Verbesserungen führen und sicherstellen, dass GitLab Duo an der Spitze der KI-gesteuerten Entwicklungs-Tools bleibt.\n\n![Dogfooding Duo – KI-Analyse-Dashboard](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098367/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098367547.png)\n\n> [Lege noch heute los mit unserer kostenlosen Testversion von GitLab Duo.](https://about.gitlab.com/de-de/gitlab-duo/#free-trial)\n\n## Erfahre mehr zur „Entwicklung von GitLab Duo\n\n- [Entwicklung von GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n- [Entwicklung von GitLab Duo: Wie wir KI-Modelle in großem Maßstab validieren und testen](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale/)",[683,1119,685,686,836],"code review",{"slug":1121,"featured":93,"template":692},"developing-gitlab-duo-how-we-are-dogfooding-our-ai-features","content:de-de:blog:developing-gitlab-duo-how-we-are-dogfooding-our-ai-features.yml","Developing Gitlab Duo How We Are Dogfooding Our Ai Features","de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features.yml","de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features",{"_path":1127,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1128,"content":1134,"config":1141,"_id":1143,"_type":16,"title":1144,"_source":18,"_file":1145,"_stem":1146,"_extension":21},"/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai",{"title":1129,"description":1130,"ogTitle":1129,"ogDescription":1130,"noIndex":6,"ogImage":1131,"ogUrl":1132,"ogSiteName":674,"ogType":675,"canonicalUrls":1132,"schema":1133},"Entwicklung von GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI","In unserem Blog stellen wir eine neue Funktion vor, mit der du die Effektivität deiner Investitionen in die KI besser nachvollziehen kannst. Dies wird durch detaillierte Metriken wie die Nutzungsquote von Codevorschlägen ermöglicht.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098611/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098611370.png","https://about.gitlab.com/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Haim Snir\"}],\n        \"datePublished\": \"2024-05-15\",\n      }",{"title":1129,"description":1130,"authors":1135,"heroImage":1131,"date":1137,"body":1138,"category":14,"tags":1139},[1136],"Haim Snir","2024-05-15","***Generative KI bedeutet einen monumentalen Wandel in der Softwareentwicklungsbranche, da sie es einfacher macht, Software zu entwickeln, zu sichern und zu betreiben. Unsere neue Blog-Serie von unseren Produkt- und Entwicklungsteams gibt einen Einblick darin, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und wie sie DevSecOps-Teams dabei helfen werden, bessere Ergebnisse für Kund(inn)en zu erzielen.***\n\nWenn Unternehmen [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), unsere Suite von KI-Funktionen zur Unterstützung von DevSecOps-Workflows, einführen, benötigen Führungskräfte aus Wirtschaft und Technik einen Echtzeit-Überblick über den ROI der Technologie. Granulare Nutzungsdaten, Leistungsverbesserungen, der Kompromiss zwischen Geschwindigkeit, Sicherheit und Qualität und andere [Produktivitätsmetriken](https://about.gitlab.com/blog/measuring-ai-effectiveness-beyond-developer-productivity-metrics/) sind unerlässlich, um die Effektivität von KI in der Softwareentwicklung zu bewerten. Aus diesem Grund haben wir das KI-Impact-Analyse-Dashboard für GitLab Duo erstellt, das ab GitLab 17.0 verfügbar ist, um den ROI von KI zu messen.\n\n> Live-Demo! Entdecke die Zukunft der KI-gesteuerten Softwareentwicklung mit unserem virtuellen Launch-Event für GitLab 17. [Registriere dich noch heute](https://about.gitlab.com/seventeen/)!\n\n## Den ROI der KI-gestützten Funktionen von GitLab Duo verstehen\n\nUnternehmen haben uns in Bezug auf die Auswirkungen von KI auf den Lebenszyklus der Softwareentwicklung ihre Wünsche mitgeteilt:\n- Visualisieren der Metriken, die sich durch die Investitionen in KI verbessert haben.\n- Vergleich der Leistung von Teams, die KI einsetzen, mit Teams, die keine KI einsetzen.\n- Verfolgen des Fortschritts bei der Einführung von KI.\n- Automatisieren der Erkenntnisgewinnung aus einer großen Menge von Leistungsdaten.\n\nDas KI-Impact-Analyse-Dashboard bietet diese und weitere Funktionen mit anpassbarer Visualisierung. Teams können damit Folgendes tun:\n- **Überwachen der KI-Einführung:** Die Überwachung der Einführungsrate von KI ermöglicht es Unternehmen, ihre Strategien zu bewerten, um den ROI ihrer Technologieinvestitionen zu maximieren. \n- **Verfolgen von Leistungsverbesserungen:** Durch die Verfolgung von Metriken und die Beobachtung von Veränderungen nach der Einführung von KI können Führungskräfte die Vorteile und den geschäftlichen Wert von KI-Funktionen rasch beurteilen.\n\n## Was ist das KI-Impact-Analyse-Dashboard?\n\nIn dieser ersten Version des KI-Impact-Analyse-Dashboards konzentrieren wir uns auf die Bereitstellung von Einblicken und Metriken für die Akzeptanz von GitLab Duo Codevorschlägen, einschließlich:\n\n- **Detaillierte Nutzungsmetriken:** Ermittle das Verhältnis zwischen der monatlichen Nutzung von Codevorschlägen und der Gesamtzahl der Mitwirkenden, um herauszufinden, wie stark Codevorschläge in deinen Teams angenommen werden.\n- **Korrelationsbeobachtungen:** Untersuche, wie sich die Entwicklung der KI-Nutzung im aktuellen Monat und über die letzten sechs Monate auf andere wichtige Metriken eines Projekts oder einer Gruppe auswirkt. \n    - Für diese Korrelationsanalyse haben wir die neue Metrik „Nutzungsquote von Codevorschlägen“ als unabhängige Variable (die Ursache) hinzugefügt. Die monatliche Nutzungsrate von Codevorschlägen errechnet sich aus der Anzahl der monatlich eindeutigen Benutzer(innen), die Codevorschläge verwenden, geteilt durch die Gesamtzahl der monatlich eindeutigen [Mitwirkenden](https://docs.gitlab.com/ee/user/profile/contributions_calendar.html#user-contribution-events). GitLab betrachtet hierbei die Summe der monatlichen eindeutigen Code-Mitwirkenden, d. h. nur Benutzer(innen), die Ereignisse gepusht haben, werden in die Berechnung einbezogen.\n    - Als abhängige Variable (den Effekt) haben wir die folgenden [Leistungsmetriken](https://docs.gitlab.com/ee/user/analytics/value_streams_dashboard.html#dashboard-metrics-and-drill-down-reports) hinzugefügt: Bearbeitungszeit, Abarbeitungsdauer und Häufigkeit der Bereitstellung. Und die [Qualitäts- und Sicherheitsmetriken](https://docs.gitlab.com/ee/user/analytics/value_streams_dashboard.html#dashboard-metrics-and-drill-down-reports) sind die Änderungsfehlerrate und kritische Sicherheitslücken. \n- **Vergleichsansicht:**  Erfasse den Leistungsunterschied zwischen Teams, die KI einsetzen, und solchen, die sie nicht einsetzen, und finde einen Kompromiss zwischen Geschwindigkeit, Qualität und Sicherheitsrisiko.\n\n![Vergleich von KI-Nutzung und SDLC-Leistung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098620998.png)\n\n## Wie geht es weiter mit dem KI-Impact-Analyse-Dashboard?\n\nWir haben große Pläne, um die Möglichkeiten des KI-Impact-Analyse-Dashboards zu erweitern. Hier sind einige der Highlights:\n\n1. Neue Kachelvisualisierungen wie „GitLab Duo-Plätze: Zugewiesen und genutzt“, „Codevorschläge: Übernahmequote %“ und „GitLab Duo Chat: Eindeutige Benutzer(innen)“, um einen tieferen Einblick in das Nutzungsverhalten von GitLab Duo zu erhalten.\n\n![KI-Impact-Analyse-Dashboard](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/Screenshot_2024-07-17_at_12.50.31_aHR0cHM6_1750098620999.png)\n\n2. Ein neues Vergleichsbalkendiagramm, mit dem du beobachten kannst, wie Veränderungen in einer Metrik mit Veränderungen in anderen Metriken korrelieren:\n\n![KI-Impact-Vergleichsbalkendiagramm](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098621000.png)\n\n3. KI-Statistiken im [Bericht zur Beitragsanalyse](https://docs.gitlab.com/ee/user/group/contribution_analytics/index.html), um zu verstehen, wie Benutzer(innen) mit KI-Funktionen interagieren. Ermittle, welche Benutzer(innen) KI-Funktionen nutzen und ob sich ihre Leistung im Laufe der Zeit verändert hat:\n\n![Bericht zur Beitragsanalyse](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098621001.png)\n\n## Lege noch heute los\n\nWir sind vom Potential des KI-Impact-Analyse-Dashboard begeistert. Es zeigt nicht nur die realen Geschäftsergebnisse der KI auf, sondern fördert auch fundierte Entscheidungen über den zukünftigen Einsatz von KI zur Optimierung des DevSecOps-Lebenszyklus. Weitere Informationen über die nächsten Schritte und die Möglichkeit, Feedback zu geben oder Fragen zu stellen, findest du in unserem [KI-Impact-Analyse-Dashboard Epic](https://gitlab.com/groups/gitlab-org/-/epics/12978).\n\nStarte noch heute deine [kostenlose Testversion von GitLab Duo und dem KI-Impact-Analyse-Dashboard](https://about.gitlab.com/de-de/gitlab-duo/#free-trial).\n\n## Weitere Artikel aus der Serie „Entwicklung von GitLab Duo“\n\n- [Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale/)\n- [Entwicklung von GitLab Duo: Wie wir unsere KI-Funktionen selbst verwenden (dogfooding)](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features/)\n\n_Haftungsausschluss: Dieser Blog enthält Informationen zu kommenden Produkten, Funktionen und Funktionalitäten. Bitte beachte, dass die Informationen in diesem Blogbeitrag nur zu Informationszwecken dienen. Bitte verlasse dich nicht auf diese Informationen, wenn du etwas kaufen oder planen möchtest. Wie bei allen Projekten können sich die in diesem Blog und auf den verlinkten Seiten genannten Punkte ändern oder verzögern. Die Entwicklung, Freigabe und der Zeitplan von Produkten, Funktionen oder Funktionalitäten liegen im alleinigen Ermessen von GitLab._",[683,1140,685],"performance",{"slug":1142,"featured":93,"template":692},"developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai","content:de-de:blog:developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai.yml","Developing Gitlab Duo Ai Impact Analytics Dashboard Measures The Roi Of Ai","de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai.yml","de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai",{"_path":1148,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1149,"content":1155,"config":1161,"_id":1163,"_type":16,"title":1164,"_source":18,"_file":1165,"_stem":1166,"_extension":21},"/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale",{"title":1150,"description":1151,"ogTitle":1150,"ogDescription":1151,"noIndex":6,"ogImage":1152,"ogUrl":1153,"ogSiteName":674,"ogType":675,"canonicalUrls":1153,"schema":1154},"Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen","Unsere Blog-Serie beginnt mit einem Blick hinter die Kulissen, wie wir LLMs evaluieren, sie an Anwendungsfälle anpassen und sie optimieren, um bessere Ergebnisse für die Benutzer(innen) zu erzielen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659856/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25.png","https://about.gitlab.com/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Susie Bitters\"}],\n        \"datePublished\": \"2024-05-09\",\n      }",{"title":1150,"description":1151,"authors":1156,"heroImage":1152,"date":1157,"body":1158,"category":14,"tags":1159},[811],"2024-05-09","**_Generative KI markiert einen monumentalen Wandel in der Softwareentwicklungsbranche, der es einfacher macht, Software zu entwickeln, sicherer zu machen und sie zu betreiben. Unsere neue Blog-Serie von unseren Produkt- und Entwicklungsteams gibt einen Einblick darin, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und wie sie DevSecOps-Teams dabei helfen, bessere Ergebnisse für Kund(inn)en zu erzielen._**\n\nGitLab schätzt das Vertrauen unserer Kund(inn)en in uns. Ein Teil der Aufrechterhaltung dieses Vertrauens ist die Transparenz darüber, wie wir die hochwertige Funktionalität unserer [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) KI-Funktionen erstellen, bewerten und gewährleisten. Die Funktionen von GitLab Duo basieren auf einer Vielzahl von Modellen, die es uns ermöglichen, eine Vielzahl von Anwendungsfällen zu unterstützen und unseren Kund(inn)en Flexibilität zu bieten. GitLab ist von vornherein nicht an einen einzigen Modellanbieter gebunden. Wir verwenden derzeit Foundation-Modelle von [Google](https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/blob/main/ai_gateway/models/vertex_text.py?ref_type=heads#L86) und [Anthropic](https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/blob/main/ai_gateway/models/anthropic.py?ref_type=heads#L62). Wir wägen jedoch kontinuierlich ab, welche Modelle für die Anwendungsfälle von GitLab Duo geeignet sind. In diesem Artikel geben wir einen Einblick in unseren Validierungsprozess für KI-Modelle.\n\n## Was sind LLMs\n\nUmfangreiche Sprachmodelle (Large language models, LLMs) sind generative KI-Modelle, die viele KI-Funktionen innerhalb der GitLab Plattform unterstützen. LLMs wurden mit riesigen Datensätzen trainiert und prognostizieren das nächste Wort in einer Sequenz basierend auf dem vorhergehenden Kontext. Als Antwort auf eine Eingabe (Prompt) von Benutzer(innen) erzeugen sie Text, der der Antwort eines Menschen ähnelt, indem sie abhängig vom Prompt aus der Wahrscheinlichkeitsverteilung von Wörtern ein Muster wiedergeben.\n\nLLMs ermöglichen es, intelligente Codevorschläge, Konversations-Chatbots, Code-Erklärungen, Analysen von Sicherheitslücken und mehr umzusetzen. Ihre Fähigkeit, für einen bestimmten Prompt unterschiedliche Antworten zu erzeugen, macht eine standardisierte Qualitätsbewertung schwierig. Da LLMs für verschiedene Eigenschaften optimiert werden können, werden so viele unterschiedliche KI-Modelle aktiv entwickelt.\n\n## Testen im großen Maßstab\n\nIm Gegensatz zu herkömmlichen Softwaresystemen, bei denen Ein- und Ausgaben einfacher definiert und getestet werden können, erzeugen LLMs Ausgaben, die oft nuanciert, vielfältig und kontextabhängig sind. Um diese Modelle zu testen, sind umfassende Strategien erforderlich, die die subjektiven und variablen Interpretationen von Qualität sowie die stochastische Natur ihrer Ergebnisse berücksichtigen. Wir können daher die Qualität der Ergebnisse eines LLM nicht individuell oder anekdotisch beurteilen. Stattdessen müssen wir in der Lage sein, das Gesamtmuster des Verhaltens eines LLM zu untersuchen. Um ein Gefühl für diese Muster zu bekommen, müssen wir in großem Maßstab testen. Darunter versteht man den Prozess der Bewertung der Leistung, Zuverlässigkeit und Robustheit eines Systems oder einer Anwendung über eine große und vielfältige Anzahl von Datensätzen und Anwendungsfällen. Unser [Centralized Evaluation Framework (CEF)](https://about.gitlab.com/direction/ai-powered/ai_model_validation/ai_evaluation/) verwendet Tausende von Prompts, die mit Dutzenden von Anwendungsfällen verknüpft sind, um signifikante Muster zu identifizieren und das Gesamtverhalten unserer grundlegenden LLMs und der GitLab Duo-Funktionen, in die sie integriert sind, zu bewerten.\n\nTesten im großen Maßstab hilft uns bei der:\n\n- **Gewährleistung von Qualität:** Durch Tests im großen Maßstab können wir die Qualität und Zuverlässigkeit dieser Modelle in einer Vielzahl von Szenarien und Inputs bewerten. Indem wir die Ergebnisse dieser Modelle in großem Maßstab validieren, können wir Muster identifizieren und potenzielle Probleme wie systematische Verzerrungen, Anomalien und Ungenauigkeiten abmildern. \n- **Optimierung der Leistung:** Die Intensivierung der Tests ermöglicht es GitLab, die Leistung und Effizienz von LLMs unter realen Bedingungen zu beurteilen. Dazu gehört die Bewertung von Faktoren wie Ausgabequalität, Latenz und der Kosten für die Optimierung der Bereitstellung und des Einsatzes dieser Modelle in GitLab Duo-Funktionen.\n- **Minderung von Risiken:** Das Testen von LLMs im großen Maßstab trägt dazu bei, die mit der Bereitstellung von LLMs in kritischen Anwendungen verbundenen Risiken zu mindern. Durch gründliche Tests über verschiedene Datensätze und Anwendungsfälle hinweg können wir potenzielle Fehlermodi, Sicherheitslücken und ethische Bedenken identifizieren und diese adressieren und beheben, bevor sie sich auf unsere Kund(inn)en auswirken.\n\nDas Testen von LLMs im großen Maßstab ist unerlässlich, um ihre Zuverlässigkeit und Robustheit für ihre Bereitstellung innerhalb der GitLab-Plattform sicherzustellen. Durch die Investition in umfassende Teststrategien, die verschiedene Datensätze, Anwendungsfälle und Szenarien umfassen, arbeitet GitLab daran, das volle Potenzial von KI-gestützten Workflows auszuschöpfen und gleichzeitig potenzielle Risiken zu mindern.\n\n### Wie wir in großem Maßstab testen\n\nDies sind die notwendigen Schritte, um LLMs in großem Maßstab zu testen.\n\n#### Schritt 1: Erstellen einer Prompt-Bibliothek als Proxy für die Produktion\nWährend andere Unternehmen Kundendaten einsehen und verwenden, um ihre KI-Funktionen zu trainieren, tut GitLab dies derzeit nicht.  Deshalb mussten wir eine umfassende Prompt-Bibliothek entwickeln, die sowohl den Umfang als auch die Aktivität der Produktionsumgebung abbildet.\n\nDiese Prompt-Bibliothek besteht aus Fragen und Antworten. Die Fragen stellen die Art von Abfragen oder Eingaben dar, die wir in der Produktionsumgebung erwarten würden, während die Antworten eine Grundwahrheit darüber darstellen, was unsere ideale Antwort wäre. Diese Referenzantwort könnte auch als Zielantwort formuliert werden. Sowohl die Frage als auch die Antwort können, aber müssen nicht von Menschen generiert werden. Diese Frage-Antwort-Paare geben uns eine Vergleichsbasis und einen Bezugsrahmen, mit dem wir die Unterschiede zwischen Modellen und Funktionen herausarbeiten können. Wenn mehreren Modellen dieselbe Frage gestellt wird und sie unterschiedliche Antworten erzeugen, können wir anhand unserer Referenzantwort feststellen, welches Modell eine Antwort gegeben hat, die unserem Ziel am nächsten kommt, und sie entsprechend bewerten.\n\nAuch hier ist ein zentrales Element einer umfassenden Prompt-Bibliothek, dass sie repräsentativ für die Eingaben ist, die wir in der Produktionsumgebung erwarten. Wir möchten wissen, wie gut die grundlegenden Modelle zu unserem spezifischen Anwendungsfall passen und wie gut unsere Funktionen funktionieren. Es gibt zahlreiche Datensätze mit Benchmark-Prompts, aber diese Datensätze spiegeln möglicherweise nicht die Anwendungsfälle wider, die wir bei GitLab annehmen. Unsere Prompt-Bibliothek ist so konzipiert, dass sie speziell auf die Funktionen und Anwendungsfälle von GitLab zugeschnitten ist.\n\n#### Schritt 2: Leistung des Basismodells\n\nSobald wir eine Prompt-Bibliothek erstellt haben, die die Produktionsaktivitäten genau widerspiegelt, geben wir diese Fragen in [verschiedene Modelle](https://about.gitlab.com/direction/ai-powered/ai_model_validation/ai_evaluation/foundation_models/) ein, um zu testen, wie gut sie den Bedürfnissen unserer Kund(inn)en entsprechen. Wir vergleichen jede Antwort mit unserer Grundwahrheit und reihen sie in eine Rangfolge ein, die auf einer Reihe von Metriken basiert, wie zum Beispiel: [Cosine Similarity Score](https://about.gitlab.com/direction/ai-powered/ai_model_validation/ai_evaluation/metrics/#similarity-scores), [Cross Similarity Score](https://about.gitlab.com/direction/ai-powered/ai_model_validation/ai_evaluation/metrics/#cross-similarity-score),  [LLM Judge](https://about.gitlab.com/direction/ai-powered/ai_model_validation/ai_evaluation/metrics/#llm-judge), und [Consensus Filtering mit LLM Judge](https://about.gitlab.com/direction/ai-powered/ai_model_validation/ai_evaluation/metrics/#consensus-filtering-with-llm-judge). Diese erste Iteration liefert uns einen Anhaltspunkt dafür, wie gut die einzelnen Modelle abschneiden, und hilft uns bei der Auswahl eines grundlegenden Modells für unsere Einsatzbereiche. Um uns kurz zu fassen, werden wir hier nicht ins Detail gehen, aber du kannst [hier mehr über die Metriken erfahren](https://about.gitlab.com/direction/ai-powered/ai_model_validation/ai_evaluation/metrics/). Es ist wichtig zu wissen, dass dieses Problem nicht gelöst ist. Die KI-Branche forscht aktiv an neuen Techniken und entwickelt sie weiter. Das Modellvalidierungsteam von GitLab behält die Branche im Auge und arbeitet ständig daran, wie wir die von GitLab Duo verwendeten LLMs prüfen und bewerten.  \n\n#### Schritt 3: Funktionsentwicklung\n\nJetzt, da wir eine Grundlage für die Leistung unseres ausgewählten Modells haben, können wir mit den gewonnen Daten unsere Plattform weiterentwickeln. Prompt-Engineering ist zwar sehr populär, aber wenn man sich ausschließlich darauf konzentriert, das Verhalten eines Modells durch Prompting (oder eine andere Technik) zu verändern, ohne es zu validieren, stochert man im Dunkeln und passt sein Prompting sehr wahrscheinlich zu stark an. Man löst vielleicht ein Problem, aber verursacht ein Dutzend andere. Und es würde wahrscheinlich nie auffallen. Wenn wir eine Grundlinie für die Leistung eines Modells festlegen, können wir verfolgen, wie sich das Verhalten im Laufe der Zeit für alle notwendigen Anwendungsfälle verändert. Bei GitLab überprüfen wir die Leistung unserer GitLab Duo Funktionen während der aktiven Entwicklung täglich neu, um sicherzustellen, dass alle Änderungen die Gesamtfunktionalität verbessern.\n\n#### Schritt 4: Iterieren, iterieren, iterieren\n\nUnsere experimentellen Iterationen funktionieren wie folgt: In jedem Durchgang untersuchen wir die Ergebnisse unserer Tests im großen Maßstab, um Muster zu erkennen:\n\n- Was haben unsere schwächsten Bereiche gemeinsam?\n- Verhält sich unsere Funktion für eine bestimmte Metrik oder in einem bestimmten Anwendungsfall ungünstig?\n- Gibt es bei bestimmten Fragen immer wieder dieselben Fehler?\n\nSolche Muster tauchen nur dann auf, wenn wir in großem Maßstab testen, und nur so können wir unsere Experimente optimieren. Auf der Grundlage dieser Muster schlagen wir verschiedene Experimente oder Ansätze vor, um die Leistung in einem bestimmten Bereich und für eine bestimmte Metrik zu verbessern.\n\nTesten im großen Maßstab ist jedoch sowohl teuer als auch zeitaufwendig. Um eine schnellere und kostengünstigere Iteration zu ermöglichen, erstellen wir einen kleineren Datensatz, der als Mini-Proxy fungiert. Die begrenzte Teilmenge wird so gewichtet, dass sie genau die Frage-Antwort-Paare enthält, die wir verbessern möchten. Die erweiterte Teilmenge enthält auch eine Auswahl aller anderen Anwendungsfälle und Bewertungen, um sicherzustellen, dass sich unsere Änderungen nicht nachteilig auf die allgemeine Funktionalität auswirken. Wir nehmen also Änderungen vor und überprüfen sie gegen eine begrenzte Teilmenge der Daten. Wie sieht die neue Antwort im Vergleich zur Ausgangslage aus? Wie verhält es sich mit der Grundwahrheit?\n\nSobald wir einen Prompt gefunden haben, der sich auf den spezifischen Anwendungsfall bezieht, an dem wir gerade mit der begrenzten Teilmenge arbeiten, validieren wir diesen Prompt anhand einer erweiterten Teilmenge von Daten, um sicherzustellen, dass er sich nicht nachteilig auf andere Bereiche auswirkt. Nur wenn wir durch die Validierungsmetriken der Meinung sind, dass der neue Prompt unsere Leistung in unserem Zielbereich verbessert UND die Leistung an anderer Stelle nicht verschlechtert, setzen wir diese Änderung in der Produktionsumgebung um.\n\nDas gesamte Centralized Evaluation Framework wird dann mit dem neuen Prompt ausgeführt und wir überprüfen, ob die Leistung der gesamten Funktionalität gegenüber der Ausgangssituation vom Vortag verbessert wurde. Auf diese Weise stellt GitLab durch ständige Iterationen sicher, dass du im gesamten GitLab-Ökosystem die neueste und beste Leistung der KI-gestützten Funktionen erhältst. So können wir sicherstellen, dass wir gemeinsam immer schneller arbeiten.\n\n### GitLab Duo noch besser machen\n\nWir hoffen, dass wir dir hiermit einen Einblick geben konnten, wie wir die Funktionen von GitLab Duo verantwortungsvoll entwickeln. Dieser Prozess wurde entwickelt, um [GitLab Duo Codevorschläge](https://docs.gitlab.com/ee/user/project/repository/code_suggestions/) und [GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) allgemein verfügbar zu machen. Wir haben diesen Validierungsprozess auch in unseren Entwicklungsprozess integriert, wenn wir die Funktionen von GitLab Duo weiterentwickeln. Es bedeutet unzählige Versuche und Fehlschläge, und oft macht die Korrektur eines Punkts drei andere kaputt. Aber wir erhalten dabei auch datengestützte Einblicke in diese Auswirkungen und können so sicherstellen, dass GitLab Duo immer besser wird.\n\n> Starte noch heute deine [kostenlose Testversion von GitLab Duo](https://about.gitlab.com/gitlab-duo/#free-trial)!\n\n\u003Cfigure class=video_container>\n\u003Ciframe width=560 height=315 src=\"https://www.youtube-nocookie.com/embed/LifJdU3Qagw?si=A4kl6d32wPYC4168\" title=\"YouTube video player\" frameborder=0 allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen=\"\">\u003C/iframe>\n\u003C/figure>",[683,976,686,685,1160],"inside GitLab",{"slug":1162,"featured":93,"template":692},"developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale","content:de-de:blog:developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale.yml","Developing Gitlab Duo How We Validate And Test Ai Models At Scale","de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale.yml","de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale",{"_path":1168,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1169,"content":1175,"config":1181,"_id":1183,"_type":16,"title":1184,"_source":18,"_file":1185,"_stem":1186,"_extension":21},"/de-de/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat",{"title":1170,"description":1171,"ogTitle":1170,"ogDescription":1171,"noIndex":6,"ogImage":1172,"ogUrl":1173,"ogSiteName":674,"ogType":675,"canonicalUrls":1173,"schema":1174},"10 Best Practices für den Einsatz des KI-basierten GitLab Duo Chat","Tipps zur Integration von GitLab Duo Chat in deine KI-basierten DevSecOps-Workflows. Dazu gibt's Ratschläge für präzisere Chat-Prompts.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097639/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%281%29_77JeTV9gAmbXM0224acirV_1750097638765.png","https://about.gitlab.com/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"10 Best Practices für den Einsatz des KI-basierten GitLab Duo Chat\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"}],\n        \"datePublished\": \"2024-04-02\",\n      }\n                  ",{"title":1170,"description":1171,"authors":1176,"heroImage":1172,"date":1177,"body":1178,"category":14,"tags":1179,"updatedDate":1180},[972],"2024-04-02","Mit einer KI ins Gespräch zu kommen, kann eine Herausforderung sein. Mit welcher Frage fängt man am besten an? Wie formuliert man seine Frage am besten? Wie viel Kontext ist erforderlich? Wird das Gespräch die besten und effizientesten Ergebnisse liefern?\n\nIn diesem Tutorial stellen wir 10 Tipps und Best Practices zur Integration von GitLab Duo Chat in deine KI-basierten DevSecOps-Workflows vor und präzisieren deine Prompts, damit du die besten Ergebnisse erzielen kannst.\n\n[GitLab Duo Chat öffnen und im Vordergrund behalten](#gitlab-duo-chat-öffnen-und-im-vordergrund- behalten)\n\n[10 Best Practices zur Verwendung von GitLab Duo Chat](#10-best-practices-zur-verwendung-von-gitlab-duo-chat)\n\n1. [Führe ein Gespräch](#1.-führe-ein-gespräch)\n2. [Präzisiere den Prompt für mehr Effizienz](#2.-präzisiere-den-prompt-für-mehr-effizienz)\n3. [Beachte Prompt-Muster](#3.-beachte-prompt-muster)\n4. [Setze auf eine kontextarme Kommunikation](#4.-setze-auf-eine-kontextarme-kommunikation)\n5. [Wiederhole dich](#5.-wiederhole-dich)\n6. [Sei geduldig](#6.-sei-geduldig)\n7. [Verwerfe alles und fang von vorn an](#7.-verwerfe-alles-und-fang-von-vorn-an)\n8. [Steigere in der IDE mit Slash-Befehlen deine Effizienz](#8.-steigere-in-der-ide-mit-slash-befehlen-deine-effizienz)\n9. [Präzisiere den Prompt für Slash-Befehle](#9.-präzisiere-den-prompt-für-slash-befehle)\n10. [Werde bei den Slash-Befehlen kreativ](#10.-werde-bei-den-slash-befehlen-kreativ)\n\nBonusinhalte:\n- [Shortcuts](#shortcuts)\n- [Unterhaltsame Übungen](#unterhaltsame-übungen)\n- [Weitere Informationen](#weitere-informationen)\n\n## GitLab Duo Chat öffnen und im Vordergrund behalten\n\n[GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) ist in der GitLab-UI, Web IDE und unterstützten Programmier-IDEs, z. B. VS Code, verfügbar. \n\nIn VS Code kannst du GitLab Duo Chat über die Side Bar auf der linken Seite öffnen. Du kannst das Symbol auch per Drag & Drop in den rechten Bereich ziehen. So kann der Chat geöffnet bleiben, während du deinen Code schreibst und durch den Dateibaum navigierst, Git-Aktionen durchführst usw. Um den Anzeigeort des Chats zurückzusetzen, öffnest du einfach die Befehlspalette (durch Drücken der Tastenkombination `Command+Umschalt+P` (bei macOS) oder `Strg+Umschalt+P` (bei Windows/Linux) und gibst dann `View: Reset View Locations` (Ansicht: Anzeigeorte zurücksetzen) ein. Im folgenden kurzen Video erfährst du, wie es geht.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/foZpUvWPRJQ\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nDie Web IDE und VS Code teilen sich das gleiche Framework – mit derselben Methode lassen sich in der Web IDE effizientere Workflows umsetzen.\n\n![Chat in der Web IDE](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097645344.png)\n\n## 10 Best Practices für die Verwendung von GitLab Duo Chat\n\n### 1. Führe ein Gespräch\n\nChats sind Gespräche, keine Suchformulare.\n\nUm das Eis zu brechen, kannst du mit Suchbegriffen beginnen, die denen einer Suchmaschine ähneln, und dann mit der Antwort und Ausgabe experimentieren. Beginnen wir in diesem Beispiel mit einem C#-Projekt und unseren Best Practices. \n\n> c# start project best practices (Best Practices für den Beginn eines C#-Projekts)\n\n![Chat-Prompt „c# start project best practices“ und die Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097646/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750097645345.png)\n\nDie Antwort ist hilfreich, um C# besser zu verstehen, gibt aber nicht sofort den Anstoß für Best Practices. Deshalb sollten wir im gleichen Zusammenhang eine gezieltere Frage stellen. \n\n> Please show the project structure for the C# project. (Bitte zeige die Projektstruktur für das C#-Projekt an.)\n\n![Chat-Prompt „Please show the project structure for the C# project.“ und die Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750097645346.png)\n\nDiese Antwort ist hilfreich. Wir fahren mit einer Git-Frage fort und verwenden dabei dieselbe Fragenstruktur: eine direkte Anfrage für eine Anzeige.\n\n> Show an example for a .gitignore for C#. (Zeige ein Beispiel für .gitignore für C# an.)\n\n![Chat-Prompt für „Show an example for a .gitignore for C#.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image25_aHR0cHM6_1750097645347.png)\n\nBleib bei CI/CD und frage, wie man das C#-Projekt erstellen kann.\n\n> Show a GitLab CI/CD configuration for building the C# project. (Zeige eine GitLab-CI/CD-Konfiguration zum Erstellen des C#-Projekts an.)\n\n![Chat-Prompt für „Show a GitLab CI/CD configuration for building the C# project.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image16_aHR0cHM6_1750097645349.png)\n\nIn diesem Beispiel hat uns Chat dazu ermutigt, bestimmte Änderungen anzufordern. Wir wollen das .NET SDK 8.0 anstelle von 6.0 verwenden.\n\n> In the above example, please use the .NET SDK 8.0 image. (Verwende im obigen Beispiel bitte das .NET SDK 8.0 Image.)\n\n![Chat-Prompt für „In the above example, please use the .NET SDK 8.0 image“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image32_aHR0cHM6_1750097645350.png)\n\nDie CI/CD-Konfiguration verwendet die .NET-CLI. Vielleicht können wir das auch für effizientere Befehle verwenden, um die Projekt- und Teststruktur zu erstellen? \n\n> Explain how to create projects and test structure on the CLI. (Erkläre, wie Projekte und Teststrukturen in der CLI erstellt werden.)\n\n![Chat-Prompt für „Explain how to create projects and test structure on the CLI.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image14_aHR0cHM6_1750097645351.png)\n\nNatürlich könnten wir diese Befehle im Terminal ausführen, aber geht das auch in VS Code? Fragen wir doch Chat.\n\n> Explain how to open a new terminal in VS Code. (Erkläre, wie man ein neues Terminal in VS Code öffnet.)\n\n![Chat-Prompt für „Explain how to open a new terminal in VS Code.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097645351.png)\n\n### 2. Präzisiere den Prompt für mehr Effizienz\n\nStell dir vor, GitLab Duo Chat wäre ein Mensch, und arbeite mit ihm in Form von vollständigen Sätzen, die so viel Kontext zu deinen Gedanken und Fragen wie möglich enthalten. \n\nErfahrene Benutzer(innen) von Suchmaschinen kennen diesen Ansatz vielleicht von der Abfrage von Inhalten: Erstelle die Frage, ergänze sie um weitere Begriffe, um den inhaltlichen Umfang zu präzisieren, und starte eine neue Suche, nachdem du bereits viele Registerkarten geöffnet hast. \n\nBei der Verwendung einer Suchmaschine hättest du wahrscheinlich schnell vier bis fünf verschiedene Suchfenster geöffnet. \n\n```markdown\nc# start project best practices\nc# .gitignore\nc# gitlab cicd \nc# gitlab security scanning \nc# solutions and projects, application and tests\n``` \n\nDu kannst diese Strategie auch in einem Chat anwenden. Du musst jedoch mehr Kontext hinzufügen, damit es zu einem Gespräch wird. Mit GitLab Duo Chat kannst du mehrere Fragen in ein und derselben Gesprächsanfrage stellen. Beispiel: Du willst mit einem neuen C#-Projekt beginnen, Best Practices anwenden, eine `.gitignore`-Datei hinzufügen und CI/CD und Sicherheitsscans konfigurieren, genau wie in der Suche oben. In Chat kannst du die Fragen zu einer Anfrage kombinieren.\n\n> How can I get started creating an empty C# console application in VS Code? Please show a .gitignore and .gitlab-ci.yml configuration with steps for C#, and add security scanning for GitLab. Explain how solutions and projects in C# work, and how to add a test project on the CLI. (Wie kann ich mit der Entwicklung einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige eine .gitignore- und .gitlab-ci.yml-Konfiguration mit Schritten für C# an und füge Sicherheitsscans für GitLab hinzu. Erkläre, wie Lösungen und Projekte in C# funktionieren und wie man ein Testprojekt in der CLI hinzufügt.)\n\n![Chat-Prompt für mehr Kontext und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image37_aHR0cHM6_1750097645352.png)\n\nIn dieser Antwort schlägt der Chat vor, bei Folgefragen im Gespräch nach konkreten Konfigurationsbeispielen zu fragen. Asynchrones Üben: Erstelle Folgefragen. Du kannst `C#` als Kontext in derselben Chat-Sitzung weglassen.\n\n> Please show an example for a .gitignore. Please show a CI/CD configuration. Include the SAST template. (Bitte zeige ein Beispiel für .gitignore. Bitte zeige eine CI/CD-Konfiguration. Füge die SAST-Vorlage hinzu.)\n\n### 3. Beachte Prompt-Muster \n\nFolge dem Muster: `Problembeschreibung, bitte um Hilfe, erstelle zusätzliche Anfragen`. Es fällt einem bei der ersten Frage vielleicht nicht gleich alles ein – beginne mit `Problembeschreibung, bitte um Hilfe`, wenn du zu Beginn noch ratlos bist. \n\n> I need to fulfill compliance requirements. How can I get started with Codeowners and approval rules? (Ich muss die Compliance-Anforderungen erfüllen. Wie kann ich mit Codeowners und Approvalregeln beginnen?)\n\n![Chat-Prompt für den Einstieg in Codeowners und Approvalregeln und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image19_aHR0cHM6_1750097645352.png)\n\nDie Antwort ist hilfreich, aber offensichtlich generisch. Vielleicht möchtest du an dieser Stelle spezifische Hilfe für dein Team-Setup erhalten. \n\n> Please show an example for Codeowners with different teams: backend, frontend, release managers. (Bitte zeige ein Beispiel für Codeowners mit verschiedenen Teams: Backend, Frontend, Release Manager.)\n\n![Chat-Prompt zur Anzeige eines Beispiels für Codeowners mit verschiedenen Teams: Backend, Frontend, Release Manager und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image31_aHR0cHM6_1750097645353.png)\n\nAlternativ kannst du deine aktuelle Situation beschreiben und um Unterstützung bitten. Wenn man dem STAR-Modell (Situation, Aufgabe, Aktion, Ergebnisse) folgt, kann es sich ein wenig wie ein Gespräch anfühlen. \n\n> I have a Kubernetes cluster integrated in GitLab. Please generate a Yaml configuration for a Kubernetes service deployment. Explain how GitOps works as a second step. How to verify the results? (Ich habe ein Kubernetes-Cluster in GitLab integriert. Bitte generiere eine Yaml-Konfiguration für eine Kubernetes-Dienstbereitstellung. Erkläre als zweiten Schritt, wie GitOps funktioniert. Wie verifiziere ich die Ergebnisse?\n\n![Chat-Prompt mit mehreren Fragen und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image27_aHR0cHM6_1750097645354.png)\n\n### 4. Setze auf eine kontextarme Kommunikation \n\nGib so viel Kontext an, wie für eine Antwort erforderlich ist. In manchen Fällen bietet der bisherige Verlauf oder der geöffnete Quellcode nicht diesen hilfreichen Kontext. Um Fragen effizienter zu gestalten, kannst du ein Muster von [kontextarmer Kommunikation](https://handbook.gitlab.com/handbook/company/culture/all-remote/effective-communication/#understanding-low-context-communication) (nur in englischer Sprache verfügbar) anwenden, das in der All-Remote-Kommunikation im Rahmen von GitLab verwendet wird.\n\nDie folgende Frage hat nicht genügend Kontext in einem C++-Projekt bereitgestellt.\n\n> Should I use virtual override instead of just override? (Sollte ich eine virtuelle Überschreibung anstelle einer einfachen Überschreibung verwenden?)\n\n![Chat-Prompt zur Frage nach der Verwendung einer virtuellen Überschreibung anstelle einer einfachen Überschreibung und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image34_aHR0cHM6_1750097645354.png)\n\nVersuche stattdessen, mehr Kontext hinzuzufügen:\n\n> When implementing a pure virtual function in an inherited class, should I use virtual function override, or just function override? Context is C++. (Sollte ich bei der Implementierung einer reinen virtuellen Funktion in einer geerbten Klasse eine virtuelle Funktionsüberschreibung oder nur eine einfache Funktionsüberschreibung nutzen? Der Kontext ist C++.) \n\n![Chat-Prompt mit mehr Details und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image36_aHR0cHM6_1750097645355.png)\n\nDas Beispiel findest du auch im englischsprachigen Video [GitLab Duo Coffee Chat: Refactor C++ functions into OOP classes for abstract database handling (GitLab Duo Coffee Chat: C++-Funktionen in OOP-Klassen umwandeln für abstrakte Datenbankverwaltung)](https://youtu.be/Z9EJh0J9358?t=2190). \n\n### 5. Wiederhole dich\n\nDie KI ist nicht berechenbar. In manchen Fällen kann es sein, dass sie nicht mit den erwarteten Ergebnissen antwortet oder keine Quellcode-Beispiele oder Konfigurations-Schnipsel erzeugt, weil sie keinen Kontext hatte. Du solltest die Frage wiederholen und die Anforderungen verfeinern.\n\nIm folgenden Beispiel möchten wir eine C#-Anwendung erstellen. Beim ersten Versuch haben wir den Anwendungstyp nicht angegeben – C# kann verwendet werden, um Konsolen-/Terminal-, aber auch UI-Anwendungen zu erstellen. Wir bekommen außerdem keinen leeren Beispiel-Quellcode als Antwort. Der zweite, wiederholte Prompt fügt zwei weitere Wörter hinzu: `console` und `empty`. \n\n> How can I get started creating an C# application in VS Code? (Wie kann ich mit dem Erstellen einer C#-Anwendung in VS Code beginnen?)\n> \n> How can I get started creating an empty C# console application in VS Code? (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen?)\n\nDie Ergebnisse im Prompt unterscheiden sich. Die erste Antwort ist für den Anfang hilfreich, da man den Anweisungen im VS-Code-Fenster folgen kann, aber sie sagt uns nicht, wo sich der Quellcode befindet und wie man ihn ändert. Durch den zweiten, verfeinerten Prompt wird die Antwort modifiziert und bietet jetzt Anweisungen, wie man die Standardvorlage mit „Hallo Welt”-Code überschreibt.\n\n![Chat-Prompts mit wiederholtem Prompt mit Modifikationen und Antworten](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image28_aHR0cHM6_1750097645355.png)\n\nDu kannst auch Wiederholungs- und Verfeinerungsstrategien miteinander kombinieren und Chat auffordern, ein Beispiel für Anwendungscode und Tests anzuzeigen.\n\n> How can I get started creating an empty C# console application in VS Code? Please show an example for application and tests. (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige ein Beispiel für die Anwendung und Tests.)\n\n![Chat-Prompt, der ein Beispiel für die Anwendung und Tests anfordert und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097645356.png)\n\n#### Wiederhole dich nach allgemeinen Fragen \n\nGitLab Duo Chat kann bei allgemeinen technischen Fragen möglicherweise nicht weiterhelfen. Im folgenden Szenario wollte ich einen Vorschlag für Java-Build-Tools und ein Framework erhalten, was jedoch nicht funktioniert hat. Es gibt viele mögliche Antworten: Maven, Gradle usw. als Build-Tools und [über 100 Java-Frameworks](https://en.wikipedia.org/wiki/List_of_Java_frameworks) (nur in englischer Sprache verfügbar), die vom Technologie-Stack und den jeweiligen Anforderungen abhängen.\n\n![Chat-Prompt für die Frage nach Java-Build-Tools und einem Framework und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097645356.png)\n\nNehmen wir einmal an, wir wollen uns auf eine Kundenumgebung mit [Java Spring Boot](https://spring.io/projects/spring-boot) konzentrieren. \n\n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel.)\n\n![Chat-Prompt, der mehr anfordert, einschließlich eines Hallo-Welt-Beispiels und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image26_aHR0cHM6_1750097645357.png)\n\nDies allein liefert bereits hervorragende Ergebnisse. Wiederhole den Prompt als asynchrone Übung und frage, wie man die Anwendung bereitstellt, wobei du bei jedem Schritt weitere Verfeinerungen ergänzt. Alternativ kannst du ein Folgegespräch daraus machen.\n\n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. Show how to build and deploy the application in CI/CD. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel. Zeige, wie man die Anwendung in CI/CD erstellt und bereitstellt.)\n> \n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. Show how to build and deploy the application in CI/CD, using container images. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel. Zeige, wie man die Anwendung in CI/CD mit Container-Images erstellet und bereitstellt.)\n> \n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. Show how to build and deploy the application in CI/CD, using container images. Use Kubernetes and GitOps in GitLab. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel. Zeige, wie man die Anwendung in CI/CD mit Container-Images erstellet und bereitstellt. Verwende Kubernetes und GitOps in GitLab.)\n\n### 6. Sei geduldig\n\nEinzelne Wörter oder kurze Sätze führen möglicherweise nicht zu den gewünschten Ergebnissen, [wie in diesem englischsprachigen Videobeispiel gezeigt wird](https://youtu.be/JketELxLNEw?t=1220). Manchmal kann GitLab Duo Chat anhand der verfügbaren Daten eine Einschätzung treffen, besteht aber bisweilen auch darauf, dass mehr Kontext bereitgestellt wird.\n\nBeispiel: `labels` entspricht dem Inhalt der GitLab-Dokumentation.\n\n![Chat-Prompt zu Labels und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image12_aHR0cHM6_1750097645357.png)\n\nPräzisiere die Frage im Hinblick auf die Problembeschreibungen und weitere Spezifizierungen für die Verwendung in der Ticketübersicht.\n\n> Explain labels in GitLab. Provide an example for efficient usage with issue boards. (Erkläre Labels in GitLab. Gib ein Beispiel für die effiziente Verwendung in Ticketübersichten.)\n\n![Chat-Prompt mit der Frage nach einem Beispiel und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image21_aHR0cHM6_1750097645358.png)\n\nOder verwende eine Problembeschreibung, gefolgt von einer Frage, und bitte um weitere Beispiele.\n\n> I don't know how to use labels in GitLab. Please provide examples, and how to use them for filters in different views. Explain these views with examples. (Ich weiß nicht, wie man Labels in GitLab verwendet. Bitte gib Beispiele an und wie man sie für Filter in verschiedenen Ansichten verwendet. Erkläre diese Ansichten mit Beispielen.)\n\n![Chat-Prompt mit Problembeschreibung und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750097645358.png)\n\nVermeide ferner `Ja/Nein`-Fragen und ergänze stattdessen einen spezifischen Kontext.\n\n> Can you help me fix performance regressions? (Kannst du mir helfen, Leistungseinbrüche zu beheben?)\n\n![Chat-Prompt mit der Bitte um Hilfe bei der Behebung von Leistungseinbrüchen und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image18_aHR0cHM6_1750097645359.png)\n\nGib stattdessen den Kontext des Leistungseinbruchs an, einschließlich der Programmiersprachen, Frameworks, des Technologie-Stacks und der Umgebungen. Im folgenden Beispiel wird eine etwas ältere Umgebung verwendet, die auch heute noch korrekt sein kann.\n\n> My PHP application encounters performance regressions using PHP 5.6 and MySQL 5.5. Please explain potential root causes, and how to address them. The app is deployed on Linux VMs. (Meine PHP-Anwendung stößt mit PHP 5.6 und MySQL 5.5 auf Leistungseinbrüche. Bitte erkläre mögliche Grundursachen und wie ich sie beheben kann. Die App wird auf Linux-VMs bereitgestellt.)\n\n![Chat-Prompt mit mehr Details und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image24_aHR0cHM6_1750097645360.png)\n\n### 7. Verwerfe alles und fang von vorn an\n\nManchmal zeigt der Chat-Verlauf eine andere Lernkurve und liefert den falschen Kontext für Folgefragen. Oder du hast spezifische Fragen gestellt, bei denen GitLab Duo Chat keine Antworten geben kann. Da generative KI nicht vorhersehbar ist, kann es auch sein, dass sie nicht in der Lage ist, bestimmte Beispiele zu geben, aber glaubt in einer zukünftigen Antwort, dass sie diese doch genannt hat (beobachtet in der Beta von Chat). Die zugrunde liegenden großen Sprachmodelle oder LLMs bestehen manchmal darauf, eine bestimmte Antwort in einer Endlosschleife auszugeben.\n\n> How can I get started creating an empty C# console application in VS Code? Please show a .gitignore and .gitlab-ci.yml configuration with steps for C#, and add security scanning for GitLab. Explain how solutions and projects in C# work, and how to add a test project on the CLI. (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige eine .gitignore- und .gitlab-ci.yml-Konfiguration mit Schritten für C# an und füge Sicherheitsscans für GitLab hinzu. Erkläre, wie Lösungen und Projekte in C# funktionieren und wie man ein Testprojekt über die CLI hinzufügt.)\n\nNachdem ich die obige Frage mit einer Beispielkonfiguration gestellt hatte, wollte ich den Umfang der Frage eingrenzen, um eine zielgerichtete Antwort zu erhalten. Dies hat nicht wie erwartet funktioniert, da Chat den Chat-Verlauf in diesem Kontext kennt und sich daher auf frühere Antworten bezieht.\n\n> How can I get started creating an empty C# console application in VS Code? Please show a .gitignore and .gitlab-ci.yml configuration with steps for C#. (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige eine .gitignore- und .gitlab-ci.yml-Konfiguration mit Schritten für C# an.)\n\n![Chat-Prompt mit der Frage nach Konfigurationsbeispielen und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image23_aHR0cHM6_1750097645360.png)\n\nUm Chat in einen neuen Kontext zu zwingen, verwendest du den Befehl `/reset` als Slash-Befehl, um die Sitzung zurückzusetzen, und wiederholst die Frage, um bessere Ergebnisse zu erzielen. Du kannst auch `/clean` oder `/clear` verwenden, um alle Nachrichten in diesem Gespräch zu löschen.\n\n### 8. Steigere in der IDE mit Slash-Befehlen deine Effizienz \n\n#### Code erklären\n\n- F: Generierter Code? Bestehender Code? Legacy-Code?\n- A: Verwende den [Slash-Befehl `/explain` in der IDE](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html#explain-code-in-the-ide) (nur in englischer Sprache verfügbar).\n- A2: Präzisiere den Prompt mit gezielteren Antworten, zum Beispiel: `/explain focus on potential shortcomings or bugs` (/explain mit Fokus auf mögliche Fehler oder Bugs).\n\n![Chat-Prompt mit Slash-Befehl /explain](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/gitlab_duo_chat_slash_commands_explain_01_aHR0cHM6_1750097645361.png).\n\n![Chat-Prompt mit präzisiertem Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097645361.png)\n\n#### Code refaktorisieren \n\n- F: Unlesbarer Code? Langer Spaghetti-Code? Keinerlei Testabdeckung?\n- A: Verwende den Slash-Befehl [`/refactor` in der IDE](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html#refactor-code-in-the-ide) (nur in englischer Sprache verfügbar).\n- A2: Präzisiere den Prompt für gezieltere Aktionen, zum Beispiel mit objektorientierten Mustern: `/refactor into object-oriented classes with methods and attributes` (/refactor in objektorientierte Klassen mit Methoden und Attributen).\n\n![Chat-Prompt mit Slash-Befehl /refactor](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image35_aHR0cHM6_1750097645362.png)\n\n![Chat-Prompt mit präzisiertem Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image30_aHR0cHM6_1750097645362.png)\n\n#### Tests generieren\n\n- F: Testbarer Code, aber das Schreiben von Tests dauert zu lange?\n- A: Verwende den Slash-Befehl [`/tests` in der IDE](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html#write-tests-in-the-ide) (nur in englischer Sprache verfügbar).\n- A2: Präzisiere den Prompt für bestimmte Test-Frameworks oder Testziele. Du kannst mit dem Prompt auch anweisen, dass der Fokus auf der Refaktorierung liegen soll, und dann Tests zu generieren: `/tests focus on refactoring the code into functions, and generate tests` (/tests mit Fokus auf das Refaktorieren des Codes in Funktionen und das Erstellen von Tests).\n\n![Chat-Prompt mit Slash-Befehl /tests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image29_aHR0cHM6_1750097645363.png)\n\n![Chat-Prompt mit präzisiertem Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097645363.png)\n\nWeitere praktische Beispiele für vollständige Entwicklungsworkflows befinden sich in der Dokumentation [GitLab-Duo-Beispiele](https://docs.gitlab.com/ee/user/gitlab_duo_examples.html) (nur in englischer Sprache verfügbar).\n\n### 9. Präzisiere den Prompt für Slash-Befehle \n\nIn diesem Blogbeitrag findest du viele Tipps für verfeinerte Prompts. Sie gehören zu den Zutaten für eine bessere KI-basierte Workflow-Effizienz. Slash-Befehle sind nichts anderes und ermöglichen bessere Ergebnisse in GitLab Duo Chat.\n\nEin Kunde hat kürzlich gefragt: „Kann ich mit Codeerläuterungen mit `/explain` Kommentare im Code erstellen?“ Die Antwort lautet: Nein. Aber du kannst den Chat-Prompt verwenden, um Folgefragen zu stellen und eine Zusammenfassung in einem Code-Kommentarformat anzufordern. Dafür ist der Kontext der Sprache erforderlich. \n\nDas folgende Beispiel für den [Code für einen HTTP-Client in C++, der die Curl-Bibliothek verwendet](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-prompts/-/blob/5cc9bdd65ee8ee16c548bea0402c18f8209d4d06/chat/slash-commands/c++/cli.cpp) benötigt eine ausführlichere Dokumentation. Du kannst den `/explain`-Prompt verfeinern, wenn du präzisiertere Anweisungen gibst, um den Code zu erklären, indem du Codekommentare hinzufügst, und diese anschließend kopierst und in den Editor einfügst.\n\n> /explain add documentation, rewrite the code snippet (/explain Füge Dokumentation hinzu, ändere die Code-Schnipsel)\n\n![Chat-Prompt zum Hinzufügen der Dokumentation und zum Umschreiben von Code-Schnipeln und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image13_aHR0cHM6_1750097645363.png)\n\nAlternativ kannst du Chat über einen verfeinerten Prompt mit `/refactor` auffordern, den Quellcode zu refaktorisieren, und fehlende Code-Kommentare zu generieren.\n\n> /refactor add code comments and documentation (/refactor Füge Code-Kommentare und eine Dokumentation hinzu)\n\n![Chat-Prompt für die Refaktorisierung von Quellcode und Generierung von Code-Kommentaren](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image15_aHR0cHM6_1750097645364.png)\n\n### 10. Werde bei den Slash-Befehlen kreativ\n\nWenn der Chat-Prompt keine Antwort auf eine Frage zum Quellcode oder zur Programmiersprache kennt, kannst du dir die Slash-Befehle `/explain`, `/refactor` und `/tests` näher ansehen und prüfen, wie hilfreich sie in dem Kontext wären.\n\nIm folgenden Beispiel wird eine SQL-Abfragezeichenfolge in C++ in einer einzelnen Zeile erstellt. Um die Lesbarkeit zu verbessern und in Zukunft weitere Datenbankspalten hinzuzufügen, kann es hilfreich sein, die Formatierung in einen mehrzeiligen String zu ändern.\n\n> std::string sql = \"CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL)\";\n\nDu kannst GitLab Duo Chat zum Beispiel mit der folgenden Frage darum bitten:\n\n> How to create a string in C++ using multiple lines? (Wie erstelle ich einen String in C++ mit mehreren Zeilen?)\n\nChat kann mit einer Erklärung und einem optionalen Quellcode-Beispiel antworten. In diesem Zusammenhang könnte es die Frage so interpretieren, dass ein C++-String-Wert mit mehreren Zeilen erstellt wird, zum Beispiel mit dem Zeichen `\\n`, das einer Variablen zugewiesen ist. \n\nDie Anforderung ist allerdings, nur den geschriebenen Code und die Zuweisung der Variablenwerte in mehreren Zeilen zu formatieren. Der String-Wert selbst benötigt keine mehrzeilige String-Darstellung.\n\nEs gibt eine Alternative für zusätzlichen Kontext in VS Code und der Web IDE: Wähle den betreffenden Quellcode aus, klicke mit der rechten Maustaste und navigiere zu `GitLab Duo Chat > Refaktorisieren`. Das öffnet den Chat-Prompt und löst sofort die Code-Aufgabe `/refactor` aus.\n\nAllerdings kann es sein, dass die Code-Aufgabe nicht die erwarteten Ergebnisse hervorbringt. Das Refaktorisieren einer einzeiligen SQL-Zeichenfolge kann in vielerlei Hinsicht Bedeutung haben: Verwendung mehrerer Zeilen für die Lesbarkeit, Erstellung von Konstanten usw.\n\nMit Code-Aufgaben kannst du den Prompt verfeinern. Du kannst nach dem Befehl `/refactor` mehr Text hinzufügen und GitLab Duo Chat anweisen, einen bestimmten Code-Typ, Algorithmus oder ein Entwurfsmuster zu verwenden. \n\nVersuchen wir es noch einmal: Wähle den Quellcode aus, gehe zurück zu Chat und gib den folgenden Prompt ein, gefolgt von der `Eingabetaste`.\n\n> /refactor into a multi-line written string. Show different approaches for all C++ standards. (/refactor in einen mehrzeilig geschriebenen String. Zeige verschiedene Ansätze für alle C++-Standards.)\n\n![Chat-Prompt für die Refaktorisierung in einen mehrzeilig geschriebenen String und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image17_aHR0cHM6_1750097645364.png)\n\n**Tipp:** Du kannst GitLab Duo Code Suggestions verwenden, um den Quellcode nach dem Refaktorisieren noch weiter zu optimieren, oder alternative Verfeinerungen des `/refactor`-Prompts nutzen.\n\n>/refactor into a multi-line written string, show different approaches (/refactor in einen mehrzeilig geschriebenen String. Zeige verschiedene Ansätze)\n>\n> /refactor into multi-line string, not using raw string literals (/refactor in einen mehrzeiligen String ohne Verwendung von rohen String-Literalen)\n>\n> /refactor into a multi-line written string. Make the table name parametrizable (/refactor in einen mehrzeilig geschriebenen String. Der Name der Tabelle muss parametrisierbar sein.)\n\nEin alternativer Ansatz mit dem Typ `stringstream` wird im [MR-Diff](https://gitlab.com/gitlab-da/use-cases/ai/gitlab-duo-coffee-chat/gitlab-duo-coffee-chat-2024-01-23/-/commit/7ea233138aed46d77e6ce0d930dd8e10560134eb#4ce01e4c84d4b62df8eed159c2db3768ad4ef8bf_33_35) dieses englischsprachigen Videos gezeigt: [GitLab Duo Coffee Chat: Refactor C++ functions into OOP classes for abstract database handling (GitLab Duo Coffee Chat: C++-Funktionen in OOP-Klassen umwandeln für abstrakte Datenbankverwaltung)](https://www.youtube.com/watch?v=Z9EJh0J9358).\n\n#### Sicherheitslücken erläutern\n\nDiese Methode funktioniert möglicherweise nicht in jedem Fall, aber über den Slash-Befehl `/explain` kann auch nach der Erläuterung von Sicherheitslücken gefragt werden. In diesem Beispiel enthält der [C-Code](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-prompts/-/blob/5a5f293dfbfac7222ca4013d8f9ce9b462e4cd3a/chat/slash-commands/c/vuln.c) mehrere Sicherheitslücken für strcpy()-Pufferüberläufe, global überschreibbare Dateiberechtigungen, Race-Condition-Angriffe und mehr.\n\n> /explain why this code has multiple vulnerabilities (/explain warum weit dieser Code mehrere Sicherheitslücken auf)\n\n![Chat-Prompt über mehrere Sicherheitslücken des Codes](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image20_aHR0cHM6_1750097645365.png)\n\n#### C-Code in Rust refaktorisieren\n\nRust bietet Speichersicherheit. Mit dem Befehl `/refactor into Rust` kannst du Duo Chat dazu auffordern, den anfälligen [C-Code](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-prompts/-/blob/5a5f293dfbfac7222ca4013d8f9ce9b462e4cd3a/chat/slash-commands/c/vuln.c) in Rust zu refaktorisieren. Übe mit präzisierteren Prompts, um bessere Ergebnisse zu erzielen.\n\n> /refactor into Rust and use high level libraries (/refactor in Rust und verwende High-Level-Bibliotheken)\n\n![Chat-Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097645366.png)\n\n### Shortcuts \n\nProbiere diese Shortcuts in deiner Umgebung aus und übe asynchron mithilfe von GitLab Duo Chat.\n\n1. Prüfe anfälligen Code aus CVEs und frage mit `/explain why is this code vulnerable` (/explain warum ist dieser Code anfällig) was er tut und wie er korrigiert werden kann. \n**Tipp:** Importiere Open-Source-Projekte in GitLab, um die Vorteile der Code-Erläuterung von GitLab Duo Chat zu nutzen.\n2. Versuche, den Code in neue Programmiersprachen zu refaktorisieren. Dies ist bei Legacy-Code-Migrationsplänen hilfreich.\n3. Du kannst auch versuchen, die Jenkins-Konfiguration in GitLab CI/CD zu refaktorisieren, indem du den Slash-Befehl `/refactor into GitLab CI/CD configuration` (/refactor in die GitLab CI/CD-Konfiguration) verwendest. \n\n### Unterhaltsame Übungen \n\nVersuche Chat dazu zu bringen, sich wie Clippy zu verhalten.\n![Chat-Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image22_aHR0cHM6_1750097645366.png)\n\nFrage nach der Mission von GitLab: „Jede(r) kann etwas beitragen.”\n\n![Chat-Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image33_aHR0cHM6_1750097645367.png)\n\n### Weitere Informationen\n\nEs gibt viele verschiedene Umgebungen und Herausforderungen. Wir haben die [Dokumentation von GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) mit weiteren praktischen Beispielen aktualisiert und einen neuen Abschnitt [GitLab-Duo-Beispiele](https://docs.gitlab.com/ee/user/gitlab_duo_examples.html) (Dokumentation nur in englischer Sprache verfügbar) mit detaillierten Einblicken in KI-basierte DevSecOps-Workflows, einschließlich Chat, hinzugefügt.\n\nDas Erlernen von GitLab Duo funktioniert am besten durch spielerische Herausforderungen und echten Produktionscode. Die neue Lernreihe GitLab Duo Coffee Chat wird sehr bald fortgesetzt. Bis dahin kannst du dir die englischsprachigen Aufnahmen in [dieser YouTube-Playlist](https://www.youtube.com/playlist?list=PL05JrBw4t0Kp5uj_JgQiSvHw1jQu0mSVZ) ansehen. Wenn du Kunde oder Kundin von GitLab bist und an einem GitLab Duo Coffee Chat teilnehmen möchtest, um gemeinsam zu lernen, dann melde dich in [diesem Planungs-Epic](https://gitlab.com/groups/gitlab-com/marketing/developer-relations/-/epics/476). \n\n> Möchtest du mit GitLab Duo Chat loslegen? [Starte noch heute deine kostenlose Testversion](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/).\n",[683,688,686,685],"2025-04-22",{"slug":1182,"featured":93,"template":692},"10-best-practices-for-using-ai-powered-gitlab-duo-chat","content:de-de:blog:10-best-practices-for-using-ai-powered-gitlab-duo-chat.yml","10 Best Practices For Using Ai Powered Gitlab Duo Chat","de-de/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat.yml","de-de/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat",{"_path":1188,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1189,"content":1195,"config":1202,"_id":1204,"_type":16,"title":1205,"_source":18,"_file":1206,"_stem":1207,"_extension":21},"/de-de/blog/learn-advanced-rust-programming-with-a-little-help-from-ai-code-suggestions",{"title":1190,"description":1191,"ogTitle":1190,"ogDescription":1191,"noIndex":6,"ogImage":1192,"ogUrl":1193,"ogSiteName":674,"ogType":675,"canonicalUrls":1193,"schema":1194},"Lerne fortschrittliche Rust-Programmierung mit KI-Unterstützung","In diesem Tutorial vertiefst du mithilfe der KI-basierten Codevorschläge von GitLab Duo deine Kenntnisse in der fortgeschrittenen Rust-Programmierung.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662439/Blog/Hero%20Images/codewithheart.png","https://about.gitlab.com/blog/learn-advanced-rust-programming-with-a-little-help-from-ai-code-suggestions","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Lerne fortschrittliche Rust-Programmierung mit KI-Unterstützung\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"}],\n        \"datePublished\": \"2023-10-12\",\n      }",{"title":1190,"description":1191,"authors":1196,"heroImage":1192,"date":1197,"body":1198,"category":14,"tags":1199,"updatedDate":1201},[972],"2023-10-12","Vor mehr als 20 Jahren musste ich für eine Programmiersprache die MSDN-Bibliothek von Visual Studio 6 mit 6 CD-ROMs installieren. Algorithmen mit Stift und Papier, Bücher für Entwurfsmuster und MSDN-Abfragen waren oft zeitaufwendig. Das Erlernen neuer Programmiersprachen hat sich mit Remote-Zusammenarbeit und KI stark gewandelt. Jetzt kannst du einen [Remote Development Workspace](https://about.gitlab.com/blog/quick-start-guide-for-gitlab-workspaces/) nutzen, deinen Bildschirm freigeben und zusammen programmieren. Mit [GitLab Duo Codevorschläge](/gitlab-duo/) hast du immer einen intelligenten Partner. Codevorschläge lernt von deinem Programmierstil und deiner Erfahrung. Es werden nur Input und Kontext benötigt.\n\nWir bauen auf den [Blogbeitrag „Erste Schritte“](/blog/learning-rust-with-a-little-help-from-ai-code-suggestions-getting-started/) auf und erstellen eine einfache Feed-Reader-Anwendung.\n\n- [Vorbereitungen](#preparations)\n    - [Codevorschläge](#code-suggestions)\n- [Rust vertiefen](#continue-learning-rust)\n    - [Hallo, Reader-App](#hello-reader-app)\n    - [Projekt initialisieren](#initialize-project)\n    - [RSS-Feed-URLs definieren](#define-rss-feed-urls)\n- [Module](#modules)\n    - [Modulfunktion im main() aufrufen](#call-the-module-function-in-main)\n- [Crates](#crates)\n    - [feed-rs: XML-Feed parsen](#feed-rs-parse-xml-feed)\n- [Laufzeit-Konfiguration: Programmargumente](#runtime-configuration-program-arguments)\n    - [Umgang mit Benutzereingabefehlern](#user-input-error-handling)\n- [Persistenz und Datenspeicherung](#persistence-and-data-storage)\n- [Optimierung](#optimization)\n    - [Asynchrone Ausführung](#asynchronous-execution)\n    - [Threads spawnen](#spawning-threads)\n    - [Funktionsumfänge, Threads und Abschlüsse](#function-scopes-threads-and-closures)\n- [Feed-XML in Objekte parsen](#parse-feed-xml-into-object-types)\n    - [Generische Feed-Datentypen zuordnen](#map-generic-feed-data-types)\n    - [Fehlerbehebung mit Option::unwrap()](#error-handling-with-option-unwrap)\n- [Benchmarks](#benchmarks)\n    - [Benchmarks für sequentielle/parallele Ausführung](#sequential-vs-parallel-execution-benchmark)\n    - [CI/CD mit Rust-Caching](#cicd-with-rust-caching)\n- [Wie geht es weiter?](#what-is-next)\n    - [Asynchrone Lernübungen](#async-learning-exercises)\n    - [Teile dein Feedback](#share-your-feedback)\n\n## Vorbereitung\nRichte [VS Code](/blog/learning-rust-with-a-little-help-from-ai-code-suggestions-getting-started/#vs-code) und [deine Entwicklungsumgebung mit Rust](/blog/learning-rust-with-a-little-help-from-ai-code-suggestions-getting-started/#development-environment-for-rust) ein.\n\n### Codevorschläge\nMache dich vorher damit vertraut. GitLab Duo Codevorschläge werden angezeigt, während du tippst. Drücke `tab`, um einen Codevorschlag anzunehmen. Das Schreiben von neuem Code funktioniert zuverlässiger als das Refactoring von bestehendem Code. Der gleiche Codevorschlag wird ggf. nicht erneut angezeigt, wenn du einen Codevorschlag löschst. Codevorschläge sind gerade in der Betaphase und wir verbessern die Genauigkeit der generierten Inhalte. Sieh dir die [bekannten Einschränkungen](https://docs.gitlab.com/ee/user/project/repository/code_suggestions.html#known-limitations) an.\n\n**Tipp:** Die neueste Version von Codevorschläge unterstützt mehrzeilige Anweisungen. Passe die Spezifikationen an deine Bedürfnisse an, um bessere Vorschläge zu erhalten.\n\n\n```rust\n    // Create a function that iterates over the source array\n    // and fetches the data using HTTP from the RSS feed items. // Store the results in a new hash map.\n    // Print the hash map to the terminal.\n```\n\nDie VS-Code-Erweiterung wird angezeigt, wenn ein Vorschlag angeboten wird. Mit `tab` kannst du die vorgeschlagene(n) Zeile(n) oder mit `cmd cursor right` ein Wort annehmen. Über das Menü mit den drei Punkten kannst du immer die Symbolleiste anzeigen.\n\n![VS Code überlagert GitLab Duo Codevorschläge mit Anweisungen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_code_suggestions_options_overlay_keep_toolbar.png){: .shadow}\n\n## Rust vertiefen\nVertiefen wir nun Rust, eine der [unterstützten Sprachen in Codevorschläge](https://docs.gitlab.com/ee/user/project/repository/code_suggestions.html#supported-languages). [Rust by Example](https://doc.rust-lang.org/rust-by-example/) und das offizielle [Rust-Buch](https://doc.rust-lang.org/book/) bieten einen guten Einstieg. Auf beide Ressourcen wird hier verwiesen.\n\n### Hallo, Reader-App\nEs gibt viele Möglichkeiten, eine Anwendung zu erstellen und Rust zu lernen. Einige beinhalten die Nutzung bestehender Rust-Bibliotheken, der `Crates`. Wir verwenden sie weiter unten. Du kannst eine App mit einer Befehlszeile erstellen, die Bilder verarbeitet und die Ergebnisse in eine Datei schreibt. Es macht Spaß, ein Labyrinth zu lösen oder ein Sudoku-Lösungsprogramm zu schreiben. Spieleentwicklung ist auch gut. Das Buch [Hands-on Rust](https://hands-on-rust.com/) bietet einen Lernpfad für ein Dungeon-Crawler-Spiel. Fatima Sarah Khalid hat [Dragon Realm in C++ mit ein wenig KI-Unterstützung](/blog/building-a-text-adventure-using-cplusplus-and-code-suggestions/) gestartet.\n\nEin echter Anwendungsfall: Wichtige Infos sollen in einem RSS-Feed für (Sicherheits-)Releases, Blogbeiträge und Diskussionen in Foren wie Hacker News gesammelt werden. Oft möchten wir nach Keywords oder Versionen filtern. Mit diesen Anforderungen können wir eine Anforderungsliste erstellen:\n\n1. Daten von verschiedenen Quellen abrufen (HTTP-Websites, REST API, RSS-Feeds). RSS-Feeds in der ersten Iteration.\n1. Die Daten parsen.\n1. Die Daten den Benutzer(innen) präsentieren oder auf die Festplatte schreiben.\n1. Die Leistung optimieren.\n\nDiese Anwendungsausgabe ist nach den Lernschritten verfügbar: \n\n![VS-Code-Terminal, Cargo-Run mit formatierter Feedelement-Ausgabe](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_terminal_cargo_run_formatted_output_final.png)\n\nDie Anwendung sollte modular und die Grundlage für weitere Datentypen, Filter und Hooks sein, um später Aktionen auszulösen.\n\n### Projekt initialisieren\nZur Erinnerung: `cargo init` im Projekt-Root erstellt die Dateistruktur, darunter den Eingangspunkt `main()`. Daher lernen wir nun, wie wir Rust-Module erstellen und verwenden.\n\nErstelle ein neues Verzeichnis `learn-rust-ai-app-reader`, wechsle dorthin und führe `cargo init` aus. Dieser Befehl führt implizit `git init` aus, um ein neues Git-Repository lokal zu initialisieren. Zuletzt wird der Git-Remote-Repository-Pfad konfiguriert, z. B. `https://gitlab.com/gitlab-de/use-cases/ai/learn-with-ai/learn-rust-ai-app-reader`. Passe den Pfad an. Durch das Pushen des Git-Repositorys [wird automatisch ein neues privates Projekt in GitLab erstellt](https://docs.gitlab.com/ee/user/project/#create-a-new-project-with-git-push).\n\n```shell\nmkdir learn-rust-ai-app-reader\ncd learn-rust-ai-app-reader\n\ncargo init\n\ngit remote add origin https://gitlab.com/gitlab-de/use-cases/ai/learn-with-ai/learn-rust-ai-app-reader.git\ngit push --set-upstream origin main\n```\n\nÖffne VS Code aus dem neu erstellten Verzeichnis. Die CLI `code` öffnet ein neues VS-Code-Fenster auf macOS.\n\n```shell\ncode .\n```\n\n### RSS-Feed-URLs definieren\nFüge eine neue Hashmap hinzu, um die RSS-Feed-URLs in der Datei `src/main.rs` in der Funktion `main()` zu speichern. Du kannst mit GitLab Duo Codevorschläge über einen mehrzeiligen Kommentar ein [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html)-Objekt erstellen und mit Standardwerten für Hacker News und TechCrunch initialisieren. Hinweis: Stelle sicher, dass die URLs korrekt sind, wenn du Vorschläge erhältst.\n\n```rust\nfn main() {\n    // Define RSS feed URLs in the variable rss_feeds\n    // Use a HashMap\n    // Add Hacker News and TechCrunch\n    // Ensure to use String as type\n\n}\n```\n\nAnweisungen sind enthalten für:\n:\n\n1. Den Variablennamen `rss_feeds`.\n2. Den Typ `HashMap`.\n3. Initiale Seed-Schlüssel-/Wertpaare.\n4. Den String als Typ (sichtbar mit `to_string()`-Aufrufen).\n\nEin möglicher vorgeschlagener Pfad:\n\n```rust\nuse std::collections::HashMap;\n\nfn main() {\n    // Define RSS feed URLs in the variable rss_feeds\n    // Use a HashMap\n    // Add Hacker News and TechCrunch\n    // Ensure to use String as type\n    let rss_feeds = HashMap::from([\n        (\"Hacker News\".to_string(), \"https://news.ycombinator.com/rss\".to_string()),\n        (\"TechCrunch\".to_string(), \"https://techcrunch.com/feed/\".to_string()),\n    ]);\n\n}\n```\n\n![VS Code mit Codevorschlägen für RSS-Feed-URLs für Hacker News und TechCrunch](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_main_array_rss_feed_urls_suggested.png)\n\nÖffne ein neues Terminal in VS Code (cmd Umschalt p – suche nach `terminal`). Führe `cargo build` aus, um die Änderungen zu erstellen. Die Fehlermeldung weist dich an, den Import von `use std::collections::HashMap;` hinzuzufügen.\n\nDer nächste Schritt betrifft die RSS-Feed-URLs. [Im letzten Blogbeitrag](/blog/learning-rust-with-a-little-help-from-ai-code-suggestions-getting-started/) haben wir Code in Funktionen aufgeteilt. Wir möchten den Code für unsere Reader-Anwendung modular mit Rust-Modulen strukturieren.\n\n## Module\n[Module](https://doc.rust-lang.org/rust-by-example/mod.html) organisieren Code. Mit ihnen können auch Funktionen im Modulbereich ausgeblendet und der Zugriff darauf vom Bereich main() aus beschränkt werden. In unserer Reader-Anwendung möchten wir den RSS-Feed abrufen/XML-Antwort parsen. Der Caller `main()` sollte nur auf die Funktion `get_feeds()` zugreifen können, andere Funktionen sind nur im Modul verfügbar.\n\nErstelle eine neue Datei `feed_reader.rs` im Verzeichnis `src/`. Weise Codevorschläge an, ein öffentliches Modul `feed_reader` und eine öffentliche Funktion `get_feeds()` mit einer String-HashMap als Eingabe zu erstellen. Wichtig: Die Datei- und Modulnamen müssen gemäß der [Rust-Modulstruktur](https://doc.rust-lang.org/book/ch07-02-defining-modules-to-control-scope-and-privacy.html) identisch sein.\n\n![Codevorschläge: öffentliches Modul mit Funktions- und Eingabetypen erstellen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_public_module_function_input.png){: .shadow}\n\nWenn du Codevorschläge mit Namen/Typ der Eingabevariablen anweist, wird auch das Modul `std::collections::HashMap` importiert. Tipp: Experimentiere mit Kommentaren und verfeinere die Variablentypen. Die Übergabe von Funktionsparametern als Objektreferenzen gilt in Rust als Best Practice.\n\n```rust\n// Create public module feed_reader\n// Define get_feeds() function which takes rss_feeds as String HashMap reference as input\npub mod feed_reader {\n    use std::collections::HashMap;\n\n    pub fn get_feeds(rss_feeds: &HashMap\u003CString, String>) {\n        // Do something with the RSS feeds\n    }\n}\n```\n\n![Codevorschläge: öffentliches Modul mit Funktion `get_feeds()` und vorgeschlagener Eingabevariable](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_public_module_function_input.png){: .shadow}\n\nWeise Codevorschläge innerhalb der Funktion weiter an:\n\n1. `// Iterate over the RSS feed URLs`\n2. `// Fetch URL content`\n3. `// Parse XML body`\n4. `// Print the result`\n\n![Codevorschläge: öffentliches Modul mit Funktion `get_feeds()`, Schritt 1: iterieren](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_module_function_01_iterate.png){: .shadow}\n\n![Codevorschläge: öffentliches Modul mit Funktion `get_feeds()`, Schritt 2: URL-Inhalt abrufen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_module_function_02_fetch_content.png){: .shadow}\n\n![Codevorschläge: öffentliches Modul mit Funktion`get_feeds()`, Schritt 3: XML-Body parsen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_module_function_03_parse_body.png){: .shadow}\n\n![Codevorschläge: öffentliches Modul mit Funktion`get_feeds()`, Schritt 4: Ergebnisse drucken](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_module_function_04_print_result.png){: .shadow}\n\nCodevorschlag:\n\n```rust\n// Create public module feed_reader\n// Define get_feeds() function which takes rss_feeds as String HashMap reference as input\npub mod feed_reader {\n    use std::collections::HashMap;\n\n    pub fn get_feeds(rss_feeds: &HashMap\u003CString, String>) {\n        // Iterate over the RSS feed URLs\n        for (name, url) in rss_feeds {\n            println!(\"{}: {}\", name, url);\n\n            // Fetch URL content\n            let body = reqwest::blocking::get(url).unwrap().text().unwrap();\n\n            // Parse XML body\n            let parsed_body = roxmltree::Document::parse(&body).unwrap();\n\n            // Print the result\n            println!(\"{:#?}\", parsed_body);\n        }\n    }\n}\n```\n\nDu siehst ein neues Keyword: [`unwrap()`](https://doc.rust-lang.org/rust-by-example/error/option_unwrap.html). Rust unterstützt keine `null`-Werte und verwendet immer den [Typ `Option`](https://doc.rust-lang.org/rust-by-example/std/option.html). Wenn du einen bestimmten wrapped-Typ verwenden willst, z. B. `Text` oder `String`, rufe die Methode `unwrap()` auf, um den Wert zu erhalten. Methode `unwrap()` gerät bei Wert `None` in Panik.\n\n**Hinweis** Codevorschläge bezogen sich auf Funktion `reqwest:: blocking::get` für Kommentaranweisung `// Fetch URL content`. [Crate `reqwest`](https://docs.rs/reqwest/latest/reqwest/) ist kein Tippfehler. Sie bietet einen praktischen, übergeordneten HTTP-Client für asynchrone und blockierende Anfragen.\n\nParsen des XML-Textes ist schwierig. Du erhältst ggf. unterschiedliche Ergebnisse, das Schema ist nicht für jede RSS-Feed-URL gleich. Rufen wir die Funktion `get_feeds()` auf und verbessern den Code.\n\n### Modulfunktion in main() aufrufen\n\nFunktion main() kennt Funktion `get_feeds()` noch nicht, wir müssen ihr Modul importieren. Evtl. kennst du schon die Keywords `include` oder `import`. Das Rust-Modulsystem ist anders.\n\nModule sind in Pfadverzeichnissen organisiert. Hier liegen beide Quelldateien auf derselben Verzeichnisebene vor. `feed_reader.rs` wird als Crate interpretiert, die ein Modul `feed_reader` enthält, das Funktion `get_feeds()` definiert.\n\n```\nsrc/\n  main.rs\n  feed_reader.rs\n```\n\nUm auf `get_feeds()` aus Datei `feed_reader.rs` zuzugreifen, müssen wir den [Modulpfad](https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html) in den Bereich `main.rs` bringen, dann den vollständigen Funktionspfad aufrufen.\n\n```rust\nmod feed_reader;\n\nfn main() {\n\n    feed_reader::feed_reader::get_feeds(&rss_feeds);\n\n```\n\nAlternativ können wir den vollständigen Funktionspfad mit Keyword `use` importieren und später den kurzen Funktionsnamen verwenden.\n\n```rust\nmod feed_reader;\nuse feed_reader::feed_reader::get_feeds;\n\nfn main() {\n\n    get_feeds(&rss_feeds);\n\n```\n\n**Tipp:** Lies den Blogbeitrag [Erklärung des Rust-Modulsystems](https://www.sheshbabu.com/posts/rust-module-system/) für ein besseres visuelles Verständnis.\n\n```diff\n\nfn main() {\n    // ...\n\n    // Print feed_reader get_feeds() output\n    println!(\"{}\", feed_reader::get_feeds(&rss_feeds));\n```\n\n```rust\nuse std::collections::HashMap;\n\nmod feed_reader;\n// Alternative: Import full function path\n//use feed_reader::feed_reader::get_feeds;\n\nfn main() {\n    // Define RSS feed URLs in the variable rss_feeds\n    // Use a HashMap\n    // Add Hacker News and TechCrunch\n    // Ensure to use String as type\n    let rss_feeds = HashMap::from([\n        (\"Hacker News\".to_string(), \"https://news.ycombinator.com/rss\".to_string()),\n        (\"TechCrunch\".to_string(), \"https://techcrunch.com/feed/\".to_string()),\n    ]);\n\n    // Call get_feeds() from feed_reader module\n    feed_reader::feed_reader::get_feeds(&rss_feeds);\n    // Alternative: Imported full path, use short path here.\n    //get_feeds(&rss_feeds);\n}\n```\n\nFühre `cargo build` erneut im Terminal aus, um den Code zu erstellen.\n\n```shell\ncargo build\n```\n\nPotenzielle Build-Fehler, wenn sich Codevorschläge auf allgemeinen Code und Bibliotheken für HTTP-Anfragen und XML-Parsing beziehen:\n\n1. Fehler: `could not find blocking in reqwest`. Lösung: Aktiviere Funktion `blocking` für Crate in `Config.toml`: `reqwest = { version = \"0.11.20\", features = [\"blocking\"] }`.\n2. Fehler: `failed to resolve: use of undeclared crate or module reqwest`. Lösung: Füge Crate `reqwest` hinzu.\n3. Fehler: `failed to resolve: use of undeclared crate or module roxmltree`. Lösung: Füge Crate `roxmltree` hinzu.\n\n```shell\nvim Config.toml\n\nreqwest = { version = \"0.11.20\", features = [\"blocking\"] }\n```\n\n```shell\ncargo add reqwest\ncargo add roxmltree\n```\n\n**Tipp:** Kopiere den Fehlermeldungs-String mit einem führenden `Rust \u003Cerror message>` in einen Browser, um zu sehen, ob eine fehlende Crate verfügbar ist. Allgemein führt diese Suche zu einem Ergebnis auf crates.io und du kannst die fehlenden Abhängigkeiten hinzufügen.\n\nWenn der Build erfolgreich ist, führe den Code mit `cargo run` aus und überprüfe die RSS-Feed-Ausgabe von Hacker News.\n\n![VS-Code-Terminal, cargo run zum Abrufen des XML-Feeds von Hacker News](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_terminal_fetch_rss_feed_output_hacker_news.png){: .shadow}\n\nWie kann der XML-Body in ein für Menschen lesbares Format geparst werden? Als Nächstes lernen wir über bestehende Lösungen und Rust-Crates.\n\n## Crates\n\nRSS-Feeds haben gemeinsame Protokolle und Spezifikationen. Es fühlt sich an, als würde man das Rad neu erfinden, wenn man XML-Elemente parsen und die untere Objektstruktur verstehen will. Empfehlung: Schau nach, ob es dieses Problem samt Code schon gibt.\n\nDer wiederverwendbare Bibliothekscode in Rust ist in [`Crates`](https://doc.rust-lang.org/rust-by-example/crates.html) organisiert und in Paketen/der Paket-Registry auf crates.io verfügbar. Füge diese Abhängigkeiten hinzu, indem du die Datei `Config.toml` im Abschnitt `[dependencies]` bearbeitest oder `cargo add \u003Cname>` verwendest.\n\nFür die Reader-App verwenden wir [Feed-rs-Crate](https://crates.io/crates/feed-rs). Öffne ein neues Terminal, führe folgenden Befehl aus:\n\n```shell\ncargo add feed-rs\n```\n\n![VS-Code-Terminal: Crate hinzufügen, in Config.toml überprüfen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_rust_crate_add_feed-rs_explained.png)\n\n### feed-rs: XML-Feed parsen\nGehe zu `src/feed_reader.rs`, ändere den Teil, in dem wir den XML-Body parsen. Codevorschläge versteht, wie Crate `feed-rs` mit Funktion `parser::parse` aufgerufen wird, aber `feed-rs` [erwartet die String-Eingabe als Rohbytes](https://docs.rs/feed-rs/latest/feed_rs/parser/fn.parse_with_uri.html), um die Codierung selbst zu bestimmen. Wir können im Kommentar Anweisungen geben, um das erwartete Ergebnis zu erhalten.\n\n```rust\n            // Parse XML body with feed_rs parser, input in bytes\n            let parsed_body = feed_rs::parser::parse(body.as_bytes()).unwrap();\n```\n\n![Codevorschläge: öffentliches Modul mit Funktion `get_feeds()`, Schritt 5: XML-Parser in feed-rs ändern](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_module_function_05_use_feed_rs_to_parse.png){: .shadow}\n\nDen Vorteil von `feed-rs` siehst du im Ausdruck mit `cargo run`: Alle Schlüssel/Werte werden ihren jeweiligen Rust-Objekttypen zugeordnet und können für weitere Operationen verwendet werden.\n\n![VS-Code-Terminal, cargo run zum Abrufen des XML-Feeds von Hacker News](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_terminal_fetch_rss_feed_output_hacker_news_feed_rs.png){: .shadow}\n\n## Laufzeit-Konfiguration: Programmargumente\nBisher haben wir das Programm mit hardcoded RSS-Feed-Werten ausgeführt, die in die Binärdatei kompiliert wurden. Jetzt wird der RSS-Feed zur Laufzeit konfiguriert.\n\nRust stellt in der Standard-Misc-Bibliothek [Programmargumente](https://doc.rust-lang.org/rust-by-example/std_misc/arg.html) bereit. [Argumente parsen](https://doc.rust-lang.org/rust-by-example/std_misc/arg/matching.html) ist besser und schneller als das Zielen auf erweiterte Programmargument-Parser (z. B. die Crate [clap](https://docs.rs/clap/latest/clap/)) oder das Verschieben der Programmparameter in eine Konfigurationsdatei/ein Format ([TOML](https://toml.io/en/), YAML). Vor diesem Blog habe ich Verschiedenes für die beste Lernerfahrung ausprobiert und versagt. Du kannst trotzdem versuchen, RSS-Feeds anders zu konfigurieren.\n\nAls langweilige Lösung können Befehlsparameter als `\"name,url\"` String-Wert-Paare übergeben und durch das `,`-Zeichen getrennt werden, um den Namen und die URL-Werte zu extrahieren. Der Kommentar weist Codevorschläge an, diese Vorgänge auszuführen und die HashMap `rss_feeds` um die neuen Werte zu erweitern. Die Variable ist möglicherweise nicht veränderbar und muss in `let mut rss_feeds` geändert werden.\n\nGehe zu `src/main.rs` und füge der Funktion `main()` nach der Variable `rss_feeds` diesen Code hinzu. Beginne mit einem Kommentar, um die Programmargumente zu definieren, überprüfe die vorgeschlagenen Codeschnipsel.\n\n```rust\n    // Program args, format \"name,url\"\n    // Split value by , into name, url and add to rss_feeds\n```\n\n![Codevorschläge für Programmargumente und Aufteilung von name,URL-Werten für die Variable rss_feeds](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_program_args_boring_solution.png){: .shadow}\n\nVollständiges Codebeispiel:\n\n```rust\nfn main() {\n    // Define RSS feed URLs in the variable rss_feeds\n    // Use a HashMap\n    // Add Hacker News and TechCrunch\n    // Ensure to use String as type\n    let mut rss_feeds = HashMap::from([\n        (\"Hacker News\".to_string(), \"https://news.ycombinator.com/rss\".to_string()),\n        (\"TechCrunch\".to_string(), \"https://techcrunch.com/feed/\".to_string()),\n    ]);\n\n    // Program args, format \"name,url\"\n    // Split value by , into name, url and add to rss_feeds\n    for arg in std::env::args().skip(1) {\n        let mut split = arg.split(\",\");\n        let name = split.next().unwrap();\n        let url = split.next().unwrap();\n        rss_feeds.insert(name.to_string(), url.to_string());\n    }\n\n    // Call get_feeds() from feed_reader module\n    feed_reader::feed_reader::get_feeds(&rss_feeds);\n    // Alternative: Imported full path, use short path here.\n    //get_feeds(&rss_feeds);\n}\n```\n\nDu kannst Programmargumente direkt an den Befehl `cargo run` übergeben, wobei den Argumenten `--` vorgestellt ist.\n `--`. Füge alle Argumente mit doppelten Anführungszeichen und den Namen gefolgt von einem Komma und den RSS-Feed-URL als Argument ein. Trenne alle Argumente mit Leerzeichen.\n\n```\ncargo build\n\ncargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n```\n\n![VS-Code-Terminal, Beispiel einer RSS-Feed-Ausgabe für den GitLab-Blog](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_terminal_gitlab_blog_rss_feed_example.png){: .shadow}\n\n### Fehlerbehandlung bei Benutzereingaben\nWenn die Benutzereingabe nicht der Programmerwartung entspricht, müssen wir [einen Fehler ausgeben](https://doc.rust-lang.org/rust-by-example/error.html) und dem Caller helfen, die Programmargumente zu beheben. Die Übergabe eines fehlerhaften URL-Formats sollte als Laufzeitfehler behandelt werden. Weise Codevorschläge an, einen Fehler auszugeben, wenn die URL nicht gültig ist.\n\n```rust\n    // Ensure that URL contains a valid format, otherwise throw an error\n```\n\nMögliche Lösung: Beginnt die Variable `url` mit `http://` oder `https://`? Wenn nicht, gib einen Fehler mit dem Makro [Panic! ](https://doc.rust-lang.org/rust-by-example/std/panic.html) aus. Vollständiges Codebeispiel:\n\n```rust\n    // Program args, format \"name,url\"\n    // Split value by , into name, url and add to rss_feeds\n    for arg in std::env::args().skip(1) {\n        let mut split = arg.split(\",\");\n        let name = split.next().unwrap();\n        let url = split.next().unwrap();\n\n        // Ensure that URL contains a valid format, otherwise throw an error\n        if !url.starts_with(\"http://\") && !url.starts_with(\"https://\") {\n            panic!(\"Invalid URL format: {}\", url);\n        }\n\n        rss_feeds.insert(name.to_string(), url.to_string());\n    }\n```\n\nTeste, was passiert, wenn du ein `:` in einem URL-String entfernst. Füge die Umgebungsvariable `RUST_BACKTRACE=full` hinzu, um beim Aufruf von `panic()` eine ausführlichere Ausgabe zu erhalten.\n\n```\nRUST_BACKTRACE=full cargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https//www.cncf.io/feed/\"\n```\n\n![VS-Code-Terminal mit falschem URL-Format, panic-Fehler-Backtrace](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_terminal_url_format_error_panic_backtrace.png){: .shadow}\n\n## Persistenz und Datenspeicherung\nBei der langweiligen Lösung zum Speichern der Feed-Daten wird der geparste Body in eine neue Datei kopiert. Weise Codevorschläge an, ein Muster zu verwenden, das den RSS-Feed-Namen und das aktuelle ISO-Datum enthält.\n\n```rust\n    // Parse XML body with feed_rs parser, input in bytes\n    let parsed_body = feed_rs::parser::parse(body.as_bytes()).unwrap();\n\n    // Print the result\n    println!(\"{:#?}\", parsed_body);\n\n    // Dump the parsed body to a file, as name-current-iso-date.xml\n    let now = chrono::offset::Local::now();\n    let filename = format!(\"{}-{}.xml\", name, now.format(\"%Y-%m-%d\"));\n    let mut file = std::fs::File::create(filename).unwrap();\n    file.write_all(body.as_bytes()).unwrap();\n```\nEin möglicher Vorschlag ist die Verwendung der [Crate chrono](https://crates.io/crates/chrono). Füge sie mit `cargo add chrono` hinzu, rufe wieder `cargo build` und `cargo run` auf.\n\nDie Dateien werden in das gleiche Verzeichnis geschrieben, in dem `cargo run` ausgeführt wurde. Wenn du die Binärdatei direkt im Verzeichnis `target/debug/` ausführst, werden alle Dateien dort abgelegt.\n\n![VS-Code mit CNCF-RSS-Feed-Inhaltsdatei, auf Festplatte gespeichert](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_cncf_rss_feed_saved_on_disk.png)\n\n## Optimierung\nDie Einträge in der Variable `rss_feeds` werden nacheinander ausgeführt. Bei einer Liste mit über 100 konfigurierten URLs kann das Abrufen und Verarbeiten lange dauern. Was wäre, wenn Abrufanforderungen parallel ausgeführt würden?\n\n### Asynchrone Ausführung\nRust stellt [Threads](https://doc.rust-lang.org/book/ch16-01-threads.html) für die asynchrone Ausführung bereit.\n\nBei der einfachsten Lösung wird für jede RSS-Feed-URL ein Thread erstellt. Wir sprechen später über Optimierungsstrategien. Vor der parallelen Ausführung musst du die Ausführungszeit des sequentiellen Codes mit dem Befehl `cargo run` vor `time` messen.\n\n\n```\ntime cargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n\n0.21s user 0.08s system 10% cpu 2.898 total\n```\n\nBeachte, dass diese Übung mehr manuelle Codearbeit erfordern könnte. Empfehlung: Den sequentiellen Arbeitszustand in einem neuen Git-Commit und einem neuen Git-Branch `sequential-exec` beibehalten, um die Auswirkungen der parallelen Ausführung besser zu vergleichen.\n\n```shell\ngit commit -avm \"Sequential execution working\"\ngit checkout -b sequential-exec\ngit push -u origin sequential-exec\n\ngit checkout main\n```\n\n### Threads spawnen\nÖffne `src/feed_reader.rs` und refaktorisiere die Funktion `get_feeds()`. Beginne mit einem Git-Commit für den aktuellen Status und lösche dann den Inhalt des Funktionsbereichs. Füge die folgenden Codekommentare hinzu:\n\n1. `// Store threads in vector`: Speichere die Thread-Alias in einem Vektor, damit wir warten können, bis sie am Ende des Funktionsaufrufs abgeschlossen sind.\n2. `// Loop over rss_feeds and spawn threads`: Erstelle Boilerplate-Code für die Iteration über alle RSS-Feeds und einen neuen Thread.\n\nFüge die folgenden `use`-Anweisungen hinzu, um mit den Modulen `thread` und `time` zu arbeiten.\n\n```rust\n    use std::thread;\n    use std::time::Duration;\n```\n\nSchreibe den Code weiter, schließe die for-Schleife. Codevorschläge schlägt dann automatisch vor, das Thread-Alias in der Vektorvariable `threads` hinzuzufügen und bietet an, den Threads am Ende der Funktion beizutreten.\n\n```rust\n    pub fn get_feeds(rss_feeds: &HashMap\u003CString, String>) {\n\n        // Store threads in vector\n        let mut threads: Vec\u003Cthread::JoinHandle\u003C()>> = Vec::new();\n\n        // Loop over rss_feeds and spawn threads\n        for (name, url) in rss_feeds {\n            let thread_name = name.clone();\n            let thread_url = url.clone();\n            let thread = thread::spawn(move || {\n\n            });\n            threads.push(thread);\n        }\n\n        // Join threads\n        for thread in threads {\n            thread.join().unwrap();\n        }\n    }\n```\n\nFüge die Crate `thread` hinzu, erstelle den Code, führe ihn erneut aus.\n\n```shell\ncargo add thread\n\ncargo build\n\ncargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n```\n\nZu diesem Zeitpunkt werden keine Daten verarbeitet oder gedruckt. Bevor wir die Funktion erneut hinzufügen, informieren wir uns über die neu eingeführten Keywords.\n\n### Funktionsumfänge, Threads und Closures\nMit dem vorgeschlagenen Code gilt es neue Keywords und Designmuster zu erlernen. Der Thread-Alias hat den Typ `thread:: JoinHandle`, wir können also warten, bis die Threads ([join()](https://doc.rust-lang.org/book/ch16-01-threads.html#waiting-for-all-threads-to-finish-using-join-handles)) beendet haben.\n\n`thread::spawn()` erstellt einen neuen Thread, in dem wir ein Funktionsobjekt übergeben können. In diesem Fall wird der Ausdruck [closure](https://doc.rust-lang.org/book/ch13-01-closures.html) als anonyme Funktion übergeben. Closure-Eingaben werden mit der Syntax `||` übergeben. Du erkennst den [Closure `move`](https://doc.rust-lang.org/book/ch16-01-threads.html#using-move-closures-with-threads), der die Variablen des Funktionsbereichs in den Thread-Bereich verschiebt. Dadurch wird die manuelle Angabe vermieden, welche Variablen in den neuen Funktions-/Closure-Bereich übergeben werden müssen.\n\nEinschränkung: `rss_feeds` ist eine Referenz `&`, die vom Funktions-Caller `get_feeds()` als Parameter übergeben wird. Die Variable ist nur im Funktionsbereich gültig. Provoziere diesen Fehler mit diesem Codeausschnitt:\n\n```rust\npub fn get_feeds(rss_feeds: &HashMap\u003CString, String>) {\n\n    // Store threads in vector\n    let mut threads: Vec\u003Cthread::JoinHandle\u003C()>> = Vec::new();\n\n    // Loop over rss_feeds and spawn threads\n    for (key, value) in rss_feeds {\n        let thread = thread::spawn(move || {\n            println!(\"{}\", key);\n        });\n    }\n}\n```\n\n![VS-Code-Terminal, Fehler im Variablenbereich mit Referenzen und Thread-Verschiebungs-Closure](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_terminal_cargo_build_error_function_threads_variable_scopes.png){: .shadow}\n\nObwohl die Variable `key` im Funktionsbereich erstellt wurde, verweist sie auf die Variable `rss_feeds` und kann nicht in den Thread-Bereich verschoben werden. Werte, auf die über den Funktionsparameter `rss_feeds` zugegriffen wird, erfordern eine lokale Kopie mit `clone()`.\n\n![VS-Code-Terminal, Thread-Spawn mit Klon](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_rust_thread_spawn_clone.png){: .shadow}\n\n```rust\npub fn get_feeds(rss_feeds: &HashMap\u003CString, String>) {\n\n    // Store threads in vector\n    let mut threads: Vec\u003Cthread::JoinHandle\u003C()>> = Vec::new();\n\n    // Loop over rss_feeds and spawn threads\n    for (name, url) in rss_feeds {\n        let thread_name = name.clone();\n        let thread_url = url.clone();\n        let thread = thread::spawn(move || {\n            // Use thread_name and thread_url as values, see next chapter for instructions.\n```\n\n## Feed-XML in Objekttypen parsen\nAls Nächstes werden die Schritte für das Parsen des RSS-Feeds im Thread-Closure wiederholt. Füge folgende Codekommentare hinzu:\n\n1. `// Parse XML body with feed_rs parser, input in bytes`. Damit rufst du den Inhalt der RSS-Feed-URL ab und parst ihn mit den Crate-Funktionen `feed_rs`.\n2. `// Check feed_type attribute feed_rs::model::FeedType::RSS2 or Atom and print its name`: Extrahiere den Feed-Typ, indem du das Attribut `feed_type` mit dem [`feed_rs::model::FeedType`](https://docs.rs/feed-rs/latest/feed_rs/model/enum.FeedType.html) vergleichst. Dazu braucht Codevorschläge Anweisungen, in denen die genauen ENUM-Werte für den Abgleich angegeben werden.\n\n![Weise Codevorschläge an, mit bestimmten Feed-Typen abzugleichen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_feed_rs_type_condition.png){: .shadow}\n\n```rust\n            // Parse XML body with feed_rs parser, input in bytes\n            let body = reqwest::blocking::get(thread_url).unwrap().bytes().unwrap();\n            let feed = feed_rs::parser::parse(body.as_ref()).unwrap();\n\n            // Check feed_type attribute feed_rs::model::FeedType::RSS2 or Atom and print its name\n            if feed.feed_type == feed_rs::model::FeedType::RSS2 {\n                println!(\"{} is an RSS2 feed\", thread_name);\n            } else if feed.feed_type == feed_rs::model::FeedType::Atom {\n                println!(\"{} is an Atom feed\", thread_name);\n            }\n```\n\nErstelle das Programm und führe es erneut aus. Überprüfe die Ausgabe.\n\n```\ntime cargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n\nCNCF is an RSS2 feed\nTechCrunch is an RSS2 feed\nGitLab Blog is an Atom feed\nHacker News is an RSS2 feed\n```\n\nWir überprüfen diese Ausgabe: Öffne die Feed-URLs im Browser oder sieh die heruntergeladenen Dateien an.\n\nHacker News unterstützt RSS-Version 2.0 mit `channel(title,link,description,item(title,link,pubDate,comments))`. TechCrunch und der CNCF-Blog haben eine ähnliche Struktur.\n```xml\n\u003Crss version=\"2.0\">\u003Cchannel>\u003Ctitle>Hacker News\u003C/title>\u003Clink>https://news.ycombinator.com/\u003C/link>\u003Cdescription>Links for the intellectually curious, ranked by readers.\u003C/description>\u003Citem>\u003Ctitle>Writing a debugger from scratch: Breakpoints\u003C/title>\u003Clink>https://www.timdbg.com/posts/writing-a-debugger-from-scratch-part-5/\u003C/link>\u003CpubDate>Wed, 27 Sep 2023 06:31:25 +0000\u003C/pubDate>\u003Ccomments>https://news.ycombinator.com/item?id=37670938\u003C/comments>\u003Cdescription>\u003C![CDATA[\u003Ca href=\"https://news.ycombinator.com/item?id=37670938\">Comments\u003C/a>]]>\u003C/description>\u003C/item>\u003Citem>\n```\n\nIm GitLab-Blog wird das [Atom](https://datatracker.ietf.org/doc/html/rfc4287)-Feed-Format verwendet, das RSS zwar ähnlich ist, aber eine andere Parsing-Logik erfordert.\n```xml\n\u003C?xml version='1.0' encoding='utf-8' ?>\n\u003Cfeed xmlns='http://www.w3.org/2005/Atom'>\n\u003C!-- / Get release posts -->\n\u003C!-- / Get blog posts -->\n\u003Ctitle>GitLab\u003C/title>\n\u003Cid>https://about.gitlab.com/blog\u003C/id>\n\u003Clink href='https://about.gitlab.com/blog/' />\n\u003Cupdated>2023-09-26T00:00:00+00:00\u003C/updated>\n\u003Cauthor>\n\u003Cname>The GitLab Team\u003C/name>\n\u003C/author>\n\u003Centry>\n\u003Ctitle>Atlassian Server ending: Goodbye disjointed toolchain, hello DevSecOps platform\u003C/title>\n\u003Clink href='https://about.gitlab.com/blog/atlassian-server-ending-move-to-a-single-devsecops-platform/' rel='alternate' />\n\u003Cid>https://about.gitlab.com/blog/atlassian-server-ending-move-to-a-single-devsecops-platform/\u003C/id>\n\u003Cpublished>2023-09-26T00:00:00+00:00\u003C/published>\n\u003Cupdated>2023-09-26T00:00:00+00:00\u003C/updated>\n\u003Cauthor>\n\u003Cname>Dave Steer, Justin Farris\u003C/name>\n\u003C/author>\n```\n\n### Generische Feed-Datentypen zuordnen\nMit [`roxmltree::Document::parse`](https://docs.rs/roxmltree/latest/roxmltree/struct.Document.html) müssten wir den XML-Knotenbaum und dessen spezifische Tag-Namen verstehen. Glücklicherweise bietet [feed_rs::model::Feed](https://docs.rs/feed-rs/latest/feed_rs/model/struct.Feed.html) ein kombiniertes Modell für RSS- und Atom-Feeds. Wir verwenden daher die Crate `feed_rs` weiter.\n\n1. Atom: Feed->Feed, Eintrag->Eintrag\n2. RSS: Kanal->Feed, Element->Eintrag\n\nZusätzlich zur obigen Zuordnung müssen wir die erforderlichen Attribute extrahieren und deren Datentypen zuordnen. Es ist hilfreich, [die Dokumentation für feed_rs::model](https://docs.rs/feed-rs/latest/feed_rs/model/index.html) zu öffnen, um die Strukturen und ihre Felder sowie Implementierungen zu verstehen. Andernfalls würden einige Vorschläge zu Fehlern bei der Typkonvertierung und Kompilierungsfehlern führen, die für die Implementierung von `feed_rs` spezifisch sind.\n\nEine [`Feed`](https://docs.rs/feed-rs/latest/feed_rs/model/struct.Feed.html)-Struktur liefert den `title`, Typ `Option\u003CText>` (entweder ist ein Wert festgelegt oder nichts). Eine [`Entry`](https://docs.rs/feed-rs/latest/feed_rs/model/struct.Entry.html)-Struktur bietet:\n\n1. `title`: `Option\u003CText>`mit [`Text`](https://docs.rs/feed-rs/latest/feed_rs/model/struct.Text.html) und dem Feld `content` als `String`.\n2. `updated`: `Option\u003CDateTime\u003CUtc>>` mit [`DateTime`](https://docs.rs/chrono/latest/chrono/struct.DateTime.html) mit der [`format()`-Methode](https://docs.rs/chrono/latest/chrono/struct.DateTime.html#method.format).\n3. `summary`: `Option\u003CText>` [`Text`](https://docs.rs/feed-rs/latest/feed_rs/model/struct.Text.html) und das Feld `content` als `String`.\n4. `links`: `Vec\u003CLink>`, Vektor mit [`Link`](https://docs.rs/feed-rs/latest/feed_rs/model/struct.Link.html)-Elementen. Das Attribut `href` liefert die rohe URL-Zeichenfolge.\n\nNutze dieses Wissen, um die erforderlichen Daten aus den Feed-Einträgen zu extrahieren. Zur Erinnerung: Alle `Option`-Typen müssen `unwrap()` aufrufen und erfordert weitere rohe Anweisungen für Codevorschläge.\n\n```rust\n                // https://docs.rs/feed-rs/latest/feed_rs/model/struct.Feed.html\n                // https://docs.rs/feed-rs/latest/feed_rs/model/struct.Entry.html\n                // Loop over all entries, and print\n                // title.unwrap().content\n                // published.unwrap().format\n                // summary.unwrap().content\n                // links href as joined string\n                for entry in feed.entries {\n                    println!(\"Title: {}\", entry.title.unwrap().content);\n                    println!(\"Published: {}\", entry.published.unwrap().format(\"%Y-%m-%d %H:%M:%S\"));\n                    println!(\"Summary: {}\", entry.summary.unwrap().content);\n                    println!(\"Links: {:?}\", entry.links.iter().map(|link| link.href.clone()).collect::\u003CVec\u003CString>>().join(\", \"));\n                    println!();\n                }\n```\n\n![Codevorschläge zum Drucken von Feed-Eintragstypen mit spezifischen Anforderungen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_print_feed_entries_fields_with_rust_type_specifics.png){: .shadow}\n\n### Fehlerbehandlung mit der Option unwrap()\nWiederhole die mehrzeiligen Anweisungen, nachdem du das Programm erstellt und erneut ausgeführt hast. Spoiler: `unwrap()` ruft das Makro `panic!` auf und lässt das Programm abstürzen, wenn es auf leere Werte stößt. Dies kann passieren, wenn ein Feld wie `summary` in den Feed-Daten nicht festgelegt ist.\n\n```shell\nGitLab Blog is an Atom feed\nTitle: How the Colmena project uses GitLab to support citizen journalists\nPublished: 2023-09-27 00:00:00\nthread '\u003Cunnamed>' panicked at 'called `Option::unwrap()` on a `None` value', src/feed_reader.rs:40:59\n```\nMögliche Lösung: [`std::Option::unwrap_or_else`](https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap_or_else) verwenden und einen leeren String als Standardwert festlegen. Die Syntax erfordert einen Closure, der eine leere `Text`-Strukturinstanziierung zurückgibt.\n\nEs waren viele Versuche nötig, um die richtige Initialisierung zu finden. Das Übergeben nur einer leeren Zeichenfolge funktionierte nicht mit benutzerdefinierten Typen. Ich zeige dir, was ich versucht habe.\n\n```rust\n// Problem: The `summary` attribute is not always initialized. unwrap() will panic! then.\n// Requires use mime; and use feed_rs::model::Text;\n/*\n// 1st attempt: Use unwrap() to extraxt Text from Option\u003CText> type.\nprintln!(\"Summary: {}\", entry.summary.unwrap().content);\n// 2nd attempt. Learned about unwrap_or_else, passing an empty string.\nprintln!(\"Summary: {}\", entry.summary.unwrap_or_else(|| \"\").content);\n// 3rd attempt. summary is of the Text type, pass a new struct instantiation.\nprintln!(\"Summary: {}\", entry.summary.unwrap_or_else(|| Text{}).content);\n// 4th attempt. Struct instantiation requires 3 field values.\nprintln!(\"Summary: {}\", entry.summary.unwrap_or_else(|| Text{\"\", \"\", \"\"}).content);\n// 5th attempt. Struct instantation with public fields requires key: value syntax\nprintln!(\"Summary: {}\", entry.summary.unwrap_or_else(|| Text{content_type: \"\", src: \"\", content: \"\"}).content);\n// 6th attempt. Reviewed expected Text types in https://docs.rs/feed-rs/latest/feed_rs/model/struct.Text.html and created Mime and String objects\nprintln!(\"Summary: {}\", entry.summary.unwrap_or_else(|| Text{content_type: mime::TEXT_PLAIN, src: String::new(), content: String::new()}).content);\n// 7th attempt: String and Option\u003CString> cannot be casted automagically. Compiler suggested using `Option::Some()`.\nprintln!(\"Summary: {}\", entry.summary.unwrap_or_else(|| Text{content_type: mime::TEXT_PLAIN, src: Option::Some(), content: String::new()}).content);\n*/\n\n// xth attempt: Solution. Option::Some() requires a new String object.\nprintln!(\"Summary: {}\", entry.summary.unwrap_or_else(|| Text{content_type: mime::TEXT_PLAIN, src: Option::Some(String::new()), content: String::new()}).content);\n```\n\nDies war nicht zufriedenstellend, da die Codezeile kompliziert ist und manuelle Arbeit ohne Codevorschläge erforderte. Ich ging also einen Schritt zurück: Wenn `Option` `none` ist, gibt `unwrap()` einen Fehler  aus. Ich fragte Codevorschläge in einem neuen Kommentar:\n\n```\n                // xth attempt: Solution. Option::Some() requires a new String object.\n                println!(\"Summary: {}\", entry.summary.unwrap_or_else(|| Text{content_type: mime::TEXT_PLAIN, src: Option::Some(String::new()), content: String::new()}).content);\n\n                // Alternatively, use Option.is_none()\n```\n\n![Codevorschläge hat nach Alternativen gefragt, wenn Options.is_none](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/code_suggestions_after_complex_unwrap_or_else_ask_for_alternative_option.png){: .shadow}\n\nErgebnis: erhöhte Lesbarkeit, weniger CPU-Zyklen, die mit `unwrap()` verschwendet wurden, und eine Lernkurve .\n\nDenke daran: Füge das Speichern der XML-Daten auf der Festplatte erneut hinzu, um die Reader-App erneut abzuschließen.\n\n```rust\n                // Dump the parsed body to a file, as name-current-iso-date.xml\n                let file_name = format!(\"{}-{}.xml\", thread_name, chrono::Local::now().format(\"%Y-%m-%d-%H-%M-%S\"));\n                let mut file = std::fs::File::create(file_name).unwrap();\n                file.write_all(body.as_ref()).unwrap();\n```\n\nErstelle das Programm, führe es aus, um die Ausgabe zu überprüfen.\n\n```shell\ncargo build\n\ntime cargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n```\n\n![VS-Code-Terminal, cargo run mit formatierter Ausgabe von Feed-Einträgen](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/vs_code_terminal_cargo_run_formatted_output_final.png)\n\n## Benchmarks\n\n### Benchmarks für sequentielle vs. parallele Ausführung\nVergleiche die Ausführungszeit-Benchmarks, indem du jeweils fünf Samples erstellst.\n\n1. Sequentielle Ausführung. [Beispiel-Quellcode MR](https://gitlab.com/gitlab-de/use-cases/ai/learn-with-ai/learn-rust-ai-app-reader/-/merge_requests/1)\n2. Parallele Ausführung. [Beispiel-Quellcode MR](https://gitlab.com/gitlab-de/use-cases/ai/learn-with-ai/learn-rust-ai-app-reader/-/merge_requests/3)\n\n```shell\n# Sequential\ngit checkout sequential-exec\n\ntime cargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n\n0.21s user 0.08s system 10% cpu 2.898 total\n0.21s user 0.08s system 11% cpu 2.585 total\n0.21s user 0.09s system 10% cpu 2.946 total\n0.19s user 0.08s system 10% cpu 2.714 total\n0.20s user 0.10s system 10% cpu 2.808 total\n```\n\n```shell\n# Parallel\ngit checkout parallel-exec\n\ntime cargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n\n0.19s user 0.08s system 17% cpu 1.515 total\n0.18s user 0.08s system 16% cpu 1.561 total\n0.18s user 0.07s system 17% cpu 1.414 total\n0.19s user 0.08s system 18% cpu 1.447 total\n0.17s user 0.08s system 16% cpu 1.453 total\n```\n\nDie CPU-Nutzung ist bei der parallelen Ausführung von vier RSS-Feed-Threads gestiegen, hat aber die Gesamtzeit fast halbiert. Wenn wir dies beachten, können wir unsere Kenntnisse von Rust vertiefen und den Code und die Funktionalität optimieren.\n\nBeachte, dass wir den Debug-Build über Cargo ausführen und noch nicht über die optimierten veröffentlichten Builds. Einschränkungen bei der parallelen Ausführung: Einige HTTP-Endpunkte haben Ratenbegrenzungen eingeführt.\n\nDas System, das mehrere Threads parallel ausführt, könnte ebenfalls überlastet werden – Threads erfordern einen Kontextwechsel im Kernel und weisen jedem Thread Ressourcen zu. Während ein Thread Rechenressourcen erhält, werden andere Threads in den Ruhezustand versetzt. Wenn zu viele Threads gespawned werden, kann dies das System verlangsamen, anstatt den Vorgang zu beschleunigen. Lösungen umfassen Entwurfsmuster wie [Arbeitswarteschlangen](https://docs.rs/work-queue/latest/work_queue/), bei denen der Caller eine Aufgabe in eine Warteschlange einfügt und eine definierte Anzahl von Worker-Threads die Aufgaben für die asynchrone Ausführung aufnimmt.\n\nRust bietet auch eine Datensynchronisation zwischen Threads, sogenannten [Channels](https://doc.rust-lang.org/rust-by-example/std_misc/channels.html). Um einen gleichzeitigen Datenzugriff zu gewährleisten, stehen [mutexes](https://doc.rust-lang.org/std/sync/struct.Mutex.html) zur Verfügung, die sichere Sperren bieten.\n\n### CI/CD mit Rust-Caching\nFüge die folgende CI/CD-Konfiguration in die Datei `.gitlab-ci.yml` ein. Der Job `run-latest` ruft `cargo run` mit URL-Beispielen für RSS-Feeds auf und misst die Ausführungszeit kontinuierlich.\n\n```\nstages:\n  - build\n  - test\n  - run\n\ndefault:\n  image: rust:latest\n  cache:\n    key: ${CI_COMMIT_REF_SLUG}\n    paths:\n      - .cargo/bin\n      - .cargo/registry/index\n      - .cargo/registry/cache\n      - target/debug/deps\n      - target/debug/build\n    policy: pull-push\n\n# Cargo data needs to be in the project directory for being cached.\nvariables:\n  CARGO_HOME:${CI_PROJECT_DIR}/.cargo\n\nbuild-latest:\n  stage: build\n  script:\n    - cargo build --verbose\n\ntest-latest:\n  stage: build\n  script:\n    - cargo test --verbose\n\nrun-latest:\n  stage: run\n  script:\n    - time cargo run -- \"GitLab Blog,https://about.gitlab.com/atom.xml\" \"CNCF,https://www.cncf.io/feed/\"\n```\n\n![GitLab-CI/CD-Pipelines für Rust, Cargo-Run-Ausgabe](https://about.gitlab.com/images/blogimages/learn-rust-with-ai-code-suggestions-advanced-programming/gitlab_cicd_pipeline_rust_cargo_run_output.png){: .shadow}\n\n## Wie geht es weiter?\nDieser Blogbeitrag war schwierig zu erstellen, da ich sowohl selbst fortgeschrittene Rust-Programmiertechniken erlernte als auch eine gute Lernkurve mit Codevorschlägen fand. Letzteres hilft bei der schnellen Generierung von Code, nicht nur von Textbausteinen. Nach dem Lesen dieses Blogbeitrags kennst du einige Herausforderungen und Turnarounds. Der Beispiel-Lösungscode für die Reader-App ist im Projekt [learn-rust-ai-app-reader](https://gitlab.com/gitlab-de/use-cases/ai/learn-with-ai/learn-rust-ai-app-reader) verfügbar.\n\nDas Parsen von RSS-Feeds ist herausfordernd, da es sich um Datenstrukturen mit externen HTTP-Anforderungen und parallelen Optimierungen handelt. Als erfahrene(r) Rust-Benutzer(in) hast du dich vielleicht gefragt: `Warum verwendet er nicht die Crate std::rss?` -- Sie ist für die erweiterte asynchrone Ausführung optimiert und erlaubt es nicht, die verschiedenen Rust-Funktionen, die in diesem Blogbeitrag erläutert werden, zu zeigen und zu erklären. Versuche als Übung den Code mit der [Crate `rss`](https://docs.rs/rss/latest/rss/) neu zu schreiben.\n\n### Asynchrone Lernübungen\nWas du in diesem Blogbeitrag gelernt hast, bildet die Grundlage für zukünftige Projekte mit persistenter Speicherung und Präsentation der Daten. Hier sind ein paar Ideen, mit denen du deine Kenntnisse von Rust vertiefen und die Reader-App optimieren kannst:\n\n1. Datenspeicherung: Verwende eine Datenbank wie sqlite und RSS-Feed-Update-Tracking.\n2. Benachrichtigungen: Spawne untergeordnete Prozesse, um Benachrichtigungen in Telegram usw. auszulösen.\n3. Funktionalität: Erweitere die Reader-Typen zu REST-APIs\n4. Konfiguration: Füge Unterstützung für Konfigurationsdateien für RSS-Feeds, APIs usw. hinzu.\n5. Effizienz: Füge Unterstützung für Filter und abonnierte Tags hinzu.\n6. Bereitstellungen: Verwende einen Webserver, sammle Prometheus-Metriken und stelle auf Kubernetes bereit.\n\nIn einem zukünftigen Blogbeitrag werden wir einige dieser Ideen besprechen und zeigen, wie wir sie umsetzen können. Tauche in vorhandene RSS-Feed-Implementierungen ein und erfahre, wie du den vorhandenen Code in Rust-Bibliotheken (`crates`) nutzen kannst.\n\n### Teile dein Feedback\nWenn du [GitLab Duo](/gitlab-duo/) Codevorschläge verwendest, [teile deine Meinung im Feedback-Ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/405152).\n",[976,1200,688,836,683],"careers","2025-01-29",{"slug":1203,"featured":6,"template":692},"learn-advanced-rust-programming-with-a-little-help-from-ai-code-suggestions","content:de-de:blog:learn-advanced-rust-programming-with-a-little-help-from-ai-code-suggestions.yml","Learn Advanced Rust Programming With A Little Help From Ai Code Suggestions","de-de/blog/learn-advanced-rust-programming-with-a-little-help-from-ai-code-suggestions.yml","de-de/blog/learn-advanced-rust-programming-with-a-little-help-from-ai-code-suggestions",{"_path":1209,"_dir":249,"_draft":6,"_partial":6,"_locale":7,"seo":1210,"content":1216,"config":1222,"_id":1224,"_type":16,"title":1225,"_source":18,"_file":1226,"_stem":1227,"_extension":21},"/de-de/blog/gitlab-flow-duo",{"title":1211,"description":1212,"ogTitle":1211,"ogDescription":1212,"noIndex":6,"ogImage":1213,"ogUrl":1214,"ogSiteName":674,"ogType":675,"canonicalUrls":1214,"schema":1215},"Kombiniere GitLab Flow und GitLab Duo für starke Workflows","Erweitere GitLab Flow um die KI-basierten Funktionen von GitLab Duo, um deine DevSecOps-Workflows so effizient wie noch nie zuvor zu machen (Tutorial mit Video).","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662840/Blog/Hero%20Images/ai-experiment-stars.png","https://about.gitlab.com/blog/gitlab-flow-duo","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Kombiniere GitLab Flow und GitLab Duo für starke Workflows\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cesar Saavedra\"}],\n        \"datePublished\": \"2023-07-27\",\n      }\n                  ",{"title":1211,"description":1212,"authors":1217,"heroImage":1213,"date":1218,"body":1219,"category":14,"tags":1220,"updatedDate":1221},[728],"2023-07-27","Für den Einstieg in DevSecOps ist ein gut durchdachter Workflow nötig – doch das kann oft eine echte Herausforderung sein. Zum Glück gibt es zwei Dinge, die dir dabei helfen können: \n\n**GitLab Flow und GitLab Duo.**\n\nGitLab Flow ist ein vorgefertigter Ansatz, der Unternehmen dabei hilft, DevSecOps-Prozesse erfolgreich umzusetzen. GitLab Duo ist ein [leistungsstarkes Set an KI-basierten Funktionen](https://about.gitlab.com/blog/supercharge-productivity-with-gitlab-duo/) in der DevSecOps-Plattform von GitLab, das Unternehmen dabei helfen kann, Code zu entwickeln, den Betrieb zu optimieren und Software effizienter zu schützen. Zusammen helfen GitLab Flow und GitLab Duo Unternehmen dabei, die Effizienz ihrer Workflows durchgängig deutlich zu verbessern. Das führt dann zu noch höherer Produktivität, Bereitstellungshäufigkeit, Codequalität und Sicherheit sowie zu Resilienz und Verfügbarkeit der Produktion.\n\nIn diesem Artikel erfährst du, wie GitLab Flow und GitLab Duo zusammen dazu beitragen können, Unternehmen mit DevSecOps zum Erfolg zu führen.\n\n > Entdecke die Zukunft von KI-gestützter Softwareentwicklung mit unserem virtuellen Launch-Event zu GitLab 17.  [Jetzt ansehen!](https://about.gitlab.com/de-de/seventeen/)\n\n## Was ist GitLab Flow?\nGitLab Flow ist ein vorgefertigter, festgelegter und durchgängiger Workflow für den Entwicklungslebenszyklus von Anwendungen mit GitLab, einer KI-basierten DevSecOps-Plattform, die eine einheitliche Benutzeroberfläche und ein einheitliches Datenmodell bietet. GitLab Flow baut auf bewährten Methoden und Erfahrungen aus Kundenfeedback und unserem Dogfooding auf. Außerdem deckt GitLab Flow alle [Phasen des DevSecOps-Lebenszyklus](https://about.gitlab.com/de-de/stages-devops-lifecycle/) ab und ermöglicht so einen effizienten Workflow, der aus einer inneren Feedbackschleife für Reviews bestimmter Updates sowie einer äußeren Feedbackschleife für die Verbesserung der gesamten Anwendung sowie des Entwicklungsprozesses an sich besteht.\n\n![Innere und äußere Feedbackschleifen von GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-feedback-loops.png)\n\u003Ccenter>Innere und äußere Feedbackschleifen von GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nWie du an den vielen Phasen in GitLab Flow erkennen kannst, besteht die Entwicklung einer Software aus viel mehr als dem reinen Programmieren. Im Folgenden erfährst du mehr über jeden Schritt von GitLab Flow und darüber, wie GitLab Duo dich dabei unterstützen kann.\n\n### Planen\nDas erste Element von GitLab Flow ist die Planung, die sich in der äußeren Feedbackschleife von GitLab Flow befindet. Sie umfasst Tickets, Merge Requests, Epics, Meilensteine, Iterationen, Veröffentlichungen, Release-Nachweise und mehr. Im Folgenden erfährst du, welche Rolle diese Komponenten in GitLab Flow spielen und wie dich GitLab Duo dabei unterstützen kann.\n\n![Planen – das erste Element in GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-planning-portion.png)\n\u003Ccenter>Planen – das erste Element in GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\n#### Tickets\nTickets sind die Elemente, in denen Produktprobleme oder neue Funktionen definiert werden und in denen Teammitglieder zusammenarbeiten können. Wenn ein Ticket erstellt wird, kannst du seinen Titel ausfüllen und dann die Funktion GitLab Duo **Issue Description Generation** nutzen, um die Beschreibung zu erstellen. So sparst du Zeit und hast weniger Aufwand. Da viele Beteiligte an Kommentar-Threads in einem Ticket mitarbeiten können, ist die **Diskussionszusammenfassung** eine KI-basierte Funktion von GitLab Duo, die dir hunderte Kommentare zu einem Ticket in einem kurzen Absatz zusammenfasst. So erhalten die Beteiligten rasch einen Überblick über die Konversation, können sich direkt an der Diskussion beteiligen und sofort produktiv werden.\n\nTickets können in Issue-Übersichten organisiert und visualisiert werden. Dabei handelt es sich um ein Software-Projektmanagementtool, das als Kanban- oder Scrum-Board eingesetzt werden kann. Mit diesen Boards können Teams den Workflow einer Funktion oder einer Produkt-Release einfacher planen, organisieren und visualisieren. Es können verschiedene Kategorien von Boards erstellt werden, wobei Tickets ganz einfach per Drag & Drop von einem zum anderen gezogen werden können.\n\n#### Merge Requests\nMerge Requests sind die Elemente, in denen Lösungen entwickelt werden. Tickets und Merge Requests sind Bestandteile einer Release und ermöglichen, dass Änderungen an Anwendungen, die von Beteiligten wie DevOps und Platform Engineers, System- und Datenbankadministrator(innen), Security Engineers und Entwickler(inne)n vorgenommen werden, überprüft und nachverfolgt werden können. Darüber hinaus sind Tickets und Merge Requests wichtige Inputs für den Release-Planungsprozess.\n\nMerge Requests können einzeln oder aus einem Ticket erstellt werden. Wenn du ein Merge Request aus einem Ticket erstellst, wird es automatisch dem Ticket zugeordnet. Wenn der Merge Request dann zusammengeführt wird, wird das zugehörige Ticket automatisch geschlossen. Merge Requests können auch manuell mit einem Ticket verknüpft werden.\n\n![Der Merge Request schließt das Ticket](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/mr-with-its-issue.png)\n\u003Ccenter>Der Merge Request schließt das Ticket\u003C/center>\u003Cp>\u003C/p>\n\nÄhnlich wie Tickets können auch Merge Requests eine lange Liste an Updates an einem Feature-Branch, die durch verschiedene Beteiligte vorgenommen wurden, enthalten. Mitwirkende, die sich mit den Updates vertraut machen möchten oder alle Updates in einem Merge Request verstehen müssen, können die Funktion **Merge-Request-Zusammenfassung** in GitLab Duo nutzen, um einen raschen Überblick über die Änderungen zu erhalten. Darüber hinaus können die Mitwirkenden mit der Funktion GitLab Duo **Code Merge Request Template Population** eine vorab erstellte Merge-Request-Vorlage heranziehen, die automatisch mit den entsprechenden Inhalten ausgefüllt wird. Beschreibungsvorlagen sind eine Möglichkeit, die Zusammenarbeit und Kommunikation im gesamten Entwicklungslebenszyklus zu standardisieren und zu optimieren – und mit GitLab Duo geht das noch schneller!\n\nTickets mit demselben Thema können in einem Epic gruppiert werden, um die zu erledigenden Arbeiten zu organisieren. Epics können untergeordnete Tickets und Sub-Epics haben und/oder mit anderen Epics im gesamten Unternehmen verknüpft werden. Mit Iterationen können Sprints nachverfolgt werden, und sie können manuell oder mithilfe von Iterationskadenzen automatisch geplant werden, um die Planungs-Workflows zu optimieren. Außerdem umfassen Iterationen Abarbeitungs- und Burnup-Diagramme. Abarbeitungsdiagramme helfen dabei, den Gesamtfortschritt im Projektumfang nachzuverfolgen, während Burnup-Diagramme die tägliche Anzahl und Gewichtung von Tickets messen, die in einer bestimmten Timebox hinzugefügt und abgeschlossen wurden.\n\n#### Meilensteine\nMithilfe von Meilensteinen können Teams ihre Tickets und Merge Requests in einer zusammenhängenden Gruppe mit optionalem Start- und Fälligkeitsdatum organisieren. Meilensteine werden in der Regel verwendet, um Releases nachzuverfolgen. Außerdem kann man mit ihnen Tickets und Merge Requests auf Projekt- oder Gruppenebene nachverfolgen. Ähnlich wie Iterationen gibt es auch bei Meilensteinen Abarbeitungs- und Burnup-Diagramme, die den Fortschritt zeigen.\n\nMeilensteine können mit einer Release verknüpft werden, bei deren Erstellung automatisch Artefakte wie etwa ein Release-Nachweis erstellt werden. Der Release-Nachweis ist eine automatisch gesammelte Momentaufnahme der Daten, die mit dieser Release zusammenhängen. Neben Testartefakten und verknüpften Meilensteinen kann der Release-Nachweis auch Jobartefakte enthalten, die sich auf interne Prozesse wie externe Audits beziehen.\n\nEpics, Meilensteine und Iterationen können über Roadmaps visualisiert werden, die dir dabei helfen, den Release-Fortschritt nachzuverfolgen und den Release-Prozess zu optimieren.\n\nSobald die Planung erfolgt ist, können die Arbeiten beginnen, die für die Lösung eines Problems oder die Entwicklung einer neuen Funktion erforderlich sind. Dies geschieht in Merge Requests. Im Folgenden erfährst du, wie das in GitLab Flow funktioniert. \n\n> [Erfahre mehr, indem du GitLab Flow und GitLab Duo ausprobierst](https://gitlab.com/-/trials/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2Fblog%2F).\n\n### Merge Requests und Pushen von Code\n\n![Merge Requests und Pushen von Code – das zweite Element in GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-mr-pushing-code-portion.png)\n\u003Ccenter>Merge Requests und Pushen von Code – das zweite Element in GitLab Flow \u003C/center>\u003Cp>\u003C/p>\n\nDas zweite Element von GitLab Flow betrifft Merge Requests und das Pushen von Code. Wie bereits erwähnt sind Merge Requests jene Orte, an denen die Beteiligten in einem Unternehmens an Lösungen zusammenarbeiten. Diese Zusammenarbeit kann verteilt und asynchron erfolgen. Die Mitwirkenden können die Kooperationsfunktionen wie Tagging, Inline-Vorschläge, Inline-Kommentare, Merge-Request-Kommentare, Review Threads und Review Requests nutzen, um gemeinsam die Codequalität, Verfügbarkeit, Zuverlässigkeit und Leistung zu verbessern. Direkt nach der Erstellung eines Merge Requests beginnt die innere Feedbackschleife von GitLab Flow, in der Code, Fix-Pushes, Tests und Scans durchgeführt werden. Hier finden außerdem Reviews zur Zusammenarbeit und zu Updates statt.\n\n#### Pipelines\nWenn Updates über Merge Requests auf einen Feature-Branch angewendet werden, werden automatisch Pipelines ausgeführt, falls diese vorab festgelegt wurden. Pipelines können mehrere Phasen und Jobs haben, um die Anwendung oder den Microservice in einer Review-Umgebung zu erstellen, zu testen und dann bereitzustellen. In dieser Review-Umgebung können Updates dynamisch verifiziert werden, bevor sie in den Haupt-Branch zusammengeführt werden. Diese Automatisierung trägt dazu bei, den Update- und Review-Prozess von Anwendungen zu optimieren.\n\nZudem stellen DevSecOps-Teams, die über Merge Requests Updates an Anwendungen vornehmen, eine Vielzahl an KI-basierten Funktionen zur Verfügung. Wenn sie Code schreiben oder aktualisieren, kann GitLab Duo **Codevorschläge** Code empfehlen, der an dieser Stelle passen würde, und die Entwickler(innen) können entscheiden, ob sie diese Empfehlung annehmen oder ignorieren möchten. Codevorschläge unterstützen dich bei der Codeerstellung über Prompts sowie durch die Code-Vervollständigung, die angezeigt wird, während du schreibst. Codevorschläge können das Programmiererlebnis verbessern, indem sie Fehler reduzieren und es den Entwickler(inne)n ermöglichen, schneller Code zu schreiben. Dies trägt wiederum dazu bei, die Qualität des Produktionscodes zu verbessern. Codevorschläge können außerdem zu einer höheren Produktivität der Entwickler(innen) und schnelleren Iterationen und Rollouts führen.\n\nDa verschiedene Stakeholder innerhalb der Organisation an der Entwicklung oder Überprüfung von Anwendungen beteiligt sind, können sie auf Code stoßen, der schlecht dokumentiert, komplex oder schwer zu verstehen ist oder in einer ihnen unbekannten Programmiersprache geschrieben ist. Die Funktion **Codeerläuterung** von GitLab Duo erklärt den Code in natürlicher Sprache, sodass jeder den Code verstehen und schnell auf dem neuesten Stand sein kann.\n\nWenn Aktualisierungen in den Feature-Branch committet werden, verwendet die GitLab-Duo-Funktion **Vorgeschlagene Prüfer(innen)** die Änderungen in einem Merge Request und das Mitarbeiterdiagramm eines Projekts, um geeignete Prüfer(innen) im Dropdown in der Seitenleiste des Merge Request vorzuschlagen. Die Liste enthält Benutzer(innen), die sich mit einem bestimmten Aspekt der Anwendung auskennen und daher am besten dazu geeignet sind, die Updates zu überprüfen. Entwickler(innen) sparen Zeit, da sie die am besten geeignet Prüfer(innen) nicht suchen und identifizieren müssen sowie den Überprüfungsprozess rationalisieren und Verzögerungen und Reviews von geringer Qualität vermeiden können.Wenn Entwickler(innen) Änderungen am Code vornehmen, fügen sie im Merge Request oft keine Kommentare zu den spezifischen Änderungen hinzu, die sie vorgenommen haben. Mit der **Merge-Request-Zusammenfassung** von GitLab Duo kann die bzw. der Autor(in) von Merge-Request-Änderungen mithilfe der KI einen Kommentar in natürlicher Sprache generieren, der die Updates am Code zusammenfasst. Prüfer(innen) können dann die Änderungen besser verstehen und den gesamten Überprüfungsprozess optimieren.\n\nWenn Prüfer(innen) Updates des Codes in einem Merge Request überprüfen, können sie den Merge Request blockieren. Die Begründung kann aus vielen Kommentaren bestehen, die sich über viele Quelldateien erstrecken. Um der bzw. dem ursprünglichen Autor(in) der Updates zu helfen, das Feedback der Prüferin oder des Prüfers in einem langen Block besser zu verstehen, erstellt die **Code-Review-Zusammenfassung** von GitLab Duo eine Zusammenfassung des Feedbacks der Prüferin bzw. des Prüfers in natürlicher Sprache. Dies ermöglicht eine bessere Übergabe zwischen Autor(inn)en und Prüfer(inne)n, wodurch der Review-Prozess optimiert wird.\n\nWenn Entwickler(innen) neuen Code über einen Merge Request hinzufügen, können sie außerdem die **Testgenerierung** von GitLab Duo nutzen, die mithilfe von KI Unit-Tests für den neuen Code generiert. Dies kann dazu beitragen, die Produktivität der Entwickler(innen) zu erhöhen, die Testabdeckung zu verbessern und Fehler frühzeitig im Entwicklungslebenszyklus zu erkennen. Entwickler(innen) können auch den jederzeit verfügbaren **Chat** von GitLab Duo nutzen, um Code zu refaktorisieren und Inline-Dokumentation wie z. B. Docstrings für ihren Quellcode erstellen.\n\nPipelines werden auf Branch-Updates ausgeführt und können automatisierte Tests und Scans enthalten, die dazu beitragen, die Sicherheit schon im Vorfeld zu kontrollieren.\n\n### Sicherheit im Vorfeld kontrollieren (Shift-Left-Ansatz)\n\n![Sicherheit im Vorfeld kontrollieren – das dritte Element von GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-shift-sec-left-portion.png)\n\u003Ccenter>Sicherheit im Vorfeld kontrollieren – das dritte Element von GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nDas dritte Element von GitLab Flow ist, dass die Sicherheit im Vorfeld kontrolliert wird. Diese Kontrolle ist auch Teil der inneren Feedbackschlaufe von GitLab Flow.\n\nNeben DevOps und Platform Engineers, System- und Datenbankadministrator(innen) und Entwickler(innen) betrifft die Sicherheit und Compliance auch einige der Beteiligten, die in einem Merge Request zusammenarbeiten, also an einem Ort, an dem automatisierte Tests und Sicherheitsscans eine Rolle spielen. Scans können einfach über praktisch nutzbare Vorlagen in eine Pipeline aufgenommen werden und/oder automatisch in einer Merge-Request-Pipeline ausgeführt werden. GitLab bietet eine Reihe an integrierten Sicherheitsscannern und Analysatoren, die von GitLab Flow genutzt werden können, doch auf der DevSecOps-Plattform sind auch Scanner von Drittanbietern sowie benutzerdefinierte Scanner möglich.\n\nGitLab Flow kontrolliert die Sicherheit im Vorfeld und verschiebt sie an den Anfang der Pipeline, um Fehler so früh wie möglich im Softwareentwicklungsprozess zu erkennen und zu beheben. Es ist viel einfacher und günstiger, Sicherheitslücken früh im Entwicklungsprozess zu erkennen und zu beheben, anstatt erst dann, wenn die Anwendung bereits in Produktion ist. Hier könnte ein ungeplanter Ausfall nämlich deine Benutzer(innen) beeinträchtigen und deinem Umsatz schaden.\n\nFolgende integrierte Sicherheitsscanner und Analysatoren sind in GitLab enthalten: Unit Tests, Infrastracture-as-Code-Scans (IaC), statische Anwendungssicherheitstests (SAST), Abhängigkeitssuche, Erkennung von Geheimnissen, Container-Scanning, API-Sicherheit, Web-API-Fuzzing und Abdeckungs-Fuzzing. Darüber hinaus hat GitLab eine Vielzahl an Sicherheitsdashboards und Berichten zu bieten, um Sicherheitslücken zu visualisieren. Dazu zählen die Liste der Abhängigkeiten, das Sicherheitsdashboard, der Sicherheitslückenbericht und die Sicherheitslücken-Seiten.\n\nUm Entwickler(inne)n und Security Engineers zu helfen, Sicherheitslücken besser zu verstehen und effizienter zu beheben, bietet die Funktion GitLab Duo **Vulnerability Explanation** eine Erklärung zu einer bestimmten Sicherheitslücke, wie sie ausgenutzt werden kann, und vor allem eine Empfehlung, wie die Sicherheitslücke behoben werden kann. Entwickler(innen) profitieren außerdem von der Funktion GitLab Duo **Vulnerability Resolution**, mit der automatisch ein Merge Request erstellt wird, der Codeänderungen zur Behebung der Sicherheitslücke enthält. Diese KI-basierten Funktionen tragen dazu bei, eine Anwendung sicherer zu machen und zu härten, um Sicherheitslücken zu vermeiden, die in der Produktion dann Ziel von Cyberangriffen werden könnten.\n\nNeben SAST-Scannern bietet GitLab auch DAST-Scanner (dynamische Anwendungssicherheitstest), für die eine laufende Anwendung erforderlich ist. Wenn diese Scanner eingesetzt werden, kann GitLab automatisch eine DAST-Umgebung für die DAST-Scans bereitstellen und dann nach dem DAST-Test eine komplette Bereinigung aller Ressourcen durchführen. Zudem bietet GitLab für ausgeführte Container das Operational Container Scanning (OCS) an, bei dem Container-Images in deinem Cluster auf Sicherheitslücken überprüft werden.\n\nDie genannten Scans können automatisch in einer Merge-Request-Pipeline ausgeführt werden. In einigen Fällen kann ihre Ausführung auch über Scan-Ausführungs- oder Merge-Request-Approvalrichtlinien geplant werden. Diese Richtlinien können über das GitLab-UI oder YAML-Dateien festgelegt werden und werden in einem separaten Projekt konfiguriert. Dies ermöglicht eine Aufgabentrennung, die die erneute Verwendung, die Wartung und die Verwaltung vereinfacht. Scan-Ausführungsrichtlinien erfordern, dass Sicherheitsscans nach einem bestimmten Zeitplan oder mit der Projektpipeline ausgeführt werden, während Merge-Request-Approvalrichtlinien Maßnahmen auf der Grundlage von Scan-Ergebnissen setzen. Security Engineers oder Sicherheitsteams können diese Richtlinien festlegen, um Sicherheitsprozesse im gesamten Unternehmen durchzusetzen. Da sich GitLab Flow durch alle Schritte zieht, können diese Richtlinien vorkommen bzw. genutzt werden.Um die Sicherheit und Compliance in deinem Unternehmen projektübergreifend durchzusetzen, kannst du Compliance-Labels und -Pipelines verwenden. Du kannst festlegen, dass Compliance-Labels und -Pipelines verpflichtend vor der eigenen Pipeline eines Projekts ausgeführt werden müssen. Mit diesem Ansatz kannst du sicherstellen, dass alle Teams in deinem Unternehmen deine Sicherheits- und Compliance-Standards erfüllen. Darüber hinaus kannst du so deine Anwendungen vor Cyberangriffen schützen, rechtlichen Vorgaben entsprechen und stets für Audits bereit sein.\n\nDas Hauptziel dieser Sicherheitsvorschriften von GitLab Flow ist, Sicherheitslücken früh im Entwicklungsprozess zu beheben, ehe die Anwendung in Produktion ist. Dann kann es nämlich sowohl teuer als auch schlecht für den Ruf sein, eine solche Sicherheitslücke beheben zu müssen.\n\nWenn Sicherheitslücken in der inneren Feedbackschleife von GitLab Flow behoben werden und weitere Updates an der Anwendung im Feature-Branch vorgenommen werden, müssen die Beteiligten auch diese Updates erneut überprüfen, um sicherzustellen, dass sie wirklich vorgenommen wurden und dass keine versehentlichen Regressionen eingeführt wurden.\n\n### Kontinuierlicher Review \n\n![Reviews – das vierte Element von GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-reviewing-features-portion.png)\n\u003Ccenter>Reviews – das vierte Element von GitLab Flow\u003C/center>\u003Cp>\u003C/p>\n\nDas nächste Element von GitLab Flow ist der Review von Funktionen, also eine kontinuierliche Überprüfung von Anwendungen. Die Review-Funktionen umfassen die Möglichkeit, eine Review-Umgebung zu erstellen, in der die vorläufige Anwendung (der sogenannte Feature-Branch) bereitgestellt wird, damit die Beteiligten sie in Echtzeit überprüfen und ihr Feedback dazu abgeben können. Die vorläufige Anwendung kann dann kontinuierlich angepasst werden, bis sie mit dem Haupt-Branch zusammengeführt werden kann. GitLab Flow schreibt außerdem eine Bereinigung aller in der Review-Umgebung bereitgestellten Ressourcen zu dem Zeitpunkt vor, an dem der Merge Request mit dem Haupt-Branch zusammengeführt wird.\n\nDieser iterative automatisierte Review-Prozess ist Teil der inneren Feedbackschleife in GitLab Flow. Wie erwähnt ermöglichen in der inneren Feedbackschleife GitLab-Duo-Funktionen wie Codeerläuterungen, Codevorschläge, vorgeschlagene Prüfer(innen), Merge-Request-Zusammenfassungen, Erstellung von Vorlagen für Merge Requests, Code-Review-Zusammenfassungen, Erläuterungen von Sicherheitslücken, Behebung von Sicherheitslücken und Grundursachenanalyse in GitLab Flow eine bessere Übergabe zwischen Autor(inn)en und Prüfer(inne)n und optimieren den gesamten Review-Prozess.\n\nDie innere Feedbackschleife von GitLab Flow endet, wenn alle Review-Elemente behandelt wurden, der Merge Request freigegeben wurde und mit dem Haupt-Branch zusammengeführt wurde. Dies löst dann die Bereitstellung der Anwendung für die Produktion aus.\n\n### Bereitstellung von Anwendungen und Infrastrukturen\n\n![Bereitstellen – das fünfte Element in GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/The-GitLab-Flow-2023-deploy-apps-portion.png)\n\u003Ccenter>Bereitstellen – das fünfte Element in GitLab Flow]\u003C/center>\u003Cp>\u003C/p>\n\nAbhängig von den Anforderungen eines Unternehmens gibt GitLab Flow entweder kontinuierliche Lieferung oder kontinuierliche Bereitstellung vor. Während man unter kontinuierlicher Lieferung die häufige Veröffentlichung von Code durch manuelles Auslösen der Bereitstellungen (z. B. in die Produktion) versteht, ist die kontinuierliche Bereitstellung die automatische Veröffentlichung von Code (z. B. in die Produktion) ohne menschliches Zutun. Sehen wir uns zunächst die kontinuierliche Lieferung an.\n\nWenn du deine Software mit kontinuierlicher Lieferung veröffentlichst, gibt es verschiedene Bereitstellungsoptionen. Du kannst ein Standbild-Fenster einrichten und dann mit fortschrittlichen Bereitstellungstechniken wie Canary, Blue/Green, zeitlich abgestimmte und inkrementelle Rollouts bereitstellen. Inkrementelle Rollouts können das Risiko von Produktionsausfällen verringern, was zu einer besseren User Experience und einer höheren Kundenzufriedenheit führt. Fortschrittliche Bereitstellungstechniken können auch die Entwicklungs- und Liefereffizienz verbessern und den Release-Prozess optimieren.\n\nWenn du deine Software mit kontinuierlicher Bereitstellung veröffentlichst, gehen alle Änderungen/Updates direkt in die Produktion. Progressive Bereitstellungsansätze wie Feature-Flags, mit denen du die Bereitstellung bestimmter Funktionen von einer Markteinführung trennen kannst, sind eine gute Möglichkeit, die Risiken zu reduzieren und zu verwalten, welche Funktionen den Produktionsbenutzer(inne)n zur Verfügung gestellt werden sollen. Feature-Flags unterstützen mehrere Programmiersprachen und ermöglichen Experimente der Entwickler(innen) und kontrollierte Tests. Du kannst sogar Feature-Flags verwenden, um Funktionen nur für bestimmte Benutzer(innen) auszurollen.\n\nGitLab unterstützt all diese Bereitstellungsansätze, doch GitLab Flow ermöglicht nur die Umsetzung jenes Ansatzes, der am besten zum Unternehmen und/oder zum spezifischen Projekt passt.\n\n### Überwachen von Anwendungen und DevSecOps-Prozessen\nSobald deine Anwendung für die Produktion bereitgestellt wurde, muss sie kontinuierlich überwacht werden, um ihre Stabilität, Leistung und Verfügbarkeit sicherzustellen. Darüber hinaus werden DevSecOps-Prozesse gemessen, während sie ausgeführt werden, damit ihre Leistung und Effizienz verbessert werden kann. Diese Überwachungsfunktionen werden von GitLab bereitgestellt und können daher auch mit GitLab Flow genutzt werden.\n\nGitLab bietet für ausgeführte Container das Operational Container Scanning (OCS) an, bei dem Container-Images in deinem Cluster auf Sicherheitslücken überprüft werden. Diese Scans können automatisiert werden, indem du planst, wann sie ausgeführt werden. Gefundene Sicherheitslücken werden dann automatisch in einem Sicherheitsdashboard angezeigt. Das OCS hilft dir dabei, deine Cluster-Anwendungen zu schützen und Cyberangriffe, die zur Veröffentlichung privater Daten und sogar zu unerwarteten Ausfällen führen können, frühzeitig abzuwehren.\n\nDie Fehlerverfolgung ermöglicht es Entwickler(inne)n, von ihrer Anwendung generierte Fehler zu entdecken und anzuzeigen. Alle von deiner Anwendung generierten Fehler werden in der Fehlerverfolgungsliste in GitLab angezeigt. Die Fehlerverfolgung trägt zu einer besseren Verfügbarkeit und Leistung deiner Anwendungen bei, indem unerwartete Anwendungsbedingungen schnell erkannt und behoben werden.\n\nGitLab kann über einen Webhook-Empfänger Alarme von beliebigen Überwachungsquellen wie Prometheus erhalten. Wenn Alarme eingehen, werden sie in der GitLab-Alarmliste angezeigt, von wo aus du sie dann manuell verwalten kannst. Alarme können auch automatisch die Erstellung von Vorfällen, ChatOps und E-Mails an die entsprechenden Personen oder Gruppen auslösen. All diese Funktionen optimieren den Umgang mit Alarmen sowie deren Bearbeitung.\n\nWenn Vorfälle aufgrund von Produktionsproblemen erstellt werden, werden sie in der GitLab-Vorfall-Liste für das Vorfallmanagement angezeigt. Du kannst einen oder mehrere Vorfälle verwalten, sie sortieren, durchsuchen, zuweisen, ihren Status festlegen und sogar den vorab gesetzten SLA-Countdown-Timer anzeigen. Darüber hinaus kannst du Bereitschaftspläne und -rotationen erstellen, Eskalationsrichtlinien festlegen sowie Paging und Benachrichtigungen für die Bearbeitung von Vorfällen einrichten. Außerdem kannst du einen Vorfall mit einem Alarm verknüpfen. Wenn der Vorfall geschlossen wird, wird der zugehörige Alarm automatisch als gelöst gekennzeichnet. Vorfall-Zeitleisten sind eine weitere Funktion für Führungskräfte und externe Betrachter(innen), um zu sehen, was während eines Vorfalls passiert ist und welche Maßnahmen zur Behebung des Vorfalls getroffen wurden. All diese Funktionen optimieren das Vorfallmanagement, damit Vorfälle so schnell wie möglich gelöst werden können.\n\nAudit Events verfolgen wichtige Ereignisse und zeichnen unter anderem auf, wer die entsprechende Handlung zu welchem Zeitpunkt in GitLab ausgeführt hat. Diese Ereignisse werden in der Audit-Event-Liste in GitLab angezeigt und geben unter anderem Informationen zum Ereignis, das für ein Objekt durchgeführt hatte, sowie die Person, die dieses Ereignis durchgeführt hat, und Datum und Uhrzeit.\n\nAll diese Listen und Dashboards helfen, nicht konforme Szenarien und damit zusammenhängende Strafen früh genug zu vermeiden sowie Audit-Prozesse zu optimieren. Sie generieren Daten und Indikatoren für deine laufenden Anwendungen, die dann in der äußeren Feedbackschleife von GitLab Flow verwendet werden können, um deine Anwendungen zu verbessern und zu optimieren und das Risiko unerwarteter Produktionsausfälle zu verringern.\n\n### Kontinuierliche Verbesserung\nWenn du GitLab Flow einsetzt, hast du auch die Möglichkeit, Einblicke mit GitLab zu nutzen. Du erhältst diese in Form von durchgängigen Prozessmetrik-Dashboards, damit du nicht nur deine Anwendungen, sondern auch die Performance deiner Softwarebereitstellung kontinuierlich verbessern kannst. Diese Dashboards und ihre Metriken werden von GitLab automatisch generiert und sind immer verfügbar.\n\n### Dashboard für die Wertstromanalyse\nDu kannst den Lebenszyklus deiner Anwendungsentwicklung über das Dashboard für die Wertstromanalyse verfolgen und überwachen, denn hier kannst du Projekt- und Gruppenstatistiken im Zeitverlauf anzeigen. Dieses Dashboard ist anpassbar, du kannst aber auch gleich loslegen und eine Wertschöpfungskette über eine der vorgefertigten Vorlagen von GitLab erstellen. Das Standarddashboard zeigt Metriken für jede der vordefinierten Phasen deiner Wertstromanalyse an, also Ticket, Planen, Programmieren, Testen, Review und Staging. Außerdem wird ein Diagramm mit der durchschnittlichen Zeit, die für den Abschluss der einzelnen Phasen benötigt wird, angezeigt. Hier werden auch die wichtigsten Indikatoren der Wertstromanalyse angezeigt: Abarbeitungsdauer, Bearbeitungszeit, neue Tickets, Commits und Bereitstellungen. Du kannst anhand dieser Metriken Verbesserungsbereiche in den einzelnen Phasen deiner Wertschöpfungskette identifizieren.\n\n### DORA-Metrik-Dashboard\nUm die Performance-Metriken anzuzeigen, die die Effektivität der Entwicklung und der Bereitstellungspraktiken in deinem Unternehmen messen, gibt es in GitLab das [DORA-Metrik-Dashboard](https://about.gitlab.com/de-de/solutions/value-stream-management/dora/) (DevOps Research and Assessment), in dem vier wichtige Metriken angezeigt werden: Häufigkeit der Bereitstellung, Vorlaufzeit für Änderungen, Zeit bis zur Wiederherstellung des Service und Änderungsfehlerrate. Die Häufigkeit der Bereitstellung misst, wie oft dein Unternehmen Code in der Produktion bereitstellt oder für Endbenutzer(innen) veröffentlicht. Die Vorlaufzeit für Änderungen misst, wie lange es vom Commiten des Codes bis zur erfolgreichen Ausführung in der Produktion dauert. Die Zeit bis zur Wiederherstellung des Service misst die Zeit, die benötigt wird, um die Services bei einem Vorfall auf dem vorherigen Niveau wiederherzustellen. Die letzte Kennzahl ist die Änderungsfehlerrate, also der Prozentsatz an Änderungen an der Produktion bzw. an für Benutzer(innen) veröffentlichten Anwendungen, die zu einem eingeschränkten Service führen (z. B. durch eine Änderung, die zu einer Einschränkung des Service oder zu einem Ausfall führte) und dementsprechende Behebung benötigen (in Form von Hotfixes, Rollbacks oder Patches). Diese vier Schlüsselkennzahlen sind Ergebnisse deine aktuellen Prozesse und geben dir die Möglichkeit, die Faktoren und Funktionen zu verbessern, die dahinterstehen.\n\n### Anpassung deines Dashboards\nEin weiteres Dashboard ist das Wertstrom-Dashboard, ein anpassbares Dashboard, mit dem Entscheidungsträger(innen) Trends, Muster und Möglichkeiten für Verbesserungen im Bereich der Softwareentwicklung erkennen können. Die gezeigten Metriken sind die DORA-Metriken, gefolgt von Flow-Metriken für die Wertstromanalyse und Zähler für kritische und hohe Sicherheitslücken im jeweiligen Monat bis zum aktuellen Datum, für die zwei vorhergehenden Monate sowie die sechs vorhergehenden Monate.\n\nGitLab Duo kann auch bei deinen Bestrebungen für kontinuierliche Verbesserungen helfen. Die Funktion **Wertstromprognose** zieht historische Daten heran und verwendet Datentrends aus deinem gesamten Entwicklungslebenszyklus, um das zukünftige Verhalten deiner Wertstrom-Metriken zu prognostizieren. Du kannst diese prädiktiven Analysen für deine Optimierungen nutzen.\n\nAll diese Dashboards und die Indikatoren, die sie anzeigen, sind Teil der äußeren Feedbackschleife von GitLab Flow. Sie helfen dir, das Risiko ungeplanter Produktionsausfälle zu verringern sowie deine Anwendungen und DevSecOps-Workflows zu verbessern.\n\n### KI-Impact-Analysen\nUm die Auswirkungen von GitLab Duo (bzw. der KI) im gesamten Entwicklungslebenszyklus besser zu verstehen, steht dir die [KI-Impact-Analyse](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/) zur Verfügung. Hier siehst du, wie sich die Nutzung von Codevorschlägen von GitLab Duo auf andere Leistungs-, Qualitäts- und Sicherheitsmetriken auswirkt. Du kannst die letzten sechs Monate der KI-Einführung und ihre Auswirkungen auf andere Indikatoren wie Bearbeitungszeit, Abarbeitungsdauer, Bereitstellungshäufigkeit, Änderungsfehlerrate und kritische Sicherheitslücken im Zeitverlauf visualisieren.\n\nKI-Impact-Analysen helfen dir dabei, die Akzeptanz, Effektivität und Vorteile zu messen, die die KI deinen Teams und deinem Unternehmen bringt. Zudem tragen sie dazu bei, Verbesserungsbereiche zu identifizieren.\n\n## Warum solltest du GitLab Flow verwenden?\nGitLab Flow ist ein vorgefertigter Ansatz, der von unseren Kund(inn)en und Benutzer(inne)n auf der ganzen Welt eingesetzt wird und folgende Vorteile bieten kann:\n\n- Höhere Produktivität durch Automatisierungsmöglichkeiten von GitLab und dessen vereinheitlichter Benutzeroberfläche und des einheitlichen Datenmodells, die beide von GitLab Flow verwendet werden\n- Genaue Einblicke in den gesamten DevSecOps-Lebenszyklus, um kontinuierliche Verbesserungen zu ermöglichen\n- Integrierte Dashboards und Metriken, die dir dabei helfen, deine Anwendungen und DevSecOps-Prozesse zu optimieren\n- Höhere Codequalität und verbesserte Zuverlässigkeit und Verfügbarkeit deiner Anwendungen\n- Bessere Anwendungssicherheit durch integrierte Sicherheitsscanner und -funktionen\n- Einhaltung von Compliance und Vorbereitung für Audits durch integrierte Compliance-Funktionen\n- Kürzere Bearbeitungszeiten für höhere Bereitstellungshäufigkeit\n- Kontinuierliche Reviews durch die innere Feedbackschleife von GitLab Flow\n- Die innere Feedbackschleife von GitLab Flow hilft dir, Anwendungs-Updates zu optimieren, wodurch sich die Codequalität verbessert und deine Anwendungen zuverlässiger und besser verfügbar werden\n- Die äußere Feedbackschleife von GitLab Flow kann dazu beitragen, deine Anwendungen sowie den Entwicklungslebenszyklus an sich zu verbessern\n- Intensive Zusammenarbeit zwischen den Beteiligten in deinem Unternehmen\n- Die Sicherheit wird im Vorfeld kontrolliert, um Sicherheitslücken in den Anwendungen zu finden,  bevor sie in die Produktion gelangen, wo solche Fehler teure, ungeplante Ausfälle verursachen können \n- Niedrigeres Risiko bei der Bereitstellung in die Produktion durch fortschrittliche Bereitstellungstechnicken und den progressiven Lieferansatz von GitLab\n- KI-Funktionen im gesamten Entwicklungslebenszyklus können Produktivität, Codequalität, kontinuierliche Verbesserung, Sicherheit, Compliance und mehr verbessern\n- Unterstützung für Cloud-native und nicht-Cloud-native Anwendungen\n- Multi-Cloud-Support für hybride Anwendungen und Multi-Cloud-Anwendungen\n- Die Sicherheit wird im Vorfeld kontrolliert, um Sicherheitslücken in den Anwendungen zu finden, bevor sie in die Produktion gelangen, wo solche Fehler teure, ungeplante Ausfälle verursachen können\n\nWie kannst du mit GitLab Flow durchstarten? Ein guter Ausgangspunkt, um die Prinzipien von GitLab Flow für deinen Lebenszyklus der Anwendungsentwicklung einzuführen, sind Auto-DevOps von GitLab.\n\n## GitLab Flow und Auto-DevOps\n\n![Auto DevOps – eine Instanziierung von GitLab Flow](https://about.gitlab.com/images/blogimages/gitlab-flow-duo/ado-pipeline.png)\n\u003Ccenter>Auto-DevOps – eine Instanziierung von GitLab Flow\u003C/center>\u003Cp>\u003C/p>Bei [Auto-DevOps](https://docs.gitlab.com/ee/topics/autodevops/) wird GitLab Flow in allen Phasen und Jobs angewendet. Du kannst es dir als ein gutes Beispiel für die Instanziierung von GitLab Flow vorstellen.\n\nAuto-DevOps ist eine Sammlung vordefinierter, sofort einsatzbereiter CI/CD-Vorlagen, die deinen Quellcode automatisch erkennen. Basierend auf bewährten Methoden können diese Vorlagen deine Anwendungen automatisch erkennen, erstellen, testen, bereitstellen und überwachen.\n\nDie Auto-DevOps-Pipeline kontrolliert die Sicherheit im Vorfeld, um Fehler so früh wie möglich im Softwarelieferprozess zu finden und zu vermeiden. Die Pipeline stellt die Anwendung dann zur Verifizierung im Staging und dann inkrementell/zeitgesteuert in der Produktion bereit.\n\nMit Auto-DevOps kannst du rasch durchstarten, die Produktivität der Entwickler(innen) steigern und das Ganze einfach an deine Bedürfnisse anpassen. Außerdem erhältst du Unterstützung für die bekanntesten Programmier-Frameworks und -sprachen. Auto-DevOps ist modular, anpassbar und erweiterbar, sodass du sowohl nur einzelne Elemente in deiner Pipeline nutzen oder das Gesamtpaket für deine Anwendung einsetzen kannst.\n\n## Los geht’s\n[Kombiniere jetzt GitLab Flow und GitLab Duo](https://gitlab.com/-/trials/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2Fblog%2F), um die Effizienz deiner Workflows von Anfang bis Ende deutlich zu verbessern. So kannst du eine noch höhere Produktivität, Bereitstellungshäufigkeit, Codequalität und Sicherheit sowie verbesserte Resilienz und Verfügbarkeit deiner Produktion erreichen.\n\nWenn du sehen möchtest, wie ein Workflow funktioniert, der GitLab Flow und GitLab Duo kombiniert und wie du davon profitieren kannst, schau dir das folgende Video an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/CKrZ4_tKY4I?si=Kf6QsYFIzKkJZpJd\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n",[111,683,976],"2025-04-21",{"slug":1223,"featured":6,"template":692},"gitlab-flow-duo","content:de-de:blog:gitlab-flow-duo.yml","Gitlab Flow Duo","de-de/blog/gitlab-flow-duo.yml","de-de/blog/gitlab-flow-duo",3,[698,718,740,761,781,801,822,843,864],1751548582819]