I Asked an AI to Build Three Circuits—Here's What Happened

I wanted to test a fairly simple question:

How far can an AI take a circuit if I describe the result instead of placing every component myself?

Not “can it draw something that looks plausible?” That bar is too low for electronics. I wanted to know whether it could build a circuit, connect it, simulate it, find problems, and leave me with something useful outside the browser.

So I tried three requests of increasing difficulty:

1. A 9 V LED circuit.
2. An automatic night light using an LDR and transistor.
3. A one-second LED blinker built around a 555 timer.

For this experiment I used Antika Circuit, an in-browser circuit editor with an AI assistant built into the workspace. The important part of the test was not how quickly a circuit appeared. It was whether I could inspect and verify what appeared.

Quick disclosure: I am part of the team building Antika Circuit. This is a reproducible walkthrough rather than an independent benchmark; the goal is to show the workflow, including the checks I would still make as a user.

What we are going to do

The workflow stays the same as the circuits become more complex:

Describe the result
        ↓
Let the AI place and connect parts
        ↓
Inspect values and polarity
        ↓
Run a simulation
        ↓
Ask the AI to diagnose the result
        ↓
Export the finished circuit

You do not need prior electronics experience to follow along. If you already know the basics, focus on the prompts, the verification results, and the export step.

Before starting, create a project and keep the Animate changes option enabled in the assistant settings. It is slower than applying the entire result at once, but it lets you watch components and connections appear in sequence. That makes an incorrect assumption easier to catch.

For every circuit below, wait until the assistant finishes its plan and verification before pressing Simulate. The assistant's check runs separately from the interactive simulation, so the second run is your opportunity to reproduce the result on the visible workspace. If a reported value and the canvas disagree, stop there and ask the assistant to inspect that exact measurement instead of moving to the next circuit.

1. Start with the smallest useful circuit

Open a new schematic project and send this prompt to the assistant:

Build a 9 V LED circuit with a 330 Ω current-limiting resistor.
Place it, wire it, and verify the LED current.

This is intentionally specific. It gives the assistant:

• An outcome: light an LED.
• A supply
• voltage: 9 V.
• A safety constraint: use a 330 Ω resistor.
• A test: report the LED current.

The assistant created a series loop containing a DC source, resistor, LED, and ground. It also returned a short plan, the changes it made, and an isolated simulation check.

Before pressing Simulate, I checked three things:

• The resistor is in series with the LED.
• The LED anode points toward the positive side of the supply.
• The circuit has a ground reference.

Those checks matter because a clean-looking diagram can still be electrically wrong.

With the simple LED model used here, the expected branch current is about 21.2 mA. The assistant reported that value, but the useful part was being able to press Simulate and see the result on the circuit itself. Wire colors changed with potential, and the voltage and current labels appeared next to the relevant parts.

That makes the first lesson surprisingly important: do not ask only for a circuit. Ask for a measurable result.

Compare these two prompts:

Build an LED circuit.

Build a 9 V LED circuit with a 330 Ω current-limiting resistor.
Verify the LED polarity and report the simulated branch current.

The second prompt gives both the AI and you a definition of “done.”

2. Add a sensor and ask the AI to diagnose states

The next circuit needs to respond to the environment. I asked for an automatic light that switches on when the room becomes dark:

Turn this into an automatic night light with an LDR,
an NPN transistor, and an LED.

Test bright and dark conditions and diagnose unsafe values.

This request is more interesting than the LED loop because one screenshot cannot prove that it works. A night light has at least two meaningful states:

• In bright conditions, the lamp should be off.
• In dark conditions, the lamp should be on.

The resulting circuit uses the LDR in a voltage divider. That divider drives the base of an NPN transistor, which switches the LED branch. A 330 Ω resistor limits the LED current.

I then used the assistant as a diagnostic tool instead of treating it only as a circuit generator. It inspected the sensor divider, checked the transistor stage, simulated both light levels, and returned the expected states.

This is where a conversational workflow becomes useful. You can ask questions that would be awkward to express as toolbar actions:

Why is the LED off at 1000 lux?

Set the LDR to 10 lux and check whether the transistor turns on.

Is any LED branch missing a current-limiting resistor?

For the dark-state test, I changed the LDR to 10 lux and ran the simulation again. The LED switched on, matching the assistant's diagnosis.

The practical takeaway is to test behavior, not just topology. For a sensor circuit, ask the AI to evaluate the boundary conditions explicitly. “Connected correctly” is weaker than “off at 1000 lux and on at 10 lux.”

It is also worth changing one condition at a time. If you change the supply, sensor value, transistor, and resistor together, a passing result tells you much less about why the circuit works.

3. Move to a timed circuit with a 555

For the final build, I asked for something with an observable time-domain behavior:

Design a 555 timer that blinks an LED once a second.
Choose the timing values, wire it, and verify frequency,
output swing, and LED current.

This prompt asks the assistant to make several connected decisions:

• Configure the 555 in astable mode.
• Choose a resistor-capacitor timing network.
• Add supply and control-pin bypass capacitors.
• Protect the LED with a series resistor.
• Verify a frequency rather than only a DC voltage.

The generated design used a 10 kΩ / 68 kΩ / 10 µF timing network. The verification reported:

• Frequency: 0.986 Hz.
• Output swing: 0.00 V to 5.00 V.
• LED current: 9.06 mA.

The difference between “the LED is connected” and “the LED blinks at 0.986 Hz with 9.06 mA” is the difference between visual confidence and electrical evidence.

I still inspected the breadboard before running it:

• VCC and RESET are tied high.
• THRESHOLD and TRIGGER share the timing node.
• DISCHARGE is connected between the two timing resistors.
• The LED has its own 330 Ω resistor.
• The circuit includes a ground reference and bypass capacitors.

Then I ran the transient simulation and watched the 555 output alternate between its high and low states.

For a timed circuit, a single paused frame cannot show the whole result. Use Play to observe the repeating behavior, Pause to inspect a state, and Step when you want to advance through intermediate states deliberately.

4. Export something useful

A browser experiment becomes more valuable when the result can leave the browser.

From the finished 555 project, open File → Export. The export panel lets you choose a source view and preview the output before downloading it.

For this walkthrough, I would create three kinds of deliverable:

PDF for a readable record

Choose PDF, select the schematic view, add a title and author, and keep component value labels enabled. If the live measurements help explain the design, include the simulation voltage/current labels too.

This gives you a print-ready document that is useful for an assignment, design review, or lab notebook.

PNG or SVG for documentation

Use PNG when you want a quick image for a README, message, or class handout. Use SVG when you want scalable linework for documentation or slides.

SPICE for continued simulation

Choose SPICE to export an ngspice-compatible netlist. This is the useful bridge when the browser model is only the beginning and you want to continue in a more specialized simulation workflow.

KiCad schematic export is also available when the next step is moving toward a PCB-oriented tool, but I kept this experiment focused on documentation and simulation outputs.

What worked—and what I would still verify

The AI was most helpful when it handled repetitive construction and made its assumptions visible:

• It translated a result into a component list.
• It placed and connected parts.
• It exposed the actions it performed.
• It tested the circuit and returned measurements.
• It diagnosed state-dependent behavior.

What it did not remove was the need for engineering judgment.

I still checked polarity, ground, current limiting, state transitions, and the meaning of the reported measurements. That is the workflow I want from an AI tool: not a black box that asks for trust, but a fast collaborator whose output remains inspectable.

The prompts also mattered more than their length. The most reliable pattern was:

Build [observable outcome]
using [required parts or constraints].
Test [specific states].
Report [numeric measurements].
Diagnose [failure or safety conditions].

For example:

Build a temperature alarm using a thermistor and buzzer.
Keep the buzzer off at 20 °C and turn it on at 70 °C.
Report the sensor-divider voltage in both states and check
that the output device is not overloaded.

That prompt is a small test specification, not merely a description.

Try the same progression

If you want to reproduce the experiment, open Antika Circuit and start with the LED prompt. Once it simulates correctly, turn it into a sensor-driven circuit, then ask the assistant for a timed design of your own.

You can also watch the complete AI-to-export workflow on YouTube before trying it yourself.

My suggested variation: change the 555 request from one blink per second to two, but ask the AI to preserve a safe LED current. That forces it to modify the timing network without unnecessarily changing the output stage—and gives you a clear result to verify.

The best outcome is not that the AI built the circuit for you. It is that you can explain why the finished circuit works.