GenAI for Systems: Recurring Challenges and Design Principles from Software to Silicon

1. Problem Statement

The application of Generative AI (GenAI) to computing systems is rapidly expanding, with publications growing over 20-fold between 2017 and 2025. However, research remains highly fragmented across three distinct layers of the computing stack:

1. Software: Code generation, performance optimization, and distributed systems.
2. Hardware Architecture: Design space exploration (DSE), performance prediction, and accelerator mapping.
3. Chip Design: RTL synthesis, physical layout, and verification.

Core Issues:

• Siloed Progress: Communities (software, architecture, chip design) rarely share methodologies, leading to the rediscovery of the same solutions in isolation.
• Structural Bottlenecks: Despite domain diversity, the field faces identical structural difficulties when integrating GenAI into real design loops, such as slow feedback cycles, the inability to capture tacit human knowledge, and verification gaps.
• Lack of Standardization: There are no unified benchmarks, vocabularies, or engineering practices to evaluate progress across layers or to ensure reliability in production.

2. Methodology

The authors conducted a cross-stack survey and synthesis of over 275 papers spanning 11 application areas across the three computing layers.

• Scope: The analysis covers software engineering, GPU kernels, distributed systems, hardware architecture, RTL design, physical layout, and verification.
• Analytical Framework: Instead of cataloging every algorithm, the authors analyzed four recurring dimensions for each layer:
  1. Datasets and benchmarks used.
  2. Algorithms and methods proposed.
  3. Real-world deployment status.
  4. Underexplored opportunities.
• Synthesis Approach: The authors identified patterns of convergence, distilling recurring structural challenges and effective design principles that appear independently across different layers.

3. Key Contributions

The paper's primary contribution is the identification of five recurring challenges and five design principles that form a unified framework for GenAI in systems.

A. The Five Recurring Challenges (C1–C5)

1. C1: The Feedback Loop Crisis: Generators are fast, but evaluators (simulators, compilers, physical measurements) are slow, expensive, or noisy. This creates a bottleneck where learning cannot iterate quickly enough.
2. C2: The Tacit Knowledge Problem: Critical system knowledge (heuristics, build conventions, unwritten design rules) is implicit in human experts and tool defaults, making it difficult to encode into training data or models.
3. C3: Trust and Validation: As GenAI moves toward correctness-critical decisions (e.g., chip layout, kernel generation), the gap between "compilable" and "correct" widens. Independent verification infrastructure is often missing.
4. C4: Co-Design Across Boundaries: Performance often depends on decisions spanning multiple abstraction layers (e.g., model architecture vs. system scheduling). Optimizing layers in isolation fails to capture these cross-layer dependencies.
5. C5: From Determinism to Dynamism: Systems are shifting from static heuristics to adaptive, policy-driven behaviors. This introduces challenges in maintaining predictability, debugging, and accountability in dynamic environments.

B. The Five Design Principles (P1–P5)

1. P1: Embrace Hybrid Approaches: Combine learning with classical structure (e.g., symbolic checks, analytical bounds) rather than replacing it entirely. This ensures robustness against hard constraints.
2. P2: Design for Continuous Feedback: Make the feedback loop a first-class design object. Systems must iterate cheaply and structurally (e.g., tool-in-the-loop repair) rather than relying on one-shot generation.
3. P3: Separate Concerns by Role, Not by Tool: Decouple the generator from the verifier/judge. This mirrors human workflows (e.g., multi-agent systems) and localizes errors.
4. P4: Match Approach to Problem Structure: Select methods based on the problem's observability and structure. Use search-based methods for structured spaces and policy learning for unstructured or high-dimensional spaces.
5. P5: Build on Decades of Systems Knowledge: Treat GenAI as an extension of existing systems practices (e.g., using established benchmarks, invariants, and protocols) rather than a replacement.

C. The Challenge–Principle Map

The authors present a diagnostic map (Figure 3) linking challenges to principles. It reveals a maturation trajectory:

• Systems often start by solving the Feedback Loop Crisis (C1) using Continuous Feedback (P2).
• As iteration speeds up, the bottleneck shifts to Trust and Validation (C3), requiring Role Separation (P3) and Hybrid Approaches (P1).
• Finally, systems face Co-Design (C4) challenges, necessitating methods that match Problem Structure (P4).

4. Results and Findings

• Convergence: The same five challenges and principles appear consistently across software, architecture, and chip design, despite different tools and domains.
• Maturity Gaps:
  • Methods: Algorithmic approaches (e.g., RL for placement, LLMs for code) are relatively mature.
  • Benchmarks & Infrastructure: Standardized benchmarks that measure process (iteration cost, validation coverage) rather than just output quality are lacking.
  • Cross-Domain Transfer: Techniques developed in one layer (e.g., EDA tool-in-the-loop) are rarely applied to others (e.g., software engineering), leading to redundant effort.
• Deployment Reality: Successful deployments (e.g., Google's TPU floorplanning, vLLM serving) almost universally rely on hybrid systems where GenAI proposes solutions and classical tools verify them. Fully autonomous, end-to-end GenAI systems are rare due to verification and safety concerns.
• Data Scarcity: Chip design and RTL synthesis suffer from severe data scarcity compared to software, limiting the effectiveness of large pretrained models without retrieval-augmented generation or synthetic data.

5. Significance and Future Directions

• Unified Engineering Methodology: The paper argues for a shift from "ad hoc construction" to "systematic engineering." It proposes a shared vocabulary and cross-layer benchmarks to allow progress to compound across communities.
• Open Research Questions:
  1. Cross-Stack Evaluation: How to build benchmarks that measure the end-to-end loop (generation + validation) rather than static artifacts.
  2. Verified Generation Architecture: How to formalize interfaces between generators and hierarchies of verifiers (proxy vs. ground truth).
  3. Learning Under Churn: How to build systems that generalize across changing workloads, hardware generations, and toolchains.
  4. Human-Model Co-Design: How to structure workflows where humans and models collaborate with clear provenance and accountability.
• Systems Readiness Matrix: The authors introduce a matrix (Table 2) to assess the maturity of GenAI capabilities, highlighting that while methods are emerging, infrastructure and cross-domain transfer remain early-stage.

Conclusion:
The paper concludes that the future of GenAI in systems lies not in building larger models in isolation, but in integrating generative models into robust, hybrid engineering loops that respect the constraints of the computing stack. By adopting the identified design principles, the field can move toward reliable, scalable, and trustworthy AI-driven system design.