
Edward Viaene is the managing director of in4it and is based in Austin. He co-founded IN4IT in May 2015 and has served as its co-founder and managing director since March 2021.
Before that, he was a training instructor and developer at Big Data Partnership from April 2014 to May 2015. He spent two and a half years at JPMorgan Chase, joining as an information risk analyst in September 2011 and becoming VP information risk manager in September 2012. In 2010 he lectured at The Belgium Campus. He co-founded VibiT BVBA in September 2006, remaining until August 2011, and had earlier worked briefly as a system administrator and developer at Tigron in 2006. He founded Webware in August 2003 and stayed until October 2006.
Viaene studied applied computer science at Katholieke Hogeschool Leuven, completing a bachelor's degree in 2006, and took a Master of Science in economics and business at Hogeschool-Universiteit Brussel from 2009 to 2011. He followed this with postgraduate study in international business practice at St Mary's University College from 2011 to 2012.
Across these sources, Edward Viaene is building a hardware-in-the-loop testing platform, BenchPod, and treating AI agents as active participants in that build rather than as code-completion tools. Early posts focus on getting the hardware itself right, chip selection, PCB bring-up fixes, cost tradeoffs, and by mid-2026 the emphasis shifts to letting Claude Code and MCP-connected agents actually flash firmware, configure ADC/DAC, drive the FPGA and run end-to-end hardware tests through BenchPod's own API . The recurring preoccupation is repeatability: capturing real failure modes (a stalling step motor, a solar panel's I-V curve, a fault waveform) so they can be replayed and tested against firmware behavior on command .
Over time the framing hardens from "AI helps me code" toward "AI operates the bench": by July 2026 he logs 167 hours of Claude Code pairing directly with hardware, building the test device and then using it to test the device under test , and describes this explicitly as "Building The Machine That Builds Machines" .
Viaene's clearest claim is that agentic AI has moved past generating smarter test cases into physically controlling test equipment: "'AI-assisted testing' used to mean smarter test case generation. Now it means an agent that can physically control your device under test" . BenchPod exists to make that possible, exposing "a hardware control API over MCP, which means any MCP-compatible agent (including Claude) can drive it directly" , and in his own account it "built the test device (BenchPod) and then used it to test the Device Under Test: flashing firmware, configuring the ADC/DAC, driving the FPGA, and running end-to-end hardware tests, all via tool calls" . He is also candid that this isn't magic: a Claude MCP session on the v1 board "didn't finish in one go because I had to tell it not to use the NRST pin" .
He extends the same trust to AI for pure software problems outside hardware control, describing a Linux/GPIB driver failure where Claude Opus kept blaming the hardware until he asked it to write a fresh implementation instead: "20 minutes later, it started to read the measurements over USB from the Multimeter using pure Python and pyusb. Took me less time to write a driver than to get the actual driver working somehow" .
A second theme is that hardware bugs are only useful if they can be captured and rerun. Talking through step-motor stalls, he asks "How fast can the software respond to a failure?" and notes that once a firmware fix exists, "we could now test whether the timing of the firmware was as expected, and whether it stays like that, by writing a CI test that covers this" . Some failures are nearly invisible in the field: "a stall that only shows as a small current increase, but wasn't captured by the firmware," and his answer is to save and replay the capture . This depends on hardware that can sample multiple domains on one clock and stay attached indefinitely: "digital + analog captured together, on hardware cheap enough to leave permanently wired to your target" , and BenchPod is pitched as running "DAC, ADC, and Logic Analyzer at the same time within ±20ns (with only a $100 BOM...)" .
Viaene repeatedly justifies component choices by total system cost rather than sticker price. Moving the orchestrator MCU, he writes: "The chip price looks like a big jump, but once you factor in the external flash, external crystal, SMPS inductor, and the W5500 you'd need for Ethernet, the real difference is smaller than it appears" . On routing constraints from a large MCU package, he still concludes "To keep it affordable, it's still better than going to more layers or a bigger board, though" . He's also self-critical about last-minute changes: "most of my mistakes come from quickly adding something just before sending it for manufacturing," citing a wrongly-oriented TVS diode and a boot button placed too close to SWD on the v2 board .
For EPS testing he takes the position that if the right stimulus source doesn't exist, build it: "I don't have a current source, so I'm building one" , using an op-amp and MOSFET to emulate a solar panel's voltage and current behavior, including sunrise, clouds, and shadows . He treats component failures in this rig as data, not just setbacks: "went through 2x OPA2192s, likely killed by feedback-loop spikes outside spec" before swapping to a TLV9151 , and frames the payoff as closing the loop entirely in software: "we now have enough to build an I-V control loop in software. We'll drop voltage as current approaches the I-V knee" .
In the demo material, separate from the BenchPod/EmbeddedCI posts, Viaene teaches Go networking fundamentals rather than hardware testing. He walks through Go 1.22's net/http wildcard routing, showing that developers can now "extract wildcard values using request.PathValue()" without third-party packages like Gorilla Mux or Gin 13. He also goes underneath the standard library entirely, building an HTTP server with net/http and then "constructing HTTP requests manually using raw TCP sockets to understand the underlying protocol mechanics," using telnet to craft a GET request by hand 14. A third demo shows him using Go to launch containers directly via the containerd API on Lima 15, again favoring working with an API at a low level over reaching for a higher-level tool.
From public career histories · 12 entries
Edward Viaene discusses Go 1.22's new routing enhancements to the net/http package, which now supports wildcard routing using syntax like `{id}` to capture path segments, whereas previous versions required third-party packages like Gorilla Mux or Gin for this functionality. He explains that developers can now extract wildcard values using `request.PathValue()` and demonstrates practical examples of how to implement simple wildcard routes without external dependencies.
Edward Viaene demonstrates how to build HTTP servers and clients in Go, starting with the net/http package library and then showing how to construct HTTP requests manually using raw TCP sockets to understand the underlying protocol mechanics. He walks through examining the HTTP RFC specification, creating a basic Go HTTP server that listens on a port with request handlers, and then manually crafting HTTP GET requests using telnet to show how HTTP requests work at the protocol level.