Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    synthesizable rtl style

    1

    ASIC-oriented SystemVerilog coding guidelines for clear, maintainable, and synthesis-friendly RTL.

    Free

    1 useSecurity scanned
    synthesizable rtl style

    synthesizable rtl style

    Example session with this skill installed

    Refactor the following 8-bit adder into clean, synthesizable SystemVerilog following ASIC-oriented RTL coding conventions.

    Preserve the original functionality, including 8-bit output truncation. Make signal naming, data types, arithmetic widths, and carry handling explicit.

    module add(
        input [7:0] a, b,
        output [7:0] sum
    );
        assign sum = a + b;
    endmodule
    

    Explain the changes and why they improve RTL clarity and maintainability.

    • Read your context and instructions
    • Compiled the synthesizable rtl style

    Refactored Synthesizable RTL

    The module has been refactored according to ASIC-oriented SystemVerilog coding conventions while preserving its original 8-bit addition behavior.

    1. Refactored Code

    `default_nettype none
    
    module add (
        input  logic [7:0] i_a,
        input  logic [7:0] i_b,
        output logic [7:0] o_sum
    );
    
    logic unused_co;
    
    assign {unused_co, o_sum} =
           {1'b0, i_a} + {1'b0, i_b};
    
    endmodule
    
    `default_nettype wire
    

    2. Key Improvements

    AreaOriginalRefactored
    Data typesImplicit net typesExplicit logic
    Port naminga, b, sumi_a, i_b, o_sum
    Arithmetic widthImplicit sizingExplicit 9-bit operands
    Carry handlingImplicitly discardedCaptured as unused_co
    Net declarationsImplicit nets permitteddefault_nettype none

    3. Why These Changes Matter

    Explicit hardware intent

    Using logic and consistent port prefixes makes signal directions and ownership easier to understand during RTL review.

    Predictable arithmetic behavior

    Both operands are explicitly zero-extended to 9 bits before addition.

    The complete result is assigned to a 9-bit concatenation. The carry-out is captured separately as unused_co, making the intentional truncation visible in the source code.

    Improved tool robustness

    The default_nettype none directive prevents accidental implicit net declarations caused by misspelled signal names. The previous setting is restored at the end of the file for integration with other compilation units.

    Maintainable conventions

    Consistent naming and explicit intermediate widths improve readability during synthesis review, waveform debugging, and later design modifications.

    4. Functional Behavior

    The original module implements 8-bit modular addition:

    [
    o_sum = (i_a + i_b) \bmod 256
    ]

    For example

    Input AInput BOutputDiscarded carry
    1020300
    255101
    200100441

    The refactoring preserves this behavior. It does not introduce saturation, overflow protection, additional latency, or registers.

    5. Important Notes

    • The adder remains purely combinational.
    • The carry is intentionally unused by downstream logic.
    • No new hardware behavior is introduced.
    • This is a source-level refactoring; functional equivalence and synthesis results have not been independently verified.

    Result: Cleaner RTL with explicit widths, consistent naming, and clearly documented arithmetic intent, suitable for ASIC-oriented development workflows.

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

    About this skill

    Write Better Synthesizable SystemVerilog

    A practical AI agent skill for writing, reviewing, and refactoring synthesizable SystemVerilog RTL with explicit hardware intent and predictable behavior across ASIC design flows.

    Built from real-world digital IC design practices, this skill helps coding agents produce RTL that is easier to understand, maintain, synthesize, and debug.

    What It Covers

    • Synthesizable RTL: Clear combinational and sequential logic using always_comb, always_ff, and explicit assignments.
    • FSMs and Priority Logic: Appropriate use of case, unique, and if / else if without unnecessary synthesis assumptions.
    • Arithmetic Correctness: Explicit bit widths, signedness, carry handling, and constants.
    • Hierarchy and Naming: Consistent port, signal, instance, and generate-block conventions.
    • Tool-Friendly Coding: Conservative practices for simulation, lint, synthesis, DFT, STA, and physical implementation.
    • Code Review and Refactoring: Identify ambiguous coding patterns and improve structural clarity while preserving intended functionality.

    Who Is It For?

    Digital IC designers, ASIC/FPGA engineers, RTL developers, and AI-assisted hardware design workflows.

    Compatibility

    Designed for AI coding agents supporting the SKILL.md format. Originally developed and tested with OpenAI Codex.

    Scope: Synthesizable design RTL only. Testbenches, UVM, and verification-only code are excluded.

    This skill provides coding guidance, not automated lint, simulation, or synthesis signoff.

    Open source: GitHub Repository

    MIT Licensed.

    Restricted to synthesizable design RTL. Excludes testbenches, UVM, verification-only tasks, and classes. Does not run actual lint or synthesis tools.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Permissions

    Read Files
    Write Files
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill enforces strict SystemVerilog standards, using constructs like `always_comb` and explicit width casting to eliminate inferred latches and X-optimism bugs common in generic AI-generated code.

    It is compatible with any LLM that supports SystemVerilog code generation, including GPT-4o, Claude 3.5 Sonnet, and specialized coding assistants.

    The skill focuses strictly on synthesizable RTL design; it does not support verification components like UVM classes, `initial` blocks, or clocking blocks.

    You receive the full configuration instructions and system-level constraints required to transform your AI agent into a specialized hardware design expert.

    Yes, the skill is designed to follow IEEE 1800 standards, making the output compatible with industry-standard tools like Design Compiler, Genus, Vivado, and Quartus.

    Simply apply the skill to your existing code or design prompt to receive a refactored version that adheres to professional `i_`/`o_` naming conventions and `logic` type-safety.

    New in Code Quality & Review