Kurs · Schulung · Workshop
Agentic Embedded Engineering
Agentic Coding für Firmware- und Embedded-Teams: KI-Agenten, die in C/C++-, Qt- und Embedded-Linux-Projekten Code schreiben, Tests bauen, Cross-Builds ausführen und Legacy-Code modernisieren – mit den Grenzen, die hardwarenahe Entwicklung setzt.
Agentic Coding Tools wie Claude Code oder Codex sind in der Web- und Cloud-Entwicklung angekommen. In Firmware- und Embedded-Projekten sieht die Realität anders aus: grosse, gewachsene C/C++-Codebases, wenig Tests, lange Cross-Build-Zyklen, Zielhardware, die der Agent nicht sehen kann, und Nachweispflichten aus dem Cyber Resilience Act (CRA) und weiteren Branchen-Normen. Dieser Kurs zeigt, wie Agenten unter genau diesen Bedingungen produktiv werden. Die Teilnehmenden lernen, Agenten mit dem richtigen Projektkontext auszustatten (Architektur, Build-System, Hardware-Constraints, Coding-Standards), sie gegen ein Test-Setup arbeiten zu lassen, das Agenten-Output auf dem Host verifizierbar macht, und sie für die Aufgaben einzusetzen, bei denen sie in Embedded-Projekten am meisten bringen: Legacy-Code verstehen und schrittweise modernisieren, Tests für ungetesteten Code nachziehen, Treiber und HAL-Schichten aus Datenblättern ableiten, Qt-Oberflächen und Embedded-Linux-Komponenten entwickeln, Dokumentation als Code mitführen. Ebenso deutlich zeigen wir, wo Agenten heute scheitern – hardwarenahes Timing, Interrupts, Speicherlayout, Toolchain-Eigenheiten – und wie man den Workflow so baut, dass der Mensch an diesen Stellen die Kontrolle behält. Wir arbeiten primär mit Claude Code und ordnen alternative Tools ein; Methode und Workflow sind bewusst tool- und modellunabhängig.
Trainer
Stimmen unserer Teilnehmer:innen
- Guter Einstieg ins Thema - Gute Vorstellung, was alles möglich ist - Praktische Beispiele veranschaulichen das Ganze - Freue mich auf den Advanced Kurs ;-)
Fachbereichsleiter IAM I Kanton Aargau
The “AI Assisted Engineering On-Boarding” course was an outstanding experience. It provided a clear, practical, and inspiring introduction to how AI can support modern engineering work. The content was well structured, easy to follow, and highly relevant to real day-to-day challenges. What stood out most was the strong balance between theory and hands-on application. The course not only explained the concepts clearly, but also showed how to use AI tools effectively and responsibly in actual engineering scenarios. It made complex topics feel accessible and immediately useful. I especially appreciated the engaging format, the high quality of the materials, and the clear expertise of the instructors. The course created a motivating learning environment and gave me valuable confidence in applying AI-assisted approaches in my work. Overall, I can highly recommend “AI Assisted Engineering On-Boarding” to anyone who wants a practical, forward-looking, and well-designed introduction to AI in engineering. It is an excellent course that delivers real value from start to finish.
Leiter IT Entwicklung Platform & Services
The AI Assisted Engineering On-Boarding course was very practical and easy to follow and awesome! I especially appreciated the hands-on approach and the focus on real use cases. It gave me a clear understanding of how to work effectively with Claude Code in a development context. After the course, I felt much more confident getting started and applying it in daily work.
Frontend Web Developer
The course fully met all my expectations and provided a smooth introduction to the subject. With the help of the instructor and the course materials, I was able to easily overcome any initial hurdles, allowing me to get started using the agents as quickly as possible.
Senior Software Engineer
I really enjoyed the lessons and learned a lot of new stuff on this course. It teaches not only fundamentals but also how to be prepared for your next challenges. The tooling that is used is very sturdy, works very well in the lab setup and is very diverse, you can pick what you like in your projects. And most importantly: I did not write any piece of code myself, the agents did everything!
Software Engineer I
Great training on agentic software development. The trainer obviously had lots of hands-on experience with the topic, there was no question that he couldn't answer. Lab environment was very well thought through and helped a lot in practicing what we learned.
Senior Software Design Engineer
* Stimmen aus diesem oder verwandten Kursen.
Diese Kunden haben Kurse im gleichen Themen-Cluster bei uns gebucht.Mehr Kunden →
Inhalt
Der Kurs besteht aus den folgenden Themen und wird für Inhouse-Durchführungen auf Stack, Toolchain, Zielhardware und Erfahrungsstand des Teams zugeschnitten. Wir arbeiten primär mit Claude Code an einem realen C++/Qt-Projekt mit Embedded-Linux-Target und ordnen alternative Tools wie Codex oder Copilot ein; Methode und Workflow sind bewusst tool- und modellunabhängig.
– Standortbestimmung und Einführung:
- Wo das Team steht: vom Skeptiker bis zum Power-User – und warum beide Enden in die Mitte müssen
- Was Agentic Coding ist: Planen, Ausführen, Verifizieren – tool- und modellunabhängig
- Was in Embedded anders ist: Cross-Builds, Zielhardware, Legacy, Nachweispflicht
- Überblick Kursumgebung: Agentic Tools, Toolchain, Emulation – Projektkontext für Embedded-Codebases:
- Rules und Guidelines im Repository: Architektur, Schichten, Coding-Standards (MISRA/CERT als Orientierung), Speicher- und Timing-Constraints
- Build-System und Toolchain für den Agenten beschreiben: CMake-Presets, Cross-Compile, Targets
- Grosse C/C++-Codebases navigierbar machen: Codebase-Maps, Sub-Agenten, gezielte Exploration
- Hands-On: Projektkontext für die Kurs-Codebase aufbauen und den Agenten eine unbekannte Komponente erklären lassen – Verifizierbarer Agenten-Output: das Test-Setup:
- Hardware-Abstraktion als Voraussetzung: Logik vom Target trennen, damit der Agent auf dem Host testen kann
- Unit-Tests mit GoogleTest/Catch2, Mocks für Peripherie, Treiber und Kommunikation
- Test-Driven Agentic Development: Tests zuerst, Agent liefert grün
- Emulation (QEMU) und Cross-Build im Agenten-Loop: lange Zyklen sinnvoll einbauen
- Hands-On: Agent legt Tests für eine ungetestete Komponente an und implementiert dagegen – Legacy-Code verstehen und modernisieren:
- Code-Verständnis und Dokumentationsgenerierung für gewachsene C/C++-Module
- Schrittweises Refactoring mit Agenten: kleine, verifizierte Schritte statt grosser Umbauten
- Migration von C nach modernem C++, Modernisierung alter C++-Standards
- Hands-On: Legacy-Modul mit Agentenunterstützung unter Test bringen und refactoren – Treiber, HAL und Systemnahes mit Agenten:
- Treiber- und HAL-Code aus Datenblättern und Register-Beschreibungen ableiten – und prüfen
- Protokoll-Implementierungen (UART, SPI, I2C, CAN) und deren Tests
- Ehrliche Grenzen: Timing, Interrupts, Speicherlayout, Toolchain-Eigenheiten – wo der Mensch entscheidet
- Hands-On: HAL-Schicht für eine Peripherie mit Agent entwickeln, Grenzen dokumentieren – Qt und Embedded-Linux-Applikationen:
- Qt/QML-Komponenten mit Agenten entwickeln, testen und refactoren
- Embedded-Linux-Komponenten: Services, systemd-Units, Build-Rezepte (Yocto/Buildroot)
- Agent im Zusammenspiel mit Cross-Build und Deployment auf Target oder Emulation
- Hands-On: Feature über Qt-Oberfläche und Backend-Komponente mit Agent umsetzen – Werkzeuge, Modelle und MCP-Server:
- Modellauswahl je Aufgabe: schnelle vs. starke Modelle, Kosten, Kontextgrösse
- Welcher Code darf in welches Modell: IP-Schutz, Self-Hosting, Enterprise-Setups
- MCP-Server für interne Systeme: Build-Server, Issue-Tracker, Anforderungsdokumente, Datenblätter
- Hooks und Skills: automatische Checks (Format, Static Analysis, Tests) und wiederverwendbare Arbeitsanweisungen
- Hands-On: Hook für clang-tidy/Tests einrichten und einen Skill für ein wiederkehrendes Muster anlegen – Security und Review-Verantwortung:
- Tool-Berechtigungen, Secrets im Kontext, Prompt Injection über Abhängigkeiten und Dokumente
- Agenten-Code reviewen: gemeinsamer Standard, damit schnelle und vorsichtige Entwickler im Team zusammenpassen
- Agentische Code Reviews als zweite Meinung, nicht als Ersatz – Dokumentation und Nachweise als Code:
- Documentation-as-Code: Architektur- und Schnittstellendoku mit dem Code pflegen
- Spec-driven: Anforderungen und ADRs zuerst, Agent implementiert dagegen – Spec als Review-Grundlage und Compliance-Artefakt
- Traceability für CRA und weitere Branchen-Normen: was der Agent liefern kann und was der Mensch verantwortet
- Hands-On: Doku und ADR für die umgesetzten Änderungen agentisch nachziehen – Team-Rollout:
- Rules, Skills, Hooks, MCP-Server als geteiltes Team-Setup ins Repository
- Arbeitsweise harmonisieren: gemeinsames Vokabular, gemeinsame Guardrails
- Nächste Schritte für das eigene Projekt erarbeiten
Der Kurs ist bewusst tool-übergreifend angelegt: Wir arbeiten praktisch mit Claude Code und ordnen alternative agentische Werkzeuge ein. Die Konzepte, Workflows und Team-Artefakte sind auf jedes Tool mit gleichwertigen oder stärkeren Fähigkeiten übertragbar.
Der effektive Kursinhalt kann, abhängig von Trainer, Durchführung, Dauer und Konstellation der Teilnehmer:innen, von obigen Angaben abweichen.
In-House Kurs anfragen
Öffentlichen Termin anfragen
Kein passender öffentlicher Termin dabei? Trag dich unverbindlich ein – sobald genug Interesse besteht, planen wir einen neuen öffentlichen Termin und informieren dich zuerst.
Mehr über Agentic Embedded Engineering
Die Methode des Agentic Coding – Agenten mit Kontext und Regeln ausstatten, planen lassen, ausführen lassen, Ergebnis verifizieren – ist über Tools und Modelle hinweg stabil. Was sich in Embedded-Projekten unterscheidet, ist die Umgebung: Der Agent kann keinen Debugger an die Hardware hängen, ein Cross-Build dauert Minuten statt Sekunden, und ein Fehler im Treiber zeigt sich erst am Gerät. Agentic Embedded Engineering übersetzt die Methode in diese Umgebung: hardwareunabhängige Logik, die der Agent auf dem Host testen kann; ein Projektkontext, der Architektur und Constraints erklärt; ein Workflow, in dem der Mensch an den hardwarenahen Stellen entscheidet.Weitere Ressourcen:
History
KI-Unterstützung beim Programmieren begann mit Autocomplete und erreichte 2021 mit GitHub Copilot die Breite. Ab 2024 verschob sich das Bild mit agentischen Tools wie Claude Code: Agenten bedienen Terminal und Build-System, führen Tests aus, lesen Fehlermeldungen und iterieren eigenständig. In Web- und Cloud-Projekten mit schnellen Builds und guter Testabdeckung wurde das rasch zum Standard.
Embedded-Teams nutzen dieselben Werkzeuge, treffen aber auf Codebases, die für eine andere Arbeitsweise gebaut wurden: wenig Tests, enge Kopplung an Hardware, proprietäre Toolchains. Die aktuelle Entwicklung – Hardware-Abstraktion als Voraussetzung für agentisches Arbeiten, Emulation im Loop, Agenten für Legacy-Modernisierung und Dokumentation – macht Agentic Coding auch für Firmware und Embedded Linux zum verlässlichen Werkzeug, mit klaren Grenzen dort, wo Timing und Hardware entscheiden.