RV

    rtl verilog lint

    1

    Catch Verilog/SystemVerilog that simulates but won't synthesise: latches, blocking assigns, resets, multiple drivers.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more
    RV

    rtl verilog lint

    Example session with this skill installed

    Review this module for synthesis issues: always @(posedge clk) if(en) out = in; always_comb if(sel) y = a;

    • Read your context and instructions
    • Compiled the rtl verilog lint

    I have reviewed the RTL for synthesis compatibility. The check identified two critical errors regarding assignment types and latch inference.

    RTL Lint Audit Results

    FileSeverityLineFindingRecommendation
    module.svERROR2Blocking assignment (=) in clocked blockReplace = with <= to avoid simulation races.
    module.svERROR3Inferred latch in always_comby is not assigned when sel is low. Add a default or initial assignment.
    module.svWARN1Missing `default_nettype noneAdd at top of file to prevent implicit 1-bit wire creation.

    Corrected RTL Implementation

    `default_nettype none
    
    module my_logic (
        input  wire clk,
        input  wire en,
        input  wire [7:0] in,
        input  wire sel,
        input  wire [7:0] a,
        output logic [7:0] out,
        output logic [7:0] y
    );
    
        // Fixed: Using non-blocking assignment for clocked logic
        always_ff @(posedge clk) begin
            if (en) begin
                out <= in;
            end
        end
    
        // Fixed: Preventing latch by assigning default value
        always_comb begin
            y = 8'h00; 
            if (sel) begin
                y = a;
            end
        end
    
    endmodule
    
    `default_nettype wire
    

    Next steps

    1. Run scripts/check_synthesizable.py to confirm no remaining text-level violations.
    2. Execute scripts/lint_rtl.sh to trigger Yosys elaboration and verify no hidden latches.
    3. Confirm if the target is FPGA or ASIC to optimize the reset strategy.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Verilog that simulates perfectly but fails in hardware is a expensive mistake. This skill enforces synthesisable RTL discipline, catching latches, race conditions, and simulation-only constructs before they reach your synthesis tool.

    What it does

    • Enforce assignment rules by ensuring non-blocking assignments in clocked blocks and blocking assignments in combinational logic.
    • Prevent latch inference by verifying every output is assigned on every path through combinational blocks.
    • Detect driver conflicts by flagging signals written to by multiple procedural blocks.
    • Validate port widths by checking for implicit wires, unsized literals, and dangerous signed/unsigned mixing.
    • Sanitise design files by identifying simulation-only constructs like initial, fork/join, and real that won't synthesise.

    How it works

    1. Define the target by specifying the FPGA family or ASIC PDK to align reset styles and memory inference.
    2. Execute fast checks using scripts/check_synthesizable.py for immediate feedback on common RTL defects.
    3. Run the full lint flow via scripts/lint_rtl.sh to trigger Verilator, Verible, and Yosys elaboration passes.
    4. Review findings categorized by error (synthesis failure), warn (bug risk), or info (timing/area impact).

    Frameworks & tools

    Works with SystemVerilog and Verilog source files. Integrates with Verilator, Verible, Yosys, and vendor tools like Vivado or Design Compiler for elaboration checks.

    Why this beats prompting it yourself

    Generic AI prompts often miss subtle Verilog semantics like the difference between always @(*) and always_comb regarding latch reporting. This skill applies a specific hardware-centric rulebook and uses script-based validation to ensure findings are grounded in synthesis reality rather than just grammar.

    Use cases

    • Pre-synthesis auditing to catch "simulation-synthesis mismatch" bugs in new modules.
    • Refactoring legacy RTL to move from always blocks to modern, stricter always_ff and always_comb constructs.
    • CI/CD integration by using the non-zero exit codes from the provided python checker to gate PRs.
    • ASIC/FPGA migration to ensure reset logic and memory instantiation style match the new target platform requirements.

    Known limitations

    The Python checker is a text-based scanner and does not expand macros, resolve includes, or process generate blocks. Full elaboration requires Yosys or Verilator.

    Text-based checker does not expand macros or resolve includes. Lacks CDC and timing analysis. Synthesis remains the final authority on hardware realization.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 13 days ago

    • Free with an Agensi account

    Requires

    Python

    Permissions

    Terminal / Shell
    Read Files
    Listed13 days ago

    What's inside

    Frequently Asked Questions

    This skill detects 'silent' hardware bugs like unintended latches, race conditions, and simulation-synthesis mismatches that standard simulators often miss but cause total failure in actual FPGA or ASIC hardware.

    The purchase includes the core linting engine, a fast-check Python script for immediate feedback, shell scripts for full elaboration flows (Verilator/Yosys), and pre-configured rule sets for different synthesis targets.

    Yes, the provided scripts are designed with non-zero exit codes, making it easy to integrate into CI/CD pipelines to automatically block pull requests that contain non-synthesizable code.

    The text-based Python scanner is tool-agnostic, while the full elaboration flow requires Verilator, Verible, or Yosys to be installed in your agent's environment or local machine.

    While the core scripts work locally, the skill is optimized for AI agents capable of file manipulation and terminal execution, allowing the agent to identify, explain, and fix RTL errors autonomously.