Course · Training · Workshop

Agentic Embedded Engineering

Agentic coding for firmware and embedded teams: AI agents that write code, build tests, run cross-builds and modernize legacy code in C/C++, Qt and embedded Linux projects – within the limits that hardware-near development imposes.

Agentic coding tools such as Claude Code or Codex have arrived in web and cloud development. In firmware and embedded projects reality looks different: large, grown C/C++ codebases, few tests, long cross-build cycles, target hardware the agent cannot see, and evidence obligations from the Cyber Resilience Act (CRA) and other industry standards. This course shows how agents become productive under exactly these conditions. Participants learn to equip agents with the right project context (architecture, build system, hardware constraints, coding standards), to let them work against a test setup that makes agent output verifiable on the host, and to use them for the tasks where they deliver most in embedded projects: understanding and step-by-step modernizing legacy code, adding tests to untested code, deriving drivers and HAL layers from datasheets, developing Qt user interfaces and embedded Linux components, keeping documentation as code. Just as clearly we show where agents fail today – hardware-near timing, interrupts, memory layout, toolchain quirks – and how to build the workflow so the human keeps control at those points. We work primarily with Claude Code and position alternative tools; method and workflow are deliberately tool- and model-independent.

In-house course

Tailored for your team.

Request

No suitable date?

Request a new public date.

Request a date

Trainers

Urs Fässler

Instructor

What participants say

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.

Martin
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.

Alexander
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.

Daniel
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!

Andrei-Flavius
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.

Eros
Senior Software Design Engineer

Very concrete and practical training on "Agentic Software Engineering", with a good amount of theoretical background to understand what happens behind the scenes. The instructor was very knowledgeable and willing to answer the multitude of questions.”

Fabio
Software Engineer I Karakun

* Voices from this or related courses.

These customers booked courses in the same topic cluster.More customers →

Content

The course consists of the following topics and is tailored to the team’s stack, toolchain, target hardware and experience level for in-house deliveries. We work primarily with Claude Code on a real C++/Qt project with an embedded Linux target and position alternative tools such as Codex or Copilot; method and workflow are deliberately tool- and model-independent.

– Assessment and introduction:

Where the team stands: from skeptic to power user – and why both ends need to move to the middle
What agentic coding is: plan, execute, verify – tool- and model-independent
What is different in embedded: cross-builds, target hardware, legacy, evidence obligations
Overview of the course environment: agentic tools, toolchain, emulation – Project context for embedded codebases:
Rules and guidelines in the repository: architecture, layers, coding standards (MISRA/CERT as orientation), memory and timing constraints
Describing build system and toolchain for the agent: CMake presets, cross-compile, targets
Making large C/C++ codebases navigable: codebase maps, sub-agents, targeted exploration
Hands-on: build the project context for the course codebase and have the agent explain an unknown component – Verifiable agent output – the test setup:
Hardware abstraction as a precondition: separating logic from the target so the agent can test on the host
Unit tests with GoogleTest/Catch2, mocks for peripherals, drivers and communication
Test-driven agentic development: tests first, agent delivers green
Emulation (QEMU) and cross-build in the agent loop: integrating long cycles sensibly
Hands-on: agent creates tests for an untested component and implements against them – Understanding and modernizing legacy code:
Code understanding and documentation generation for grown C/C++ modules
Step-by-step refactoring with agents: small, verified steps instead of big rewrites
Migrating from C to modern C++, modernizing old C++ standards
Hands-on: bring a legacy module under test with agent support and refactor it – Drivers, HAL and system-near code with agents:
Deriving driver and HAL code from datasheets and register descriptions – and checking it
Protocol implementations (UART, SPI, I2C, CAN) and their tests
Honest limits: timing, interrupts, memory layout, toolchain quirks – where the human decides
Hands-on: develop a HAL layer for a peripheral with the agent, document the limits – Qt and embedded Linux applications:
Developing, testing and refactoring Qt/QML components with agents
Embedded Linux components: services, systemd units, build recipes (Yocto/Buildroot)
Agent in interplay with cross-build and deployment to target or emulation
Hands-on: implement a feature across Qt UI and backend component with the agent – Tools, models and MCP servers:
Model selection per task: fast vs. strong models, cost, context size
Which code may go into which model: IP protection, self-hosting, enterprise setups
MCP servers for internal systems: build server, issue tracker, requirement documents, datasheets
Hooks and skills: automatic checks (format, static analysis, tests) and reusable work instructions
Hands-on: set up a hook for clang-tidy/tests and create a skill for a recurring pattern – Security and review responsibility:
Tool permissions, secrets in context, prompt injection via dependencies and documents
Reviewing agent code: a shared standard so fast and careful developers fit together in the team
Agentic code reviews as a second opinion, not a replacement – Documentation and evidence as code:
Documentation-as-code: maintaining architecture and interface documentation with the code
Spec-driven: requirements and ADRs first, agent implements against them – the spec as review basis and compliance artifact
Traceability for CRA and other industry standards: what the agent can deliver and what the human is responsible for
Hands-on: update documentation and ADR for the implemented changes agentically – Team rollout:
Rules, skills, hooks, MCP servers as a shared team setup in the repository
Harmonizing the way of working: shared vocabulary, shared guardrails
Working out next steps for your own project

The course is deliberately tool-agnostic: we work hands-on with Claude Code and position alternative agentic tools. The concepts, workflows and team artifacts transfer to any tool with equivalent or stronger capabilities.

The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.

Goal

After this course you use AI agents in your C/C++, Qt or embedded Linux project in a targeted and controlled way. You build a project context that conveys architecture, build system, hardware constraints and coding standards to agents, and establish a test setup that verifies agent output on the host before it gets anywhere near the hardware. You use agents for code understanding, refactoring and modernization of legacy code, for adding tests, for driver and Qt development and for documentation that grows with the code. You know the limits of agentic development in hardware-near code and which tasks remain with the human. And you bring this way of working into the repository as a shared team setup – rules, skills, hooks, MCP servers – rather than as an individual configuration.

Duration

2 Days

Format

Two days hands-on on a real embedded project (C++, CMake, Qt, embedded Linux target) in the Letsboot Labmachine with pre-installed agentic coding tools, cross toolchain and emulation. Every topic block combines a short concept part with a task participants solve with the agent – and a reflection on what went well and where the agent had to be corrected. For in-house courses we work on excerpts of your own codebase on request. The trainer brings experience from embedded architecture, test automation and legacy modernization in regulated projects.

Target group

Firmware and embedded software developers, embedded Linux engineers, Qt developers, software architects and tech leads working with C/C++ who want to introduce agentic coding in their own project or harmonize it across the team. The course meets skeptics and power users alike: the goal is a shared, reliable level in the team, not maximum agent autonomy.

Prerequisites

Solid experience in C or C++ and in embedded development (firmware, embedded Linux or Qt). Confident use of Git, CMake or a comparable build system and the Linux command line. First contact with AI coding tools is helpful but not required – the course meets beginners and experienced users alike.

Preparation

Before the course each participant receives a questionnaire about experience with agentic tools, stack, toolchain and concrete challenges so we can set focus and exercises precisely. We provide the Letsboot Labmachine with pre-installed agentic coding tools, cross toolchain and emulation; the required AI API tokens are provided during the course. After the course, Labmachine access remains available for further learning.

Request this course in-house

Request a public date

No suitable public date? Register without obligation — once there is enough interest we schedule a new public date and let you know first.

More about Agentic Embedded Engineering

The method of agentic coding – equip agents with context and rules, let them plan, let them execute, verify the result – is stable across tools and models. What differs in embedded projects is the environment: the agent cannot attach a debugger to the hardware, a cross-build takes minutes instead of seconds, and a bug in the driver only shows on the device. Agentic Embedded Engineering translates the method into this environment: hardware-independent logic the agent can test on the host; a project context that explains architecture and constraints; a workflow in which the human decides at the hardware-near points.

Further resources:

History

AI assistance in programming started with autocomplete and reached the mainstream in 2021 with GitHub Copilot. From 2024 the picture shifted with agentic tools such as Claude Code: agents operate terminal and build system, run tests, read error messages and iterate on their own. In web and cloud projects with fast builds and good test coverage this quickly became the standard.

Embedded teams use the same tools but meet codebases built for a different way of working: few tests, tight coupling to hardware, proprietary toolchains. The current development – hardware abstraction as a precondition for agentic work, emulation in the loop, agents for legacy modernization and documentation – makes agentic coding a reliable tool for firmware and embedded Linux too, with clear limits where timing and hardware decide.