My desk has been a mess for a while now, so I decided to lean into the chaos and share a practical development update instead of cleaning it up first. Over the last couple of weeks, I’ve been working on adding Luckfox Pico support to my fork of SeedSigner, which is now called ShieldSigner. This builds on earlier work done by Lightning Spore about a year ago.
I thought this was a good opportunity to test some AI coding agents—ChatGPT Codex, Claude Code and GitHub Copilot—on a real embedded Linux problem rather than just running through toy examples. I’m not claiming to be an expert in software development or AI workflows, but the lessons I learned should be useful if you want to use these tools in practice, or if you are thinking about porting SeedSigner/ShieldSigner to another single-board computer.
Watch the video for the full walkthrough. This article is a standalone written version of the same process and learnings.

The project: adding new SBC support to SeedSigner/ShieldSigner
SeedSigner is basically a Python app running on Linux. That makes it possible to move it onto different single-board computers, as long as the board has enough RAM and the right peripherals for your use case. In this update, I was working with boards such as the Libre Computer La Frite and Luckfox Pico variants.
The goal was not “vibe coding” in the flashy sense. The goal was to reduce tedious porting work: Buildroot configuration, IO mapping, CI builds, boot issues, camera problems, display wiring and device debugging. Security still matters here because this is a wallet-related project, so AI-generated changes need human review before they are trusted.
Step 0: Do not use the AI as just a chatbot
The first lesson was simple: if you only paste code snippets into a normal chatbot, you will waste time. A general answer might be okay for brainstorming, but it is not enough when you need changes across an existing project.
To get useful results, I used AI coding tools that could access the full repository. That can mean an editor plugin, such as the ChatGPT extension in Visual Studio Code, or a browser-based agent connected to GitHub.

The important part is context. The AI needs to see the whole codebase it is trying to work on, not just one file or a small snippet. When it understands the surrounding project structure, build system and existing patterns, its suggestions are much more useful.
Cloud-first builds changed everything for me
One of the biggest changes in this round of development was moving Buildroot work into GitHub Actions instead of running long local builds on my PC.
When I added smart card support to my SeedSigner fork about 18 months ago, I did most of that Buildroot development locally. Builds often took 30 to 40 minutes each, tied up my machine and required digging through logs manually. This time, the workflow was cloud-first.
That made several things easier:
- My local PC stayed free for other work.
- Development images could be produced in a way that is easier for others to access.
- The AI agent could inspect build results and iterate on failures without me babysitting a local terminal.
- I could kick off tasks from my phone or browser and check back later.
For example, when adding support for the Libre Computer La Frite, I asked GitHub Copilot to add a Buildroot profile and ensure that all smart card dev profiles were tested. That meant testing not only the new board profile but also existing ones, in case something else broke.

The agent produced a pull request with changes and linked GitHub Actions runs. When a build failed, I did not need to write a long prompt explaining every detail. A simple prompt like “the build failed—can you work out why?” was enough in many cases. Over several iterations, the builds started passing, and then I could move on to live device debugging.

The fixes suggested by the AI were not exotic. They were similar to changes I would have made myself. The difference was speed and reduced tedium. Instead of manually waiting for local builds, reading logs and applying patches one by one, the loop happened in the cloud while I reviewed the results.
Run multiple approaches in parallel
Another advantage of cloud-first work is that you can test different approaches at the same time.
While working on SeedSignerOS changes, I also started tasks to add La Frite support into the main SeedSigner app repository. Those changes were smaller because much of the portability groundwork had already been done for Luckfox Pico boards. Most of it involved IO mapping and configuration.
I also ran separate agent tasks to explore different Buildroot approaches for the La Frite, plus another task for a Radxa ZERO 3E environment while I was at it. This kind of parallel exploration is much harder when every build occupies your local machine for an hour or more.
Feedback loops matter more than perfect prompts
One of my biggest takeaways: feedback loops are more important than trying to write the perfect prompt.
An AI tool does not truly know what “correct” means in your project. It can generate plausible code, but it may also make mistakes that look reasonable on the surface. If your project has good CI tests and build logs, the agent gets verifiable feedback. That changes everything.
For this kind of work, I want:
- A build system that produces clear pass/fail results.
- Unit tests where possible.
- Continuous integration tests with predefined inputs and expected outputs.
- Build logs that the AI can read after a failure.
- A way to inspect live device behavior when software is running on hardware.
If your code has solid CI coverage, the AI can check whether its changes still pass. If not, it may do something surprising. During this project, I saw cases where an agent would remove or weaken tests just so everything appeared green. That is why you need to review carefully what changed and why.
This is especially important for security-related software. You should not assume that a passing build means the system is safe. AI-generated changes still need manual review, lock-down checks and careful validation of inputs, outputs and behavior.
Use an Agents.md file to guide the AI
Another lesson was that you should give explicit guidance about how the AI should behave in your repository.
Almost every serious programming-oriented AI tool supports some form of instruction file, such as Agents.md. This is where you can tell the agent what matters for your project: coding style, UI constraints, security practices, areas not to refactor, and behaviors to avoid.
For a SeedSigner-style project, that guidance should include things like:
- Keep the UI usable on small screens.
- Follow existing security practices.
- Be careful with entry generation and private key handling.
- Clean up sensitive data properly.
- Avoid unnecessary refactors.
- Do not add unrelated features or architectural changes.
Without this kind of guidance, an AI tool might decide to restructure large parts of the codebase for no good reason. It may introduce patterns that do not fit your project requirements. An instruction file helps keep the work focused and safer.
Image recognition helped with pinouts and IO maps
One surprising win was using image recognition for schematics and IO diagrams.
I was working across several Luckfox Pico variants, and each one has its own unique pin configuration. The documentation often uses images: pin numbers on the sides, alternate functions, GPIO labels, SPI/I2C/UART mappings and so on. Even boards from the same family can be inconsistent, which means you may need a different hardware profile for each one.
That becomes frustrating when you are wiring buttons, displays, cameras or smart card readers late at night. It is easy to mix up pin assignments between similar boards.
I fed schematic images and IO diagrams into ChatGPT Codex and asked it to compare them against the existing configuration. The result was almost completely correct. In one case, it got only one pin wrong. I then gave it more board images and related documentation, and it helped identify a few small mistakes I had introduced while juggling between boards.

This was genuinely useful. If you have built embedded systems before, you know how painful it can be to match IO across multiple peripherals and board revisions. AI image recognition is not a replacement for checking the hardware yourself, but it can dramatically reduce the time spent cross-referencing diagrams.
Let the AI debug live devices over ADB or SSH
Another useful capability was using command-line-based AI tools to interact directly with embedded devices.
Some of these boards ship with ADB enabled by default. From a terminal, I could connect to the device and run normal Linux commands. That included starting SeedSigner, checking logs and inspecting system state.
In one case, the app was running but the camera was throwing an error. I connected the AI tool to the repository and allowed it to talk to the device over ADB. It checked where the camera should respond, found that it did not, and helped identify the problem. In the end, the issue was simpler than expected: the camera had been plugged in the wrong way.

This kind of workflow is very useful when developing Python apps for embedded Linux. You can code in your IDE, ask the AI to push changes to the device, run them and inspect errors automatically. It can query system details, read logs and help identify Linux-specific quirks that would otherwise require manual digging.
For the Libre Computer La Frite, I also used SSH to debug issues on the device, including an SPI bus problem with the screen. The AI helped fix those issues once it could see the relevant environment and error output.
Different tools are better for different tasks
I tested three main tools: ChatGPT Codex, Claude Code and GitHub Copilot. All of them can be useful, but they have different strengths.
ChatGPT Codex
ChatGPT Codex worked well when connected to GitHub. I could link it to a repository, select a branch and ask it to make changes. It was good for cloud-based tasks and for working inside Visual Studio Code.
My main complaint was that its documentation and comments were sometimes light. It would produce code without always explaining why it made certain choices. That is not fatal, but for a security-sensitive project I want more clarity around decisions.

Claude Code
Claude Code impressed me with documentation quality. It was often better at explaining why it did something and producing useful notes along the way, which is closer to how I would hope a human developer would work.
However, I had less success using its browser-based or cloud workflow compared with Codex. Basic GitHub interactions felt clunkier in some cases, and I kept hitting session limits more often. For my use case, that made it less convenient as the main driver for long-running repository tasks.
GitHub Copilot
GitHub Copilot was very useful because of how well it integrates with GitHub repositories and GitHub Actions. The workflow I used—debugging builds from CI logs, opening pull requests and iterating on failures—worked almost out of the box.
That matters a lot. You can spend time configuring other tools to do similar things, but if you are trying to make progress on a real project, “what just works” is valuable. Copilot also gives access to different AI models through one interface, which makes it easier to compare behavior without rebuilding your entire setup each time.

For me, the choice came down to documentation quality, session limits, pricing and how smoothly the tool integrated with my existing GitHub workflow. I ended up moving back to Codex in Visual Studio Code for some work because its session limits were more practical for what I was doing. But Copilot was excellent for repository-level tasks tied directly to GitHub Actions.
What worked on the La Frite
By the end of this update, the Libre Computer La Frite was running modified SeedSigner code that had been adjusted with AI assistance. The IO mapping and configuration were in place, and I used SSH to debug remaining issues on the device, including an SPI display problem.
The camera setup was also working using a USB webcam. There is still more work to do for a polished Buildroot image, but the major body of getting it running on that board was done. In total, I spent maybe one to two hours on the whole process from start to finish, with Copilot doing much of the heavy lifting.

Near the end, I also got a Buildroot image working properly on the La Frite. There was a boot issue, so I connected a serial port adapter, fed the boot log to an AI tool and it identified the problem quickly. It then helped produce a patch that fixed the issue. That was impressive because documentation for some of these single-board computer quirks can be poor or hard to find.
Notes on porting SeedSigner-style apps to Linux SBCs
If you are thinking about porting SeedSigner, ShieldSigner or another Python-based embedded app to a new SBC, the process is not as mysterious as it sounds. Under the hood, these boards are running a cut-down version of Linux. If the board can run the operating system and your application with enough RAM, the main work usually involves:
- Getting a base Buildroot or Linux environment working.
- Mapping GPIO, SPI, I2C, UART and camera peripherals correctly.
- Adding or adjusting hardware profiles in the app.
- Setting up CI builds so changes can be tested repeatedly.
- Debugging boot logs, service startup and device-specific issues.
- Reviewing all AI-generated changes carefully from a security perspective.
I have been impressed that this codebase has run nicely on smaller boards such as the Luckfox Pico Mini with 64 MB of RAM. That said, you should not treat an AI-assisted dev image as final without proper hardening and review. The goal is to make development faster, not to skip security work.
If you are working with Luckfox Pico hardware for this kind of project, the LuckFox Pico Mini RV1103 Linux Development Board is a compact starting point. For a more complete ShieldSigner-style setup on that platform, the ShieldSigner+ Display Hat, Smartcard Reader & USB-C Power for Luckfox Pico can simplify display and smart card integration. If you want to keep the build tidy, the 3D Printed Case for ShieldSigner Plus Smartcard Pico Mini Hat is a natural companion. For camera work on Luckfox Pico boards, you can also look at the Luckfox Pico Camera Module 3PM SC3336 in Zerocam size or the Low Profile version, depending on your hardware layout.

Conclusion
The main takeaway is that AI coding agents can be genuinely useful for embedded Linux development when you give them the right context and feedback. Full repository access, cloud builds, CI tests, clear instruction files, image-based IO references and direct device debugging all matter more than trying to craft one perfect prompt.
For this project, ChatGPT Codex, Claude Code and GitHub Copilot each had strengths. Some were better at documentation, some at IDE integration, and some at working smoothly with GitHub Actions. The best choice depends on your workflow, session limits, pricing and how much setup you are willing to do.
What I found most valuable was not that the AI wrote magic code by itself. It was that it removed a lot of tedious iteration: waiting for builds, reading logs, cross-checking pinouts and testing small fixes across multiple boards. As long as you keep security review in mind and validate the results yourself, these tools can make porting Python-based embedded apps much faster.
Stuck with a wallet recovery?
I maintain BTCRecover and have helped people recover seed phrases, passphrases and wallet passwords since 2019. Book a one-hour video session and I’ll walk you through doing the recovery yourself, without sharing your seed. Or, if you’d rather I run it, a trusted recovery is charged only if it succeeds.
Private sessions: US$100 per hour. Trusted recovery: 10% of recovered funds. I never contact people first and will never ask for your seed phrase over chat or email.
Found this useful?
These guides are free and ad-free. You can support them by sharing them, subscribing on YouTube, or sending a tip.







