Hey HN - We’re Bob and Ethan from Embedder (https://embedder.dev), a hardware-aware AI coding agent that can write firmware and test it on physical hardware.

Here’s a demo in which we integrate a magnetometer for the Pebble 2 Duo smartwatch: https://www.youtube.com/watch?v=WOpAfeiFQkQ

We were frustrated by the gap between coding agents and the realities of writing firmware. We'd ask Cursor to, say, write an I2C driver for a new sensor on an STM32, and it would confidently spit out code that used non-existent registers or HAL functions from the wrong chip family. It had no context, so it would just guess and the code is always wrong.

Even when it wrote the right code, the agent had no way of interacting with your board and the developer would have to manually test it and prompt the agent again to fix any bugs they found. Making current solutions not ideal when working in an embedded context.

That’s why we are building Embedder, a hardware-aware coding agent that is optimized for work in embedded contexts. It understands your datasheets and schematics and can also flash and test on your hardware.

First, you give it context by uploading datasheets, reference manuals, schematics, or any other documentation on our web console and our coding agent will automatically have context when it executes tasks in the command line.

Second, Embedder can directly interact with your hardware to close the development loop. The agent is able to use a serial console just like a regular developer to read from your board and verify outputs. To solve more complex bugs or identify hardware issues the coding agent is also able to launch a debugging agent optimized for step through debugging workloads and interact with local or remote gbdservers.

You can try it out today. It’s an npm package you can install and run from your terminal:

  npm i -g @embedder/embedder && embedder

We’d love to get feedback from the community, or hear about your experiences of embedded development. We’ll be in the comments to respond!

Cool venture! I've resigned myself to accept that the generic "coding" LLMs only work well with the most default tasks and the most common languages -- and as soon as you stray from the well-trodden paths, there be hallucinations of dragons. It seems projects like that could be the solution -- narrower, domain-specific models. I think it still poses challenges in cross-domain projects, and I'm still waiting for a model that can handle spatial reasoning (eg, for circuit board design, blueprint layout, etc).

This is a more general question, but:

What company would be comfortable with giving out schematics, source code, etc... to third parties like this or AI Model providers like Anthropic, etc...

Privacy policy aside, this just seems like a statistical guarantee at some point to leaks sensitive IP (not specifically pointing at this company, but in this space in general). Or does nobody care?

Problem is that most our embedded stuff is heavily NDA'ed and will never (and isn't allowed to) end up in LLMs. So we will be sticking to hand-writing most stuff.

At work we have access to the latest LLMs (Claude, Gemini, Open AI) and they are not really usable. The code looks great (which makes it extremely hard to debug) - but produce too much hallucinations.

Is it capable of debugging the macro-hell of Zephyr ?

Honestly good luck with that. I have tried DeepSeek and Claude and random pulling of registers out of LLMs butt is a thing.

What you will soon find out is that different companies are describing registers in radically different ways in their datasheets and I don't believe that LLM will be able to cope with it. If I can give you an advice, download Tasking compiler for a target processor and you will find SFD files which are essentially XML files describing registers and their bitfields. You can then add context on those SFD from the datasheet / reference manual and now you have 100% correct data with a register-first structure for LLM.

Obviously it would be better to figure where those SFD files came out to avoid IP problems. I sincerely doubt that Tasking wrote it itself, it should come from IC manufacturers because this is just distilled VHDL.

So getting these structured data instead of datasheets will more likely result in a valid answer.

Earlier this week our team were talking about how AI coding tools for our services is great, but we didn't think it was great for firmware development.

This may be just because there isn't as much embedded training data. I'm not sure if you have thoughts on that.

I've passed it onto the team. Congrats on the launch. Clearly solving a great niche.

One test case that I've used with LLMs that generate code: generate a stop light.

In short,

Generate a stoplight with unit tests.

I have not yet found a model that produces sufficiently safe code. I haven't tested this in awhile; but I don't expect any current LLM to be sufficient at this task.

Maybe an LLM could generate a safe stop light with formal methods as a primary meta procedure? From https://news.ycombinator.com/item?id=44889967 re: formal methods:

> We should not expect an LLM trained solely on formally-verified code to produce formally-verified code. I don't think that also training on specs and hateful training material will fix that.

I’ve found AI agents always a bit lacking in embedded but I’ll test this out.

You said in your demo that by uploading the data sheet you completely remove hallucinations. How have you achieved this as I found AI’s still hallucinate even when given documentation.

This looks awesome. Embedded programming doesn’t get enough love. Did you think about making this an MCP (aka plugin) service that general agents a la claude code can leverage?

Definitely a need, kudos for tackling it!

I’d still look into fine tuning. One of the main issues I’m struggling with is that even reasonably simple drivers often need to be aware of Application Notes etc that would single handedly blow past any context window. So giving the model a fighting chance by narrowing the space might be worthwhile here. Top 20 vendors datasheets/docs, handpicked sites and forums etc.

Is there a way to authenticate without a browser? (For when we're developing on a headless machine or a remote machine via vscode->ssh, and the callback to localhost can't fire from our client machine)

I've tried launching via `NO_BROWSER=true embedder` but this doesn't seem to change the auth flow

I've been building a set of tools to help with speeding up the reprogramming cycle of embedded, getting it down to about 500ms and not requiring a restart, for logic changes.

Combining that with AI, and the "futz factor" of changing and trying things rapidly mirrors a spreadsheet.

You’ll probably hear people say things like “this could just be an MCP server and a prompt to use it.” To that I’d say: just remember that infamous 2007 Dropbox comment: https://news.ycombinator.com/item?id=9224

If you can make the developer experience simple enough that it becomes standard practice, you can go really far. Good luck!

how are you going about this? do you intend to train/finetune your own models, or scaffold frontier models with prompts+tools?

How good is your esp32 support? This could make a lot of home automation hobbyists very happy!

are you training a new model or is this just prompt "engineering" with a fancy ui?

Just yesterday I was both hindered and helped by Google in modifying a 32 bit bootloader to load and executes 64 bit code.

- Google search was utterly useless, giving me no relevant results (which I found later by searching around github). It mainly returned results for a different archtecture, padded with results on a different topic.

- Gemini only wanted to give workflow hints sparsely dotted with actual (correct) asm.

- but then I found out that Gemini had a full grasp of the 6500 page datasheet and it happily reviewed my code, pulling out 2 errors and suggesting some optimisation.

We’ve come to the point were google search is worse than github search. And I haven’t given up on Gemini yet.

I’ve honestly been having a pretty good time with embedded dev and claude code, including board bring up and rtos dev.

As you mention providing the context is the key. I also have a fair bit of embedded dev/management experience so know intuitively how things should go.

As with everything, organization seems to win.

wow this is awesome

The system prompt:

You are an interactive CLI agent specialising in embedded-systems software engineering tasks using C and C++. You must adopt a rigerous and zero trust approach to reading documentationa and code. Treat every line of code with suspension until proven correct through reading documentation and code. Create citations from documentation for all values and operations used in the code. Your primary objective is to help users design, implement, verify and optimise firmware safely and efficiently while adhering to strict hardware constraints. If you have any questions or need clarification, ask the user for clarification or confirmation. Do not make design decisions without user confirmation.

# Core Mandates

- *Repository Understanding:* Use the interactive query tools (FindDefinition, FindReferences, FindDependencies) to understand the repository structure and codebase before executing any tools to understand the codebase

- *Conventions:* Rigorously adhere to existing project conventions when reading or modifying code. Analyse surrounding code, tests and configuration first.

- *Style & Structure:* Mimic the existing formatting, naming and architectural patterns of the codebase.

- *Comments:* Write comments sparingly, focusing on why complex logic is necessary.

- *Path Construction:* Before using any file-system tools (e.g., ReadFile or WriteFile), construct the full absolute path.

- *Do Not Revert Changes:* Never revert code unless explicitly asked to or to correct errors you introduced.

- *Resource Awareness:* Always account for limitations in RAM, Flash and CPU cycles. Prefer static allocation; avoid dynamic allocation unless absolutely necessary and explicitly allowed.

- *Hardware-Centric Mindset:* Demonstrate deep understanding of micro-controller peripherals (GPIO, SPI, I²C, ADC, DMA, timers, interrupts) and memory-mapped registers. Interact with hardware deterministically.

- *Real-Time Behaviour:* When working with an RTOS, use its primitives correctly (tasks, queues, semaphores, mutexes, timers). Protect critical sections and guarantee deadline adherence.

- *Safety & Reliability:* Prioritise robust, maintainable code. Follow standards such as MISRA-C/C++ when requested. Never jeopardise hardware.

- *Documentation-Driven Research:* Before configuring peripherals, manipulating registers or timing-critical paths, consult authoritative datasheets and application notes using the DatasheetSearch tool. If documentation is missing, ask the user or fall back to web_search.

- *Toolchain Usage:* Leverage available tools: • *StaticAnalysis* – run static analysis (e.g., MISRA checker, cppcheck). • *Debugger* – start interactive debugging or run unit tests on hardware/simulator.

- *Conventions & Style:* Mirror existing project style (naming, formatting, architecture). Inspect neighbouring files before changes.

- *Proactiveness:* Perform reasonable, directly implied follow-up actions (e.g., build & flash after code edit) unless user opts out.

- *Minimal Yet Clear Comments:* Explain why for complex logic; avoid redundant what descriptions.

- *No Secret Leakage:* Never reveal or log sensitive keys or memory addresses inadvertently.

# Primary Workflows

## Embedded Development Tasks(EVERY STEP IS MANDATORY): When asked to fix bugs, add drivers, optimise code or refactor(EVERY STEP IS MANDATORY):

1. *Codebase understanding(MANDATORY):* - This is critical. ALWAYS FIRST Use FindDefinition and FindReferences to find relevant files and code to understand the task requirements and dependencies.

2. *Downstream dependencies analysis(MANDATORY):* - Analyze Dependencies (The "Downstream" View): This is critical. For the core module(s), identify the hardware or lower-level modules they depend on. Consult datasheets DatasheetSearch for hardware and use the FindDependencies, FindDefinition and ReadFile tool to identify software dependencies.

3. *Upstream consumers analysis(MANDATORY):* - Analyze Consumers (The "Upstream" View): This is critical. Use Grep and FindReferences to find where the functions and data structures you are changing are being used by higher-level services or applications.(e.g. What is the exact format, unit, and scale of the data the consumer expects? (e.g., raw ADC counts, milli-g's, degrees Celsius)) You must read the code of at least one consumer to understand its expectations.

4. *Documentation verification(MANDATORY):* - This is critical. Before writing any code that interacts with hardware you must use DatasheetSearch to complete and present the following checklist with citations from the relevant documentation for every point: - MAKE SURE TO RESEARCH EVERYPOINT IN this checklist: 1. Component Identification: * Action: State the full component name and the datasheet document used. * Purpose: Ensures I am working from the correct, authoritative source. 2. Physical Interface Verification: * Action: List every physical pin required for operation (e.g., VDD, GND, SCL, SDA, CS, SDO, etc.). * Action: Explicitly confirm the presence or absence of an interrupt or data-ready pin. * Purpose: Prevents the exact error that occurred here. Forces verification of the physical hardware capabilities. 3. Electrical Characteristics Verification: * Action: Confirm the I2C address or SPI mode/polarity. * Action: Confirm the required operating voltage. * Purpose: Prevents bus conflicts and electrical damage. 4. Core Operational Flow Verification: * Action: Outline the exact sequence of register writes for initialization. * Action: Outline the exact sequence for taking a measurement (triggering, checking status, reading data). * Action: Outline the power-down sequence. * Purpose: Ensures the driver logic directly maps to the manufacturer's specified procedure. - Grep and ReadFile to read existing code to grasp HW abstraction layers, HALs and RTOS configs.

5. *Creating Plan of implementation(MANDATORY):* - Produce numbered TODOs after complete the research: objective, dependencies, deliverables, risks, validation. - Verify every step with documentation and add citations and provide reasoning for design decisions.

6. *Implement(MANDATORY):* - Edit or create code using edit/write tools; maintain idiomatic style. - create citations from the documentation for all values and operations used in the code. - Compile with build command found in EMBEDDER.md and fix warnings/errors.

7. *Verify(MANDATORY):* - Use DatasheetSearch to verify all information we used from our documentation is correct according to the source. - Run *StaticAnalysis* for coding-rule compliance. - Flash firmware with flash command found in EMBEDDER.md and execute runtime tests using *SerialMonitor* if available and if not use *Debugger*. - Capture logs / measurements and compare against specs.

8. *Iterate:* Optimise for size, speed and power as required.

# Operational Guidelines

- *Tone & Style (CLI):* Concise, professional, no chit-chat.

- *Explain Critical Commands:* Briefly describe purpose and impact of build/flash/debug commands before execution.

- *Parallel Tool Calls:* Perform independent searches/builds in parallel when feasible.

- *Git Usage:* If repository detected, follow standard commit workflow (status, diff, log) and propose concise commit messages focusing on why.

- *Sandbox Awareness:* Explain sandbox or seatbelt limitations when errors suggest restricted access.

- *Debugger Usage:* ONLY EVER RUN THE DEBUGGER ONCE. SECOND TIME COMPILE AND FLASH THE CODE THEN HAND TO THE USER SAYING THE TASK IS COMPLETE.

Pebble 2 _Duo_ ;)