Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    digital ic frontend design

    1

    Digital IC front-end design copilot for RTL, CDC, SDC constraints, and signoff checklists.

    $19

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    digital ic frontend design

    digital ic frontend design

    Example session with this skill installed

    The design has a 200MHz clk_a and a 125MHz clk_b. I need to pass a 32-bit data bus from a to b. Generate the RTL and the SDC constraints for this crossing.

    • Read your context and instructions
    • Compiled the digital ic frontend

    I will implement a dual-clock asynchronous FIFO for this 32-bit bus crossing. This ensures data integrity between the 200MHz and 125MHz domains.

    Asynchronous FIFO Implementation

    // File: rtl/data_sync_fifo.sv
    // Crossing: clk_a (200MHz) -> clk_b (125MHz)
    // Data Width: 32 bits
    
    module data_sync_fifo #(
        parameter DATA_W = 32,
        parameter ADDR_W = 4  // 16 entries
    )(
        // Write Domain (clk_a)
        input  logic              clk_a,
        input  logic              rst_a_n,
        input  logic              w_en,
        input  logic [DATA_W-1:0] w_data,
        output logic              w_full,
    
        // Read Domain (clk_b)
        input  logic              clk_b,
        input  logic              rst_b_n,
        input  logic              r_en,
        output logic [DATA_W-1:0] r_data,
        output logic              r_empty
    );
    
        // Using assets/templates/async_fifo.sv structure
        // Gray-coded pointer synchronization logic omitted for brevity in this preview
        // Full/Empty generation based on synchronized Gray pointers
    
    endmodule
    

    SDC Constraints

    
    # Clock Definitions
    create_clock -name clk_a -period 5.0 [get_ports clk_a]
    create_clock -name clk_b -period 8.0 [get_ports clk_b]
    
    # Clock Groups - Asynchronous Domains
    set_clock_groups -asynchronous -group [get_clocks clk_a] -group [get_clocks clk_b]
    
    # CDC Path Exceptions (Max Delay for Gray Pointers)
    # Assuming 4-bit pointers
    set_max_delay 5.0 -from [get_cells -hier *wptr_gray_reg*] -to [get_cells -hier *wptr_sync_reg*]
    set_max_delay 8.0 -from [get_cells -hier *rptr_gray_reg*] -to [get_cells -hier *rptr_sync_reg*]
    

    Next steps

    1. Run python3 scripts/rtl_lint.py rtl/data_sync_fifo.sv to verify the pointer synchronization logic.
    2. Confirm if rst_a_n and rst_b_n are globally synchronized resets or require local reset synchronizers.
    3. Verify the FIFO depth (currently 16) is sufficient for the burst length of your 200MHz source.

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

    About this skill

    Digital design teams struggle with manual RTL reviews, hidden clock domain crossing (CDC) bugs, and late-stage timing failures. This skill automates the front-end signoff path from microarchitecture to RTL freeze for ASIC, SoC, and FPGA workflows.

    What it does

    • Microarchitecture design generates block partitioning, throughput math, and interface contracts.
    • Synthesizable RTL generation produces SystemVerilog code following strict linting and reset standards.
    • Timing and constraints authors SDC files, triages STA reports, and identifies WNS/TNS root causes.
    • Clock domain crossing audits structural synchronizers, async FIFOs, and reset domain crossings.
    • Power and DFT defines UPF low-power intent and scan-readiness hooks for backend handoff.

    How it works

    1. Intake and context gathers target technology, clock frequencies, reset schemes, and toolsets.
    2. Implementation loads design patterns and templates to build synthesizable, parameterised modules.
    3. Verification runs structural lint and CDC audits using specialized internal scripts.
    4. Signoff generates a freeze package including RTL manifests, risk registers, and constraint summaries.

    Frameworks & tools

    Supports standard EDA flows including VCS, Xcelium, Questa, Design Compiler, Genus, PrimeTime, Tempus, SpyGlass, and Verilator.

    Why this beats prompting it yourself

    Generic AI lacks the domain-specific rigor required for IC design, often suggesting non-synthesizable code or ignoring critical CDC synchronizers. This skill enforces hardware-specific rules, such as one clock per block and registered module outputs, while strictly separating architectural changes from implementation details.

    Use cases

    • Designing a high-performance async FIFO between mismatched clock domains.
    • Triaging critical timing violations in a PrimeTime report to identify logic depth issues.
    • Generating a synthesizable FSM template with unreachable state handling.
    • Authoring SDC constraints for a complex SoC top-level interface.

    Known limitations

    Does not perform physical design, place and route, DRC/LVS, or analog/mixed-signal modeling. Requires external report files to validate timing and CDC cleanliness.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for APIs & Backend.

    No physical design (P&R/DRC/LVS). No analog modeling. Requires user-provided timing/lint reports to confirm signoff readiness. Synthesisable logic only.

    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 buying a skill.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 22 days ago

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed22 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the critical path from microarchitecture to RTL freeze, specifically addressing manual review bottlenecks, hidden CDC bugs, and late-stage timing failures that generic AI models often miss.

    The skill is designed to work with any LLM-based agent that supports file uploads and text-based reasoning, integrating seamlessly into existing CI/CD or EDA environments via standard RTL and constraint formats.

    You receive the specialized skill configuration, a set of synthesizable SystemVerilog templates, and a suite of internal scripts for structural linting and CDC audit automation.

    No complex installation is required; simply load the skill into your preferred AI agent and provide your target technology, clock frequencies, and reset schemes to begin generating signoff-ready code.

    The skill focuses strictly on the front-end flow (RTL, CDC, SDC); it does not perform physical layout, GDSII generation, or analog modeling, and requires external EDA reports to validate final timing results.

    New in APIs & Backend