Skip to content
Talk to us

AI-Assisted Engineering

Coding agents that write, test and review the code in your repository. Your engineers decide, and a person approves every merge.

We set up this system inside your repository, under version control, next to your code. You keep it if we stop. We started this work in 2025. Today it runs on our own products and on customer code in C, Rust and Go.

How we build it

  1. One toolchain for the agent and the engineer

    We pin your build environment with Nix, and the agent runs inside that same environment. So it uses the compiler, the linter and the tests that your engineers use. An agent with different tools reports faults that do not exist.

  2. Your domain, written down first

    Before the agents write code, we write down how your product works: a glossary, decision records and behavior specs. Each agent reads them, so it knows what correct means for your product, and not only for the language.

  3. The agent asks, and the engineer decides

    Large work starts as a map of open questions. An agent asks your engineer each design question in turn. Each answer becomes a decision record, and every later agent reads it.

  4. A plugin, not a prompt

    We deliver a versioned plugin through a marketplace. Your team installs it with one command. A prompt in a chat window helps one person one time. A plugin helps every engineer, every day, and you can review it in a pull request.

  5. Unattended agents take the ready work

    Your engineer marks an issue as ready. An agent takes it, works in a sealed container and opens a pull request. If it cannot finish, it gives the issue back with its notes. The queue runs while your engineers do other work.

  6. The container is sealed

    Each run gets a token for one repository, and the token expires in one hour. The agent reads the issue as data, not as instructions. Limits on time, cost and parallel runs, and a kill switch, stop a run that goes wrong.

  7. Many small agents, and one that checks

    Four review agents read each pull request on three axes: your standards, the spec and correctness. A separate agent then checks each finding before it is posted. Small agents with one task each find more than one large agent.

  8. Every change passes the same gate

    Build, tests, format and lint run on every pull request, from an engineer or from an agent. The agent does not run on one laptop only. A person approves the merge.

  9. Third-party skills stay legal

    We publish ai-plugin-vendor-tool. It copies a skill from a public source, pins the version in a lockfile, and credits the author in a NOTICE file. You then know what you use, and where it came from.

A legacy controller, moved to Go in 135 engineer hours

An agricultural equipment maker ran its control services in Python, on ARM devices built with the Yocto Project. One of our engineers moved them to Go with agents. The new code runs next to the old fleet during the change.

The engineer answered the design questions and decided what the agents built. The agents wrote the code, the tests and the reviews.

135 h
of tracked engineer time, less than four 40-hour weeks
22
porting tasks finished, of 23 planned
421
merged pull requests, and not one revert
40%
of the pull requests came from unattended agents

The test code is larger than the product code, with 1,364 test functions. The 135 hours include the set-up of the unattended agents, and that set-up took four of them.

You can check this yourself

ShellHub is a public product with an Apache-2.0 license. We added the AI review to it in February 2026, and it still reads every pull request. Every review it wrote is public.

700+
public pull requests carry an AI review
97%
of the pull requests since February 2026 got one
1,400+
findings posted as comments on the code
See the reviews on GitHub

We also say when an agent helped upstream. Our merged changes to nixpkgs carry an Assisted-by line, and two of them package Yocto Project and Zephyr Project tools.

See them in nixpkgs

Questions we are asked

  • What is AI-Assisted Engineering?

    It is a development system around coding agents, set up inside your repository. The agents write, test and review the code. Your engineers decide what to build, and a person approves every merge.

  • Does it work on embedded and firmware code?

    Yes. We use it on C, Rust and Go, in Yocto Project, Zephyr Project and UEFI firmware products. We also run it on our own products.

  • What happens to the system if we stop working together?

    You keep it. It lives in your repository, under version control, next to your code.

  • How do unattended agents stay under control?

    Each run works in a sealed container, with a one-hour token for one repository. Limits on time and cost, and a kill switch, stop a run that goes wrong.

  • How do I start with AI-Assisted Engineering?

    Start with a Starter on one repository, for a stack that we already have a kit for. If your case is not standard, start with a paid Diagnostic.

Send us a message about your product

A few lines are enough: what the device does, which processor it uses and when it must ship.

For example

We make a gateway on an NXP i.MX 8M Plus. We need a Yocto BSP and secure updates in 3 months.

An engineer who does this work reads your message and answers you.