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
  • 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

‹AI Skills for VLSI Engineers
  1. Topics
  2. AI Skills for VLSI Engineers
  3. AI Skills: Full Course Index

Start here · All levels

AI Skills: Full Course Index

Required starting route, new practical modules and preserved reference lessons in one index.

On this page

    Follow the fourteen-part route on the course hub. This index also retains the earlier reference library; a longer list is not a requirement to read every page before doing useful work.

    Getting started

    Getting Started with AI for VLSI Engineers

    Useful AI Tasks: Start Small and Checkable

    Assistants, Models, Tools, and Your Responsibility

    Your First RTL Explanation

    Improve the Answer and Check It Independently

    Choose a Tool for the Task

    Just enough AI

    Just Enough AI: Models and Context

    What a Language Model Does

    Next-Token Prediction and the Sampling Loop

    Training and Inference

    Parameters at an Intuitive Level

    Fluency, Correctness and Knowledge Cutoff

    Temperature and Sampling

    Tokens and Tokenization

    Tokens, Words and Characters

    Subword Tokens and Byte-Pair Encoding

    Why Some Text Costs More Tokens

    Approximate Rules of Thumb

    Estimating Tokens Before Sending

    Context Window and Attention for Users

    What Counts Against the Window

    When the Window Fills

    Attention in One Picture

    Long Inputs and the Lost Middle

    A Context-Budget Planner

    Asking clearly

    Prompting

    Anatomy of a Prompt

    Five Parts of a Prompt

    Roles: System, User, and Assistant

    Specific and Parseable

    Weak Versus Strong Prompts

    Prompt Template Builder

    Examples and Reasoning

    Zero-Shot and Few-Shot Prompts

    Choosing and Ordering Examples

    Step-by-Step Reasoning Prompts

    Self-Checks and Structured Output

    Prompt Debugging

    Diagnose the Failure First

    Change One Thing at a Time

    Keep a Small Set of Test Prompts

    A Prompt Regression Harness

    Verification and safe use

    Trust and Verification

    Hallucination and Failure Modes

    Invented APIs, Flags and Signal Names

    Plausible but Wrong Numbers

    Overconfident Tone and Sycophancy

    Instruction Drift in Long Sessions

    Subtle Bugs That Compile

    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

    Define the Task Before Measuring Anything

    Build a Small Labelled Test Set

    Measure Pass Rate and Time Saved

    Track Cost per Accepted Result and Decide

    Everyday engineering assistance

    Using AI for Engineering Work

    RTL and Testbench Assistance

    Explaining Unfamiliar RTL

    Drafting RTL from a Spec

    Drafting Testbenches

    Reviewing for Latches, Widths and Assertions

    Assumptions and Acceptance

    Debugging with AI

    Log Slices That Help

    Ranked Hypotheses with Evidence

    Summarising and Clustering Logs

    The Engineer Runs the Experiment

    Scripts and Automation

    Reviewing Generated Scripts

    Idempotence and Dry-Run Flags

    Testing a Script on a Copy

    A Small Static Checker for Scripts

    Data, Privacy and IP

    What Never to Paste

    Policy and Approved Tools

    Sanitise Before Sharing

    Local Tools, Hosted Tools, and Security Review

    Role-based VLSI walkthroughs

    Engineering Walkthroughs

    Specification to Requirements

    RTL Review

    Verification Plan and Assertions

    Scoreboard Debug

    Timing Report

    Physical Design Reports

    Engineering Writing

    Scripts, APIs and working copies

    Practical Foundations for AI Workflows

    APIs: Requests, Responses and Errors

    JSON Records and Meaningful Validation

    Repositories, Diffs and Isolated Changes

    Working with Waveforms and Report Images

    Engineering data

    Engineering Data

    Files, CSV, and JSON

    Tables and IDs

    Basic SQL for Engineering Questions

    Regression Database Lab

    Queries Versus Search

    RAG and grounded answers

    Retrieval-Augmented Generation

    The Retrieval Workflow

    Preparing Engineering Documents

    Keyword and Semantic Search

    Embeddings and Vector Storage

    Grounded Answers and Abstention

    Specification Assistant Lab

    Tools, workflows and agents

    Agents and Tool Use

    What an Agent Is

    Prompts, Scripts, and Agents

    The Agent Loop Step by Step

    Agent Components

    Agent Loop Simulator

    When a Script Wins

    Tool Use and Structured Output

    Describing Tools to a Model

    Propose, Execute, Validate

    Handling Malformed Calls

    Idempotent and Side-Effecting Tools

    Tool-Call Validator Lab

    Planning, Memory and Stopping

    Task Decomposition and Success Criteria

    Memory Outside the Model and Summaries

    Step and Cost Budgets

    Loop Detection and Stopping

    Multi-Agent Patterns and When Not to Use Agents

    Planner, Worker and Reviewer Patterns

    Hand-off Cost and Error Compounding

    Complexity and Debuggability

    Script, Workflow or Agent

    Design a simple agent

    Agent Design

    Define the Task and Boundaries

    Design the Architecture

    Build Safe Read-Only Tools

    Control the Decision Loop

    Record State and Hand Over

    Handle Errors and Budgets

    Build the Starter Controller

    Evaluate Your Assistant

    MCP and reusable skills

    MCP and Skills

    What MCP Is

    Clients, Servers, and Capabilities

    Connect Read-Only Tools

    Permissions and Untrusted Content

    Reusable Engineering Skills

    One-Tool Server Extension

    Small multi-agent workflows

    Multi-Agent Design

    When to Split a Task

    Roles and Task Contracts

    Context and Handoffs

    Merge and Disagreements

    Permissions, Budgets and Failures

    Review Team Lab

    Troubleshooting and final project

    Practical Capstone

    Define the Assistant

    Assemble the Workflow

    Troubleshoot the Workflow

    Evaluate Known and Unseen Cases

    Compare Effort and Cost

    Final Review and Handover

    Optional reference library

    Tokens, Cost and Latency

    Cost Arithmetic

    The Cost Formula

    A Code-Review Job

    A Nightly Regression Summary

    Sensitivity and a Cost Calculator

    Latency and Throughput

    Time to First Token and Decode Speed

    A Simple Latency Model

    Streaming, Batching and Interactive Use

    Rate Limits and Retries

    Reducing Tokens

    Prefix Caching

    Summarisation and Information Loss

    Retrieval Instead of Pasting

    Trimming Logs and RTL

    Agentic Workflows for Chip Teams

    Regression Triage Agent

    The Nightly Triage Loop

    Clustering Failures by Signature

    Ranking Suspects with Evidence

    Read-Only by Default

    Evaluating Against Labelled History

    Lint-and-Fix Loops

    Anatomy of the Loop

    Acceptance Rules and the Test Suite

    Limits and Failure Modes

    A Loop Simulator with a Fake Fixer

    Guardrails and Human in the Loop

    Permission Tiers and Least Privilege

    Sandboxing and Approval Gates

    Rate, Cost Limits and Audit Logs

    Secret Handling

    Prompt Injection from Files and Logs

    Evaluating and Operating Agents

    Task Success Rate on a Held-Out Set

    Cost and Latency per Task

    Regression Suites for Agent Changes

    Drift, Incident Review, and Shutoff Rules

    Interview and Judgment

    AI Interview Questions

    Tokens and Context Questions

    Cost Estimation Questions

    Prompting Questions

    Verification Questions

    Agent Questions

    Guardrails and Judgment Questions

    Design Scenarios with Numbers

    Estimate a Review Assistant Budget

    Design a Regression-Triage Agent

    Give a Model a 300k-Token Codebase

    Evaluate Before Adopting a Tool

    Related topics

    • Course guide

    Previous

    171 / 173

    Next: Working with AI Glossary

    Up next

    Up nextWorking with AI Glossary

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Getting Started with AI for VLSI Engineers
    • Just Enough AI: Models and Context
    • Prompting