acceptodds
Under review as a conference paper at ICLR 2027

SchGen: PCB Schematic Generation with Semantic-Grounded Code Representations

Abstract

Printed circuit board (PCB) schematic design defines nearly all electronic hardware, but it remains mostly manual and expertise-intensive. While generative AI has advanced digital and analog IC design, PCB schematic generation from natural-language intent is largely unexplored. This paper presents SchGen, a large language model that generates editable PCB schematics from natural-language requests. The key challenge lies in the lack of an LLM-suited representation and a large-scale dataset. Current schematic formats are dominated by verbose, tool-specific syntax and geometry-heavy descriptions, making them difficult to generate reliably. We introduce a semantically grounded code representation that encodes schematic editing primitives with relative placement and pin-name-based wiring, transforming a geometry-driven generation problem into a semantics-driven matching task amenable to LLMs. We further construct a large-scale dataset of PCB schematics paired with user prompts via a human–agent collaborative pipeline that converts open-source hardware designs into our representation. Experiments show that SchGen significantly outperforms alternative representations and even larger general-purpose LLMs on wire connectivity accuracy and functional correctness. Our results highlight the critical role of representation design in enabling generative models for complex hardware design tasks.

Primary area:
generative models
Keywords:
PCB schematic, design generation, Large language models, Generative models

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_ua6oOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents SchGen, a framework for generating editable PCB schematics from natural-language requirements. Its main contribution is Code-L1, an executable representation combining anchor-relative component placement with pin-name-based electrical connections. The authors construct a dataset of 2,105 schematics from 1,390 unique designs through an LLM-assisted reconstruction and human-correction pipeline, and fine-tune two language-model backbones on synthesized request–program pairs. Experiments compare alternative representations, general-purpose LLMs, and performance on an independently collected GitHub dataset, reporting improvements in netlist accuracy and expert-assessed functional correctness.

Critical strengths
  • Practical representation design with meaningful empirical gains. Code-L1 abstracts electrical connectivity from low-level wire geometry while preserving relative component placement. The controlled ablations show substantial improvements over absolute-coordinate and explicit-wire representations on both fine-tuned backbones, supporting the value of the proposed abstraction.

  • Useful dataset construction and evaluation effort. The human–agent reconstruction pipeline addresses the scarcity of paired natural-language requests and editable PCB schematics. The evaluation covers execution validity, netlist accuracy, spatial quality, and expert-assessed functionality, providing a more informative assessment than syntactic validity alone.

  • Encouraging transfer across data sources. The additional evaluation on 988 schematics from GitHub projects shows that the fine-tuned models retain advantages on designs collected outside the original SparkFun source. The component-overlap analysis further helps characterize the distribution shift.

Critical weaknesses
  • Limited algorithmic novelty and generalizability. SchGen primarily relies on existing LLMs and standard supervised fine-tuning, with its contributions centered on task-specific engineering rather than novel learning algorithms or reasoning mechanisms. Despite promising empirical results, the paper provides limited exploration of broader applicability within the PCB design domain or transferable methodological insights.
  • Limited realism of the evaluation. The in-domain test requests are synthesized from existing schematics, potentially making the task closer to reconstructing known designs than generating circuits from real user requirements. Performance on independently written, underspecified engineering requests remains unclear.
  • Insufficient comparison with competitive design pipelines. The experiments mainly compare simplified representation variants or fine-tuned models against general-purpose LLMs. Stronger baselines using existing netlist-first generation and automated schematic construction under matched training conditions are missing, making it difficult to establish the advantage of the proposed approach.
Questions for authors
  • Beyond task-specific engineering and fine-tuning existing LLMs, what generalizable methodological insights does SchGen introduce?

  • How does SchGen perform on independently written engineering requests and larger, more complex PCB schematics?

  • Can the authors compare against a netlist-first or SKiDL-based generation pipeline under matched training and inference conditions?

  • How are electrical constraints beyond KiCad ERC checks validated? Can the authors provide more detailed evidence of expert agreement and failure analysis?

5 comments
AuthorsOpenReview ↗

[Response to Reviewer ua6o]

We sincerely thank the reviewer for recognizing the empirical representation gains, the dataset-construction effort, and transfer across data sources.

We agree that the following aspects need clearer explanation or more analysis. We will update our paper accordingly to address them.

W1 / Q1. Methodological insight beyond standard fine-tuning

SchGen’s methodological contribution, recognized by the other two reviewers, Vd1x and NWZR, is the code representation named Code-L1, an executable representation derived from how engineers design schematics. Engineers organize components around functional anchors and connect pins according to their roles in the circuit. Code-L1 encodes these decisions as anchor-relative placement and named-pin connections. The model specifies the intended circuit relationships, and the API constructs the wire geometry and writes the KiCad schematic. The representation benefits both prompting and supervised fine-tuning. With API specifications and examples supplied in the prompt, Code-L1 improves expert-assessed functional correctness over Code-L2 by 22.4–24.0 percentage points across GPT-5.5, GPT-5.2, and Grok-4 (Table 3). Under supervised fine-tuning, the ablation shows the contribution of each design choice. For Qwen3.8-27B, netlist Jaccard increases from 19.6% with explicit wire geometry to 50.9% with named-pin wiring, then to 70.7% with anchor-relative placement. GPT-OSS-20B shows the same ordering (Table 2).

Besides, SchGen also made contributions to the dataset and corresponding construction pipeline for the community. Frontier AI labs, Anthropic reports results on internal PCB benchmark, while OpenAI reports results on its internal design tasks. Restricted access to the underlying tasks and data limits what independent researchers can reproduce and build on from these evaluations. We have already released the model, dataset, and the whole pipeline but have not disclosed them here due to anonymity. Researchers can use this shared dataset to train new models, construct new datasets, and evaluate schematic generation.

Methodological Insights: Applying LLMs to hardware engineering has attracted wide interest, including Anthropic [https://www.anthropic.com/research/claude-electronics-design] and OpenAI [https://openai.com/index/accelerating-engineering-for-the-physical-world/]. However, it still raises a common representation problem`. Many hardware designs can be understood as spatial graphs whose components have both functional connections and geometric relationships. Our proposed SchGen uses PCB schematics to study how these designs can be represented in a form that LLMs can learn and generate more efficiently. The general method is to identify how engineers express design intent and encode those decisions as executable operations. In Code-L1, the model places components relative to functional anchors and connects pins by name, and the backend constructs the wires and writes the schematic. The same principle could guide representation design for other engineering artifacts, such as mechanical CAD, where a model could specify how named features mate, and for chip design, where it could connect block ports and specify relative placement constraints.

W2 / Q2. Independently authored requirements and larger designs

From independently written requirements to working hardware. To test this, we add two requirement-driven hardware design case studies involving three users.

Each case starts from a natural-language device specification. SchGen decomposes the request into functional blocks and calls the model with written requirements, then generates and merges the block-level schematics. The resulting boards were then tested separately for correctness. We also asked the 3 experts to perform a similar task for a complete PCB board and record the time consumed.

Device-level requirementVerification on fabricated hardwareSchGen-assisted design time (min)Mean manual design time (min)
Multi-sensor module integrating pressure, light, audio, inertial, magnetic, and environmental sensing, with I2C connectivity and a power indicatorGyroscope responses to controlled motion along all three axes1582
CO2-monitoring device integrating sensing, microcontroller processing, USB communication, and microSD storageResponse to human breath and continuous indoor CO2 recording over 12 hours24128

These cases demonstrate the practical role of automating repetitive design operations to reduce manual labor so that human effort can focus on requirements, inspection, correction, and functional verification.

AuthorsOpenReview ↗

[Response to Reviewer ua6o, cont']

W3 / Q3. Matched netlist-first or SKiDL pipeline

A related netlist representation is SKiDL, which directly compiles a netlist without spatial or editable schematic design. Although this is different from the problem we want to solve, we agree that this representation comparison is helpful.

A fine-tuned netlist-first baseline. We converted the original dataset to SKiDL programs and fine-tuned the same Qwen3.8-27B backbone using the original training/test split. This adds a learned netlist-first baseline, rather than comparing Code-L1 only with prompted general-purpose LLMs. The following results are from tests over the same test set of 500 samples.

Method (SFT setup; checkpoint)Pass Rate (%)Netlist Jaccard (%)Netlist precision (%)Netlist recall (%)
SchGen (Qwen3.8-27B)95.270.776.374.5
SKiDL (Qwen3.8-27B)97.258.9761.2561.26

Both methods achieve high execution/export pass rates (95.2% for SchGen and 97.2% for SKiDL), while SchGen's reported netlist Jaccard, precision, and recall are higher by 11.73, 15.05, and 13.24 percentage points, respectively, which highlights that even compared to netlist-based representation, SchGen can still maintain both readability and higher performance of netlist accuracy.

Q4. Electrical constraints, expert agreement, and failure analysis

Beyond KiCad’s Electrical Rules Check (ERC), we use expert review to assess whether generated schematics can meet the user’s design request. As described in Appendix §6.6 (p. 19), six experts evaluated the generated schematics using the user request, the reference schematic, and relevant component datasheets when needed. Electrically equivalent implementations that satisfy the request are accepted.

We use the following rubrics:

  • Symbol Error. Count missing, incorrect, or duplicated components. Electrically suitable substitutes are accepted when the request does not specify an exact part.
  • Connection Error. Count required functional pins that are left unconnected, connected to the wrong net, or involved in an unintended short. Electrically equivalent connections are accepted regardless of wire routing or net-label naming.
  • Functional Correctness. Judge whether the complete schematic can reasonably perform the requested functions. A positive judgment requires zero symbol and connection errors and a separate assessment of end-to-end functionality.

We report symbol and connection errors as mean counts per schematic across all experts, and functional correctness as the percentage of evaluated schematics that receive a positive judgment among all experts. We separately reconcile disagreement for a small amount of samples not reaching full agreement. Below is a table of the raw distribution of expert agreement, which shows the consistent agreement within experts.

Number of DisagreementsNumber of schematics
0 (No disagreement)478
111
28
33
Total500

Failure-case study. We inspected retained Code-L1 evaluation records for the two SchGen backbones in the main results. The examples below represent the main failure types across all samples.

Failure typeSchGen backbone and exampleObserved evidence
Incomplete programQwen3.8-27B, ZED-F9P GPSGenerated code ends inside an add_schematic_symbol call; a SyntaxError prevents netlist export.
Invalid pin referenceQwen3.8-27B, indoor air-quality sensorThe code requests LX on the AP3012 symbol, whose library pin is named SW; pin lookup fails before export.
Ambiguous pin selectionQwen3.8-27B, mosaic-T UART protectionAll four UART signals use the same D1.K selector; pins 1, 3, and 4 remain unconnected. Only 2/5 reference nets match: precision 100%, recall 40%.
Connectivity mismatch after exportGPT-OSS-20B, XBee development boardThe saved evaluation reports successful execution/export, but the single evaluated net matches neither of the two reference nets: precision and recall 0%.
AuthorsOpenReview ↗

[Kind Reminder of Feedback to Comments]

Dear Reviewer,

Thank you again for your thoughtful review.

As the author–reviewer discussion period is drawing to a close and the deadline is only a few days away, we would greatly appreciate any final feedback regarding whether our rebuttal has adequately addressed your concerns.

If there are still any remaining issues or questions, we would be more than happy to clarify them before the discussion period ends.

Thanks a lot for your time and hard work.

Reviewer_NWZROpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

SchGen fine-tunes GPT-oss-20B and Qwen3.8-27B to generate editable KiCad PCB schematics from natural-language requests. Instead of raw KiCad files, it outputs Python code built on a small set of editing calls (add symbols, add label, connect pins), using placement relative to anchor components and wiring by pin name. The training set comes from about 1390 SparkFun designs, converted through an LLM-sketch and human-correction pipeline. The model reaches 96% pass rates and 82.6% expert-verified functional correctness, beats GPT-5.5 and Grok-4 on the in-distribution test set, and out-of-distribution GitHub set.

Critical strengths
  • Text-to-PCB-schematic is an area that has not yet been rigorously explored, and the work presents clear comparative evaluation and ablation study on a relatively large dataset.
  • Turning schematic images into editable KiCad files (agentic sketch with execution feedback, then human alignment), and a deterministic schematic-to-code converter sound practical to solve data scarcity.
  • The evaluation metrics cover executability and ERC checks, spatial overlap, netlist Jaccard, precision, recall, and expert-judged functional correctness.
Critical weaknesses
  • The paper reports 82.6% functional correctness, but there is no comparison of effort or error rate between human engineers working from scratch and engineers refining SchGen outputs, and no characterization of repair effort for the incorrect designs. Without this, it is unclear whether SchGen reduces designer effort or not. For evalution, there is no comparison with Claude or Gemini, so it is unclear whenther SchGen performs better w.r.t. other frontier AI tools.
  • Figure 5 suggests that the majority of the designs are simpler PCB boards with fewer than 20 components, so the dataset remains on the low complexity side as compared to practical engineering design requirements.
  • All training data, evaluation, and the symbol vocabulary are tied to KiCad and its standard libraries. The model learns KiCad-specific symbol and pin names, so it is unclear whether SchGen can be used for industry-standard tools like Cadence, Altium without retraining.
Questions for authors
  1. Can you report a small user study (time to correct design with vs. without SchGen)? Also describe how the method can be applied to alternative PCB design tools such as Cadence or Altium.
  2. For dataset generation, could the human alignment step be reduced with fine-tuning the agentic sketch? What error rate does the agentic sketch have before human correction? How much human effort is needed for the correction?
  3. Can SchGen work with a different symbol library of different tool at inference time, or does a new library require retraining?
  4. Can Code-L1 be compared with netlist representation for pass rate and expert verification? My understanding is that spatial violation is used to evaluate how well the schematic can be visualized, but one can imagine an automated agentic design flow that does not need any graphical user interface at all.
  5. Will the large-scale dataset of PCB schematics paired with user prompts be open-sourced?
5 comments
AuthorsOpenReview ↗

[Response to Reviewer NWZR]

We sincerely thank the reviewer for recognizing the value of the problem and our dataset, and the practical data-construction pipeline.

We agree that the following aspects need clearer explanation or more analysis. We will update our paper accordingly to address them.

W1 / Q1. Human effort and correction cost

The practical benefit of SchGen's programmable representation is to automate PCB schematic design while retaining an editable schematic for inspection and correction. We set up two hardware design case studies with 3 users to illustrate how code-based schematic generation supports a faster design workflow.

Case-study setup. Each case starts from a natural-language device specification. The user decomposes the request into functional blocks and calls SchGen, then generates and merges the block-level schematics. The resulting boards were then tested separately for correctness. We also asked the 3 experts to perform a similar task for a complete PCB board and estimate the time consumed.

ProjectRequested functionalityVerification on fabricated hardwareTime spent by SchGenTime spent by human designer on average
Multi-sensor modulePressure, light, audio, inertial, magnetic, and environmental sensing, with an I2C interface and a power-indicator LED.Gyroscope responses to controlled motion along all three axes.15 minutes82 minutes
CO2 monitoring deviceCO2 sensing, microcontroller processing, USB communication, and microSD storage.Sensor response to human breath and continuous indoor CO2 recording over 12 hours.24 minutes128 minutes

These cases demonstrate the practical role of automating repetitive design operations so that human effort can focus on requirements, inspection, correction, and functional verification.

W3 / Q1 / Q3. Other symbol libraries and EDA tools

We chose KiCad because it is one of the industry-standard tools and has a free license, an open-source implementation, accessible libraries, and a file format. Cadence and Altium are proprietary software that require licenses and have more restrictions.

However, SchGen is a general method for PCB schematic generation with a specially designed code representation, rather than a method intrinsically tied to KiCad. Its core operations express tool-independent design decisions: placing components relative to functional anchors and connecting named pins. The execution backend translates these operations into the target tool's native schematic. The same representation can be transferred to Cadence or Altium by implementing a backend through the target tool's supported scripting interfaces or SDKs. It does not require redesigning SchGen's representation.

The symbol library is likewise supplied as information rather than hard-coded into the representation. At inference time, the model receives the available library information, including symbol identifiers and pin definitions, as context for selecting components and making connections. This context can be replaced with metadata from another library, while the backend resolves the supplied identifiers and pin mappings. With compatible library metadata and a backend that implements the same operations, a new library can be used through an inference-context change without retraining the model. The portability mechanism retains the representation and model while adapting the library context and execution backend.

W1. Claude and Gemini comparisons

We run additional experiments with Claude and Gemini. Note that SchGen has a much smaller parameter size (27B with Qwen 27B and 20B with GPT-oss), so it is not fair to directly compare it with advanced models. Nevertheless, according to the following table. SchGen still slightly outperforms Claude-Opus-5.5, Claude-Haiku-5.5, and Gemini-3.8-flash.

Netlist accuracy (Jaccard, %; higher is better).

ModelCode-L1Code-L2Code-L3Raw KiCad
Claude Sonnet 567.9568.3252.0335.19
Claude Haiku 4.567.0462.7126.699.06
Gemini 3.8 Flash63.2266.4363.5058.71
SchGen (Qwen3.8-27B)70.7 ± 0.5850.9 ± 0.8819.6 ± 0.4211.5 ± 0.41

W2. Larger and more complex schematics

We acknowledge that our dataset primarily focuses on the functional block level of PCB schematics, which has a relatively lower complexity. However, in the actual design process, large PCB schematics are always partitioned into different functional blocks that are connected with labels. Thus, SchGen can be used to generate a larger PCB schematic by first generating multiple functional blocks separately and merging them into a complete PCB schematic with high complexity. Another approach is to train SchGen directly with complex, larger-scale schematic designs. We leave this to future work.

AuthorsOpenReview ↗

[Response to Reviewer NWZR, cont']

Q2. Sketch errors, manual alignment effort, and adapting the sketcher

We acknowledge that the agentic sketch can be improved with more advanced or fine-tuned base models to produce sketches of PCB schematics with higher fidelity. Currently, the error rate is roughly 50% and most errors are minor issues due to wrong connection in some areas. Roughly, on average, fewer than 5 connections in a schematic need adjustment. Human engineers need to focus on the corrections over minor connection errors and verification, which only takes around 10% of the original design time.

Q4. Netlist representation and headless workflows

A related netlist representation is SkiDL, which directly compiles a netlist without spatial or editable schematic design. Although this is different from the problem we want to solve, we agree that this representation comparison is valuable for certain cases that do not need any graphical user interface at all. We convert the original dataset to the SkiDL representation, which uses netlist as the representation, and then use the same training set and test set to do the fine-tuning and verification. Below is the table showing the comparison of all metrics over the test set between SkiDL netlist representation and the proposed SchGen. The results show that even with direct netlist representation, the final netlist accuracy still falls behind our method.

Method (training; checkpoint)Pass Rate (%)Netlist Jaccard (%)Netlist precision (%)Netlist recall (%)
SchGen (Qwen3.8-27B)95.270.776.374.5
SKiDL (Qwen3.8-27B)97.258.9761.2561.26

Note that the netlist representation is not designed for humans to read, so temporarily we have difficulty with expert verification. We aim to include it in the final version of the paper.

Q5. Dataset release

Yes. We have released the complete dataset and data pipeline as public repos. To remain anonymous, we do not include the links here.

AuthorsOpenReview ↗

[Kind Reminder of Feedback to Comments]

Dear Reviewer,

Thank you again for your thoughtful review.

As the author–reviewer discussion period is drawing to a close and the deadline is only a few days away, we would greatly appreciate any final feedback regarding whether our rebuttal has adequately addressed your concerns.

If there are still any remaining issues or questions, we would be more than happy to clarify them before the discussion period ends.

Thanks a lot for your time and hard work.

Reviewer_Vd1xOpenReview ↗
Rating
1(−1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

This paper presents SchGen, an LLM-based generative model for editable PCB schematics from natural-language requests. The main contribution is Code-L1, a code representation that uses relative coordinates for component placement and pin names for electrical connections. The authors also build a dataset of 2,105 schematics from 1,390 designs.

Critical strengths
  1. The idea and dataset are novel and promising for accelerating the design of hardware from natural language user requests to schematics.
  2. The constructed dataset is a good contribution to this domain.
  3. The proposed Code-L1 representation significantly improves performance, as shown by the experimental results.
Critical weaknesses
  1. From the example, I found that the user request is highly related to hardware design specifics. It is a little bit far from the real user request. This means users still need to understand the electronic components. In section 3.2.2, the authors mentioned two kinds of requests: one is high-level about functionality, the other one is a detailed request. But the evaluation side did not distinguish between them.

  2. For Table 1, I can not find useful information about the specific number of loss. If it just shows Code-1 is better than the other two, I don't think this metric is informative. Maybe more information and clarification should be provided for this.

  3. Code-L1 and Code-L3 use APIs with different error checks. This may affect the fairness of their pass-rate comparison.

Questions for authors
  1. Will the dataset be released or not?
6 comments
AuthorsOpenReview ↗

[Response to Reviewer Vd1x]

We sincerely thank the reviewer for recognizing that the idea and dataset are novel and promising, making a good contribution to this domain. We agree that the following aspects need clearer explanation or more analysis. We will update our paper accordingly to address them.

W1. Hardware-specific requests and the two request styles

We have two types of user requests to cover users with different levels of background knowledge on hardware designs. The two request styles address different inputs: concise requests specify intended functionality, whereas detailed requests additionally constrain components or connections. We will include more examples in the paper. For more high-level, vague requests, we expect the model to be able to handle them as well, but these requests would make it hard to verify the output correctness, because the requests can be under-specified or have several possible ways of interpretation.

To better align with real user requests, we asked both PCB design experts and non-experts to write their intended requests. When generating requests in our datasets, we use them as references for LLMs and mimic the two different kinds of users. We compare the model performance on netlist precision over the two different styles as follows:

Netlist precision comparison for two types of user requests.

ModelRepresentationConcise (%)Detailed (%)
SchGen (Qwen3.8-27B)L171.2580.51
SchGen (Qwen3.8-27B)L248.4267.92
SchGen (Qwen3.8-27B)L334.6133.96
SchGen (GPT-OSS-20B)L145.4963.96
GPT-5.5L133.1964.28
GPT-5.5L224.6062.97
GPT-5.5L317.6562.05

From the table, we can see that SchGen with L1 representation performs well and outperforms other baselines on both types, which highlights the efficiency of the proposed method.

W2. Table 1 loss metric clarification

The loss metric in the table below shows the validation loss of token prediction on the test dataset with each representation, after training on the training set. We use lower val loss to compare token-level learning under a matched training setup, and use it as a proxy indicator for better performance and generalization ability. We found validation loss is consistently correlated with netlist performance across checkpoints. At each checkpoint, we compute Pearson and Spearman correlations across evaluation samples, using the netlist Jaccard score as the performance metric. All correlations are statistically significant (adjusted two-sided p < 0.001).

CheckpointPearson rSpearman rho
1+0.295+0.349
2+0.234+0.320
3+0.203+0.271

W3. Different API error checks

We consider the main comparison for Code L1 and L3 fair because API error checks are part of the end-to-end design. Both are evaluated on the same test requests, with one generation attempt per request and the same requirement of zero KiCAD ERC errors. In terms of extra API checks, Code-L3 has a lower risk of coding error because its API is more basic and has no restrictions. Code-L1 has named pin checks before constructing a connection, while Code-L3 can place wire segments directly with any coordinates.

In Table 2, Code-L3 shows a similar pass rate to Code-L1, but Code-L1 achieves higher netlist accuracy, with 70.7% versus 19.6%. So Code-L1 has more difficult checks but still outperforms Code-L3, which further highlights Code-L1's advantage.

Q1. Dataset availability

Yes. We have released the complete dataset and data pipeline as public repos. To remain anonymous, we do not include the links here.

AuthorsOpenReview ↗

[Kind Reminder of Feedback to Comments]

Dear Reviewer,

Thank you again for your thoughtful review.

As the author–reviewer discussion period is drawing to a close and the deadline is only a few days away, we would greatly appreciate any final feedback regarding whether our rebuttal has adequately addressed your concerns.

If there are still any remaining issues or questions, we would be more than happy to clarify them before the discussion period ends.

Thanks a lot for your time and hard work.

I recently came across a closely related paper:

“IoTGen: Towards LLM-Driven IoT Hardware PCB Generation” (MobiSys 2026)
https://dl.acm.org/doi/pdf/10.1145/3745756.3809239

The two papers appear to share substantial similarities in their core schematic generation approach, including the semantic code representation and even specific code examples.

Could the authors please clarify how the proposed approach differs from IoTGen, particularly in terms of its technical novelty and contributions? I believe a more explicit comparison with this prior work is unavoidable

Comments on the paper

1 comment
AuthorsOpenReview ↗

[Final Response of Rebuttal Summary]

Dear Area Chair and all reviewers,

We thank you and the reviewers for the careful evaluation of our paper. The comments from the reviewers are quite constructive, which helped us improve the work and make clarifications. We would like to summarize the reviewers' concerns and our corresponding response below to show the possible concerns in the current version of the paper and how we address them.

  • Request realism, design scale, and effort (Vd1x, NWZR, ua6o). Reviewers asked how realistic the test requests are, how well SchGen handles larger boards, and whether it reduces design and repair effort. We have addressed the concerns from two additional verifications: (1) Examples from PCB experts and non-experts informed the two request styles of concise and detailed requests, and SchGen led on on both of them, with 71.25% and 80.51% netlist precision, respectively. (2) Aiming to test SchGen's function over larger boards, we design two case studies involving three users, which started with independently written requirements, combined generated functional blocks into board-level schematics, and verified key functions on fabricated boards. SchGen-assisted design took 15 and 24 minutes, compared with reported manual averages of 82 and 128 minutes from human engineers.
  • Evaluation protocol and baselines (Vd1x, NWZR, ua6o). Reviewers questioned the interpretation of Table 1’s loss, the fairness of comparing pass rates under different API checks, and the lack of Claude, Gemini, and matched netlist-first baselines. (1) We clarified Table 1’s token-prediction loss and analyzed its association with netlist accuracy across three checkpoints to show that the validation loss is statistically highly correlated with the final task performance. (2) We further clarify the different API used by Code-L1 and Code-L3 to illustrate that Code-L3 can have a specific advantage in pass rate but fails on netlist accuracy. (3) We also added Claude and Gemini baselines to show SchGen still outperforms them on netlist Jaccard. (4) To compare our proposed method with netlist representation, we also fine-tuned a SKiDL baseline with the same Qwen backbone and data split. SKiDL had a slightly higher export pass rate, and SchGen led by 11.7 percentage points in netlist Jaccard.
  • Electrical verification beyond ERC (ua6o). The reviewer asked how electrical correctness was validated beyond ERC and requested evidence on expert agreement and failure modes. We detailed how six experts assess components, connections, and overall functionality, accepting electrically equivalent designs. The manuscript reports that the experts’ aggregate correctness rates differed by less than three percentage points. We also provided examples of execution and connectivity failures.
  • Data construction, release, and portability (Vd1x, NWZR). Reviewers asked about sketch errors and manual correction effort, public access to the dataset, and compatibility with other symbol libraries and EDA tools. (1) We reported sketch errors and human alignment estimates, including fewer than five connection adjustments per schematic on average. (2) We also clarified that symbol metadata is supplied at inference, which is not constrained to the fine-tuned model. Besides, the tool-specific backends of SchGen can be replaced by any PCB schematic design tools, including Cadence or Altium. (3) As confirmed in the discussion, we have released the model, dataset, and data-construction pipeline already, though they are not disclosed because of anonymity.

Thank you for considering these results and clarifications. We sincerely hope you could review our revised paper and all the discussion threads before the final decision.

Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.