top of page
Adiuvo Engineering & Training logo
MicroZed Chronicles icon

MicroZed Chronicles: Agentic AI

One of the most talked-about areas in recent engineering workflows is the use of AI to generate code. I’ve explored this in the past, comparing Claude, Grok, and ChatGPT by asking them to create something simple such as a blinking LED. But as the models have matured, I wanted to revisit the topic and look at what has improved, especially now that agentic AI workflows are becoming practical.



If you're unfamiliar with agentic AI, the key difference is that instead of only generating code, the AI is able to plan, write, test, debug, and refine the solution. In other words, we are no longer interacting with a passive assistant but with an autonomous agent capable of iterating toward a correct implementation.


As I’ve mentioned before, I like using VS Code for FPGA development, which makes it a natural place to experiment with agent-based tools. To try this out, I installed GitHub Copilot, starting with the free tier and then upgrading to Copilot Pro to access the full agentic features. Once installed, I set up a new workspace with a README describing the requirements for a fairly modest but non-trivial design:


  • Use VHDL-2008

  • 100 MHz input clock

  • Active-high synchronous reset

  • UART with generics for:

    • Baud rate

    • Parity

    • Stop bit (1 or 2)

  • 8-bit LSB-first TX and RX

  • Idle line state '1'

  • Single stop bit

  • AXI-Stream output for received data

    • tuser indicates parity error

  • AXI-Stream input for transmitted data

  • Create:

    • The RTL

    • A self-checking testbench

    • A Vivado 2025.1 project with constraints, targeting the Arty S7-50

      • This design should loop back the RX to the TX

  • Use the Vivado Simulator


Once these requirements were in place, I let Copilot take over. The agent began by planning the architecture, then generated the RTL, the testbench, and the supporting files. After that, it automatically attempted to compile and simulate the design.



The first run produced an error, which Copilot analyzed before updating the files and trying again. The reasoning and corrective steps were visible directly in the Copilot window, making the process surprisingly transparent.



The second simulation ran, but the functionality was not fully correct, some expected behaviours failed. Copilot detected the issue, reviewed the waveform activity, and produced additional corrections. On the next iteration, the testbench passed.



Naturally, we should never trust an automated tool blindly, so I opened the waveform for manual inspection and in this case, the behaviour looked exactly as intended.



The instructions asked Copilot to generate a loopback testbench, wiring the AXI-Stream interfaces together so the UART could echo whatever it received. It produced the required modules, the simulation ran, and the waveforms again looked correct.


The final instruction was to create a Vivado project taking the design through to hardware on the Arty S7-50 confirmed the expected echo behaviour on the physical UART interface.




What does the code look like, I have put the code generated in a github repo, however, I also ran the code through Blue Pearls Visual Verification Suite, I had a base set of checks enabled. The code does not flag any of the checks apart from one which is related to the parity error indication on Tuser which I had not defined with to do with.



This was my first experience with a fully agentic AI workflow, and it feels genuinely transformative, another step up in abstraction.


Of course, there are broader considerations, particularly in professional settings, where reliability, traceability, and security matter deeply. But AI is here to stay, and as engineers we need to understand its strengths, limitations, and how it fits into our development flows.


Used in the right way, agentic AI can be a powerful tool for generating simple IP, scaffolding project frameworks, or accelerating routine engineering tasks.


What hasn’t changed is the need for engineering judgement and knowledge: knowing what you’re building and what “correct” actually looks like. But with that understanding, these tools can become an extremely productive part of our workflows.


FPGA Conference

FPGA Horizons US East - April 28th, 29th 2026 - THE FPGA Conference, find out more here.


FPGA Journal

Read about cutting edge FPGA developments, in the FPGA Horizons Journal or contribute an article.


Workshops and Webinars:

If you enjoyed the blog why not take a look at the free webinars, workshops and training courses we have created over the years. Highlights include:



Boards

Get an Adiuvo development board:

  • Adiuvo Embedded System Development board - Embedded System Development Board

  • Adiuvo Embedded System Tile - Low Risk way to add a FPGA to your design.

  • SpaceWire CODEC - SpaceWire CODEC, digital download, AXIS Interfaces

  • SpaceWire RMAP Initiator - SpaceWire RMAP Initiator,  digital download, AXIS & AXI4 Interfaces

  • SpaceWire RMAP Target - SpaceWire Target, digital download, AXI4 and AXIS Interfaces

  • Other Adiuvo Boards & Projects.


Embedded System Book   

Do you want to know more about designing embedded systems from scratch? Check out our book on creating embedded systems. This book will walk you through all the stages of requirements, architecture, component selection, schematics, layout, and FPGA / software design. We designed and manufactured the board at the heart of the book! The schematics and layout are available in Altium here.  Learn more about the board (see previous blogs on Bring up, DDR validation, USB, Sensors) and view the schematics here.


Sponsored by AMD

bottom of page