DigiTekXplorer - AI Case Studies

Think of the AI, Gemini 2.5 Pro, as a technical co-pilot and infinitely patient talented developer instead of just a code generator. It's brilliant at executing well-defined tasks, but it relies on you, the project architect and senior developer, to provide the vision, context, and quality control.

Your process can be broken down into four key phases.

Phase 1: The "Architect" Phase - Specification and Scaffolding

This is the most critical phase. A clear specification leads to useful code. Your goal is to give the AI a complete "blueprint" of what you want to build.  In this context, scaffolding means the process where the architect provides temporary support to the AI as it learns new concepts or skills for the design task. The support is gradually reduced as the AI becomes more proficient.  In other words, the architecture guides the AI in the direction of the desired outcome. 

How to Write the Prompt:

Assign a Role: Start the prompt by giving the AI an expert persona. This primes the model to access the most relevant information and adopt the correct terminology.

"Act as an expert Android developer specializing in Bluetooth Low Energy."

"You are a computer architect. We are designing a 16-bit microprocessor from scratch."

"Assume the role of a senior FPGA design engineer specializing in SystemVerilog."

Define the Scope and Constraints: Clearly state the boundaries of the project.

Technology Stack: "This will be written in Python 3.9.", "The target IDE is Android Studio using Kotlin.", "The HDL is SystemVerilog for a Xilinx Artix-7 FPGA."

High-Level Goal: "I am building a C-like compiler for a custom 16-bit CPU.", "I need a UART module that can transmit and receive 8-bit data with one start bit and one stop bit."

Key Constraints: "Do not use any external libraries.", "The design must be synthesizable.", "Focus on clarity and add extensive comments."

Provide a Detailed Specification: This is what you must do in an iterative process. Break down the project into its core components.

For Software/HDL: Define functions, classes, modules, inputs/outputs (I/O), and state machines.

For Architecture: Define the instruction set architecture (ISA), register file, memory map, and addressing modes.

Example: "Design a SystemVerilog UART receiver module named 'uart_rx'. It needs the following ports: clk, reset, rx_in (serial input), data_out (8-bit parallel output), and data_valid (a single-cycle pulse). It should operate based on a state machine with states: IDLE, START, RECEIVING_DATA, and STOP."

Pro-Tip: Before asking for the full code, ask the AI to outline the plan first.

"Based on the spec above, provide a step-by-step plan for implementing this. List the modules/classes we'll need and the order in which we should build them."

Phase 2: The "Coder" Phase - Generation and Implementation

Once you have a solid plan, you can ask for code.

How to Write the Prompt:

Be Specific and Modular: Don't ask for the entire, massive project at once. Ask for one component from your plan.

"Based on our plan, please write the Python code for the 'Assembler' class. It should have a method called 'parse_instruction' that takes a line of assembly code as a string and returns a 16-bit machine code integer."

Reference the Context: Remind the AI of the key design decisions made in Phase 1.

"Now, generate the SystemVerilog code for the 'uart_rx' module we defined. Remember to use the 16x oversampling clock we discussed for detecting the start bit."

Phase 3: The "Compiler Whisperer" Phase - Syntax and Integration Debugging

This is a tight, iterative loop. You act as the bridge between the AI and the ground-truth of a tool’s Integrated Development Environment (IDE).  In this context, "ground-truth" refers to the objective, undeniable reality of what happens when your code is processed by the actual development tool. It is the final, non-negotiable verdict from the compiler, interpreter, synthesizer, or simulator.

How to Write the Prompt (The "Error Sandwich" Method):

This is the most effective debugging prompt format. You "sandwich" the error message between the context and the problematic code.

Context: State the tool and the goal. "I am using Vivado to synthesize the SystemVerilog code you provided, and I'm getting a syntax error."

The Error Message: Copy and paste the exact error message from your tool. This is crucial as it contains line numbers and specific keywords the AI can use. "The error is: [Synth 8-27] procedural assign not supported [...] on line 42."

The Code Snippet: Paste the relevant lines of code around the error. Don't paste the whole file unless it's small. "Here is the code around line 42:" followed by the code block.

The Question: Ask for an explanation and a solution. "Please explain what this error means and provide the corrected code."

Phase 4: The "Detective" Phase - Functional and Logic Debugging

This is harder than syntax debugging because the code runs but doesn't do what you want.

How to Write the Prompt:

State the Goal: "We are now debugging the functionality of the abCore16 simulator."

Describe the Expected Behavior: "When I execute the 'ADD R1, R2' instruction, I expect the value in register R2 to be added to register R1, and the result stored in R1."

Describe the Observed (Wrong) Behavior: "However, what I'm observing is that the value from R2 is overwriting R1, not being added to it. The original value of R1 is lost."

Provide the Relevant Code: Paste the function or module responsible for the logic. "Here is my 'execute_instruction' function in Python."

Ask for Debugging Strategies: This is where you leverage the AI's power to suggest troubleshooting steps.

"Can you analyze this code for a potential logic error?"

"What's the best way to debug this? Suggest some print statements I can add to trace the values of R1, R2, and the ALU output during execution."

"Can you write a SystemVerilog testbench snippet that specifically tests this failing corner case?"

By following this four-phase framework, you systematically guide the AI from a high-level concept to a fully debugged, functional implementation, making the entire development process faster and more robust.