RTL Skills — Automação de Design de Hardware com Claude
phamcuong21478/rtl-skills
Automatiza arquitetura, RTL, testes e síntese de IP de hardware via Claude
Ver no GitHubConjunto de skills e agents Claude que automatizam todo o fluxo de design RTL/Verilog, desde especificação em uma página até síntese, testes e documentação. Inclui arquitetura, codificação, linting, simulação, testbenches auto-verificáveis, regressão, debug e síntese Vivado.
Instalação
npx convez-ai phamcuong21478/rtl-skills1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Gerar arquitetura e decomposição modular de especificações RTL
- Implementar e testar módulos Verilog com simulação e linting automáticos
- Sintetizar e otimizar design com Vivado, capturando utilização e Fmax
- Gerar documentação técnica completa e testbenches auto-verificáveis
- Orquestrar fluxo full-stack de design: req → RTL → sim → synth → doc
Veredito

Projeto robusto e bem-estruturado para engenheiros de hardware que buscam acelerar design RTL com Claude. Cobertura abrangente (arquitetura, codificação, síntese, debug) e agentes especializados tornam viável automação real de fluxo de design; requer fluência em Verilog/SystemVerilog e bom entendimento do próprio fluxo para máxima efetividade.
README
A tradução para o português deste README ainda está na fila.
rtl-skills
A collection of Claude Code skills and agents that automate a full RTL/Verilog design flow — from a one-page IP requirement all the way to synthesized, tested, and documented hardware.
Drop these into a Verilog project and Claude can architect an IP, write the RTL, lint and simulate it, build a self-checking testbench, run regressions, debug failures, synthesize with Vivado, and produce documentation — each step driven by a focused, reviewable skill.
What's in here
| Path | Contents |
|---|---|
skills/ | One folder per skill, each a SKILL.md defining the workflow, inputs, and outputs |
agents/ | Agent definitions (*.yaml) that bundle skills into roles with a model and turn budget |
skills/shared/ | Cross-skill contracts: coding style, module-doc format, hierarchy filelist rules |
CLAUDE.md | Project instructions describing the directory layout and conventions a consuming project should follow |
The design flow
ip_req.md
│
├─[varch]────► ddoc/<submodule>_req.md (one per submodule) + rtl/<ip>_top.v skeleton
├─[vdesign]──► rtl/<module>.v backbone + ddoc/<module>_proposal.md + doc/<module>.md
├─[vfill]────► rtl/<module>.v full implementation + tb/<module>/ (lint + sim)
├─[vflow]────► flow_status.md (live phase-completion snapshot, orchestration)
├─[vsynth]───► synth/<module>/ (Vivado: utilization, Fmax, power)
├─[vtestgen]─► tb/<ip>/ (CPU-bus bench project + self-checking testcases)
├─[vtestrun]─► issue/<ip>/ (regression results + per-failure reports)
├─[vdebug]───► issue/<ip>/debug_*.md (root-cause diagnosis, no fix proposed)
└─[vdoc]─────► doc/<ip>.md (full IP integration document)
Skills
| Skill | Purpose |
|---|---|
varch | Decompose an IP requirement into submodules, define interfaces, generate an architecture doc, per-module requirement files, and a top-level skeleton |
vdesign | Generate a design proposal, module documentation, and an RTL backbone with //@ direction markers from a requirement file |
vfill | Implement the Verilog from an approved proposal, then lint and simulate |
vexplain | Generate documentation for any RTL module from its Verilog source |
vdoc | Aggregate per-module documentation into a single IP-level document |
vsynth | Synthesize a module or full IP with Vivado; report utilization, Fmax, and power |
vtestgen | Scaffold a Makefile-driven, CPU-bus-controlled bench project and generate self-checking testcases |
vtestrun | Run all testcases from tc_list.md, capture results, write per-failure issue reports |
vdebug | Trace failing signals through the RTL hierarchy, classify root cause, write a debug report |
vflow | Scan project state, write flow_status.md, and orchestrate the full flow end-to-end |
Agents
Agents bundle one or more skills into a role with a fixed model and turn budget.
| Agent | Model | Skills | Purpose |
|---|---|---|---|
rtl-architect | Opus | varch, vexplain | Decompose an IP requirement into submodules |
rtl-designer | Opus | vdesign | Generate proposal, docs, and RTL backbone |
rtl-coder | Opus | vfill | Implement code, lint, and simulate |
rtl-documentation | Opus | vdoc, vexplain | Build complete IP documentation |
rtl-synthesizer | Sonnet | vsynth | Synthesize a module or IP and produce a report |
rtl-tester | Opus | vtestgen, vtestrun | Generate IP testcases, run them, report failures |
rtl-debugger | Opus | vdebug, vexplain | Trace RTL signal paths to root cause |
rtl-orchestrator | Opus | vflow + all skills | Drive the complete flow with checkpoints and a debug loop |
Conventions
//@markers in RTL are design-direction comments forvfill; their grammar and lifecycle live inskills/shared/CodingStyle.md.- Synthesizable RTL (
rtl/,lib/) must be Verilog-2005 (IEEE 1364-2005). Testbenches undertb/may use SystemVerilog (.sv). - Reset is always synchronous, active-low by default; use the
RS_LVparameter when configurable. - Module docs follow
skills/shared/ModuleDocContract.mdso they're usable without reading the RTL. - Testcase verdicts end with
[FINISH] PASS/[FINISH] FAIL; pass/fail is decided from that token only. - Each skill lists its required external tools (Verilator, xvlog/xelab/xsim, Vivado) in a Prerequisites table. If a tool is missing, the skill stops and reports it rather than fabricating results.
Prerequisites
- Claude Code
- A simulator: Verilator and/or Xilinx xvlog/xelab/xsim
- Vivado (for
vsynth)
Skills degrade gracefully: if a required tool isn't installed, the affected phase is marked blocked and the flow continues.
Getting started
- Make these skills and agents available to Claude Code (e.g. copy
skills/andagents/into your project's.claude/directory, or reference this repo from your setup). - Copy
CLAUDE.mdinto your RTL project so the directory layout and conventions are picked up. - Write a top-level IP requirement (
ip_req.md) and runvarchto begin — or hand the whole thing tovflow/ thertl-orchestratoragent to drive end-to-end.
Quick walkthrough
Skills are invoked inside Claude Code (type /<skill> or just ask Claude to run it). A typical IP goes:
-
Write the requirement. Drop a plain-English spec for the IP in
ddoc/<ip>_req.md— interfaces, registers, behavior. This is the only file you author by hand. -
Architect —
/varch ddoc/<ip>_req.mdSplits the IP into submodules and producesddoc/<ip>_arch.md(the structural source of truth), addoc/<submodule>_req.mdper block, and thertl/<ip>_top.vskeleton. Edit the arch doc and re-run to reshape the design. -
Design each submodule —
/vdesign ddoc/<module>_req.mdGenerates a proposal (ddoc/<module>_proposal.md), module docs, and an RTL backbone with//@direction markers. Review the proposal before continuing. -
Implement —
/vfill rtl/<module>.vFills in the Verilog from the approved proposal, then lints and unit-simulates it undertb/<module>/. -
Test the IP —
/vtestgenthen/vtestrunvtestgenscaffolds a CPU-bus-driven bench intb/<ip>/with self-checking testcases;vtestrunruns them all and writes pass/fail plus per-failure reports toissue/<ip>/. -
Debug failures —
/vdebug issue/<ip>/issue_NNN_<name>.mdTraces the failing signal to a root cause and writes a debug report (it diagnoses; it doesn't auto-fix). Loop back tovfillto apply the fix, then re-runvtestrun. -
Synthesize —
/vsynth <module>Runs Vivado and reports utilization, Fmax, and power undersynth/<module>/. -
Document —
/vdocAggregates every per-module doc into a singledoc/<ip>.md.
Let an agent drive it
Instead of running each step yourself, point the orchestrator at the IP and let it manage the dependencies and the debug→fix→retest loop:
Use the rtl-orchestrator agent to take ddoc/<ip>_req.md through the full flow.
It runs vflow to scan project state, writes flow_status.md, and calls each skill in order, pausing at the review checkpoints. You can also run /vflow on its own at any time to see what's done and what's next.
Tip: skills are resumable and mostly idempotent — re-running a step picks up from the current state rather than starting over, so it's safe to iterate.
License
Licensed under the Apache License 2.0.