Build Log #01: From RTL Generation to Verification

SiliCode Build Log #01 | October 2026
Writing an RTL module is only the beginning of a hardware-design workflow. Once the Verilog or VHDL exists, an engineer still needs to ask harder questions: Does the module implement the intended behavior? What was actually tested? Can the results be inspected and reproduced?
We're starting this build log to share how we think about those questions, what we're working on, and what we learn from other FPGA and ASIC engineers. This first entry is a look at our current workflow and the technical example we're preparing next—not a claim that a new feature shipped this week.
Why generating HDL is not enough
AI can produce plausible RTL quickly. But code that parses or synthesizes is not necessarily functionally correct. Even a passing testbench has limits: if the specification is ambiguous, the implementation and its generated tests may share the same mistaken assumption.
That is why we think the useful unit of output is not just a code snippet. It is a collection of artifacts that an engineer can review: the requirements, the generated module, executable checks, simulation results, and synthesis feedback.
What the SiliCode workflow looks like today
SiliCode focuses on a hardware module described in natural language. Depending on the run settings, the workflow can:
- Turn a module description into a more explicit set of ports and expected behaviors.
- Generate synthesizable Verilog, SystemVerilog, or VHDL for the supported workflow.
- Produce a matching self-checking testbench.
- Run simulation when automated verification is enabled and provide the resulting logs.
- Provide synthesis output and a resource estimate for the selected target family.
- Export artifacts for review in the engineer's own toolchain.
These checks are evidence, not sign-off. A synthesis estimate does not establish timing closure, physical implementation correctness, or readiness for production. Hardware engineers still need independent review and the appropriate vendor flows.
For a deeper explanation, see How SiliCode Works.
A lesson from our own FPGA tooling workflow
We also spent time looking at a community discussion about FPGA toolchain friction. One complaint was especially familiar: keeping a Vivado project manageable in Git while still being able to rebuild it elsewhere.
Our hardware team typically avoids treating the full GUI project directory as the source of truth. Instead, the team works in Vivado Non-Project Mode, drives the flow from a central script, and keeps generated project data out of the main repository where possible. When visual inspection is useful—for example, to investigate a synthesis result or trace a path—the flow can produce a checkpoint that can be opened in the GUI.
This approach can reduce repository noise, but it does not remove the need to manage source files, constraints, IP dependencies, tool versions, and clean-build checks. It is a practical team workflow, not a claim that SiliCode itself replaces Vivado project management.
The broader lesson is useful for our product work: engineers need to know which inputs produced which outputs, and they need a clear way to inspect the evidence.
Next up: a packet counter with real test artifacts
We're preparing a small packet-counter example with a valid/ready handshake. Its behavior is simple enough to review, but it exposes several verification cases worth checking:
- Synchronous reset and reset priority.
- No count increment while backpressure prevents a handshake.
- Exactly one increment on an accepted end-of-packet transfer.
- Consecutive accepted packet transfers.
- Counter wraparound at a defined width.
Our next step is to run the example, review the produced RTL and testbench, and share the actual logs and synthesis artifacts. The tests and results are not being reported as complete in this entry. If an expected check fails, that will be part of the story too.
What we'd like to learn from engineers
When working on a new RTL block, where does the most time go: clarifying specifications, writing testbenches, debugging simulation, or dealing with the surrounding toolchain?
We're especially interested in cases where automated checks look green but an independent review later finds a missed assumption.
Explore SiliCode or request a walkthrough
Take a look at SiliCode's RTL workflow. If you'd prefer to see the product live and discuss your own FPGA or ASIC use case, request a live walkthrough.
Next build log: the packet-counter example, with concrete artifacts and what the checks actually showed.