Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • Getting Started with AI for VLSI Engineers5
  • Just Enough AI: Models and Context15
  • Prompting13
  • Trust and Verification14
    • Hallucination and Failure Modes
    • Verifying AI Output
      • The Verify-First Checklist
      • Differential Testing Against a Reference
      • Property-Based Checks
      • Review the Diff, Not Just the Result
      • When to Refuse to Trust
    • Evaluating AI Tools for Your Team
  • Using AI for Engineering Work17
  • Engineering Walkthroughs7
  • Practical Foundations for AI Workflows4
  • Engineering Data5
  • Retrieval-Augmented Generation6
  • Agents and Tool Use18
  • Agent Design8
  • MCP and Skills6
  • Multi-Agent Design6
  • Practical Capstone6
  • Tokens, Cost and Latency12
  • Agentic Workflows for Chip Teams18
  • Interview and Judgment10
  • AI Skills: Full Course Index
  • Working with AI Glossary
  • Working with AI Cheatsheet
Loading lesson

‹Verifying AI Output
  1. Topics
  2. AI Skills for VLSI Engineers
  3. Trust and Verification
  4. Verifying AI Output
  5. The Verify-First Checklist

Verification and Safe Use · Beginner to Intermediate

The Verify-First Checklist

A fixed check order for assistant-written changes: compile, lint, simulate, assert, test, then compare.

On this page

    Run checks in a fixed order

    Every assistant-written change runs the same stages in the same order. A fixed order keeps cheap checks first and stops weak changes early.

    Compilation rejects syntax and type mistakes. Lint rejects suspicious but legal code, simulation and assertions check behavior, and comparison against a reference checks intent.

    Stage

    What it rejects

    Example

    Compile

    Syntax and type mistakes

    Undeclared signal, width mismatch, missing semicolon.

    Lint

    Suspicious but legal code

    Inferred latch, unintentional truncation, unread reset.

    Simulate

    Wrong behavior on driven inputs

    State machine skips a state under reset release.

    Assert

    Broken invariants during the run

    One-hot enable with two bits set.

    Test

    Failures in the existing suite

    A regression in an untouched block.

    Compare

    Disagreement with a reference

    Generated RTL differs from a trusted model.

    A worked escape count

    Assume 100 defects reach an assistant-written change. The calc block below is a stated example parameter, not a measured rate.

    plaintext
    1
    2
    3
    4
    5
    6
    assume 100 defects in one assistant-written change (stated example parameter)
    compile rejects 40, leaving 100 - 40 = 60
    lint rejects one half of the remainder: 60 / 2 = 30, leaving 60 - 30 = 30
    simulation rejects nine tenths of the remainder: 30 x 9 / 10 = 27, leaving 30 - 27 = 3
    caught 40 + 30 + 27 = 97, escaped 3
    shares: 40% + 30% + 27% + 3% = 100%

    Make the checklist automatic

    A checklist that depends on memory is skipped under pressure. Encode the order in one script or command so every change runs every stage.

    Record which stages passed with each change. A change that skipped simulation is still unreviewed, whatever the reason.

    Common mistakes

    Common pitfall

    Stopping at a clean compile treats a syntax check as a behavior check. Most assistant mistakes are legal code with wrong behavior, which only simulation and comparison catch.

    Interview

    Likely probes: the stage order and what each stage rejects.

    • Cheap stages run first: compile, then lint, then simulation and assertions.

    • Each stage rejects a different defect class, so skipping one leaves its class unchecked.

    • The escape count multiplies remainders; one skipped stage keeps its whole remainder.

    Check yourself Lint is clean and the code compiles. Which defect classes are still unchecked?

    Behavior, invariants, regressions, and intent. Simulation, assertions, tests, and comparison against a reference are still owed.

    Check yourself In the worked count, simulation is skipped. How many defects escape?

    30 instead of 3. Lint leaves 30, and all 30 reach the design untested.

    Related topics

    • Differential testing against a reference

    • Failure modes

    Previous

    39 / 173

    Next: Differential Testing Against a Reference

    Up next

    Up nextDifferential Testing Against a Reference

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Property-Based Checks
    • Review the Diff, Not Just the Result
    • When to Refuse to Trust