ltspice-circuits

LTspice Circuits

A complete workflow for reading, editing, building, simulating, and debugging LTspice circuits through a CLI wrapper around spicelib and LTspice's batch-mode runner.

When to activate

Activate this skill any time the task involves circuits or SPICE in a simulation context. Triggers include:

• Any mention of a .asc (schematic) or .raw (waveform output) file.
• The user mentions LTspice, SPICE, circuit simulation, schematic, netlist.
• EE coursework about circuit analysis — KVL/KCL practice, Thevenin/Norton equivalents, RC/RL/RLC transients, AC frequency response, filter design (low-pass, high-pass, band-pass), op-amp circuits (inverting, non-inverting, integrator, differentiator, Sallen-Key), oscillators.
• Device characterization: MOSFET (V_GS/V_DS sweeps, transfer/output curves, threshold extraction), BJT (Gummel plots, beta vs I_C, common-emitter gain), diode (I-V curves, breakdown, rectifier behavior).
• Analysis types: .tran (transient), .ac (small-signal AC), .dc (DC sweep), .op (operating point), .noise, .tf (transfer function).
• The user mentions plotting a signal, probing a node voltage, or measuring something on a waveform.

CLI invocation

Always invoke the CLI through Python:

py "${CLAUDE_PLUGIN_ROOT}/lib/ltspice_cli.py" <subcommand> [args]

Read / debug subcommands

Subcommand	Purpose
inspect <file.asc>	Print structured topology — components, values, nets, directives.
sim <file.asc>	Run LTspice in batch mode (-b). Produces <file>.raw and <file>.log.
signals <file.raw>	List every available signal (node voltages, branch currents) in the raw file.
probe <file.raw> <sig> [--at T]	Return numeric samples for a signal. --at T returns the value at time T.
op <file.asc>	Run a fresh .op on the schematic (strips other analysis directives) and print node voltages / device currents.
plot <file.raw> <sig> [sig...]	Render the named signal(s) to a PNG. Returns the PNG path.
open <file>	Open the file in its default Windows handler (LTspice for .asc/.raw).
meas <file.log> [name]	Read .meas directive results from a simulation .log (omit name to list all).
netlist <file.asc> [--out P]	Convert a schematic to a SPICE netlist (.net).

Edit subcommands

Subcommand	Purpose
set-value <file.asc> <ref> <value>	Change the value of a component (e.g. R1 to 4.7k).
set-directive <file.asc> <pattern> <new>	Replace a SPICE directive line matching pattern.

Build subcommands

Subcommand	Purpose
new <file.asc>	Create an empty schematic with the LTspice header.
`add-component [--rotation R0	R90
add-wire <file> <x1> <y1> <x2> <y2>	Draw a wire segment between two coordinates.
add-flag <file> <x> <y> <name>	Place a net label. name=0 is ground.
add-directive <file> <text>	Add a SPICE directive (e.g. .tran 1m, .ac dec 10 1 1Meg, .step param R 1k 10k 1k).
pins <symbol>	Print the pin offsets (relative to the component origin) for a given symbol. Use this before placing wires so you connect at the right coordinates.
new-symbol <file.asy> <n_pins>	Generate a minimal .asy block symbol for a subcircuit.

Standard debugging workflow

When given an existing .asc to debug or analyze:

1. Inspect first. Run inspect <file.asc> to learn the topology, component values, and existing directives. Never guess what's in a schematic — read it.
2. Simulate. Run sim <file.asc>. Check the exit code and skim the resulting .log for SPICE errors (convergence failures, missing models, syntax issues).
3. Discover signals. Run signals <file.raw> to see what node voltages and branch currents are available. Signal names follow LTspice conventions: V(node) for node voltages, I(R1) for branch currents through a device.
4. Visualize. Run plot <file.raw> <sig> for each signal of interest, then Read the resulting PNG. This is the primary visualization path — Claude Code can see images, so a plot tells you far more than scalar numbers ever can.
5. Probe for precision. Once you've seen the shape on a plot, use probe <file.raw> <sig> --at <time> to get exact numeric values at specific points (e.g. steady-state, peak, zero crossing).
6. Edit. Use set-value for component tweaks (R, C, L, source amplitudes), set-directive for analysis parameter changes (e.g. switching .tran 1m to .tran 10m). Use add-component / add-wire / add-flag for structural changes.
7. Re-simulate. Always re-run sim after any edit. A stale .raw file looks plausible but reflects the previous schematic — it lies silently. If you edit, you must re-sim before trusting any probe or plot output.

Build-from-scratch workflow

When the user wants a circuit built from a natural-language description:

1. Choose location. Put the schematic in ./circuits/ relative to the current working directory. Example: circuits/rc_lowpass.asc. This is important — the user can then double-click the file in File Explorer to open it in the LTspice GUI (the .asc extension is registered to LTspice on Windows).
2. Create the empty schematic. new circuits/<name>.asc.
3. Look up pins before placing. Before each add-component, run pins <symbol> to get the pin offsets. You need them to compute the wire endpoint coordinates correctly. Misplaced wires that don't touch a pin produce floating nodes and silent simulation failures.
4. Place components. add-component <file> <symbol> <x> <y> --ref <NAME> --value <V>. Use the LTspice coordinate convention (positive Y is down; grid units are 16 px). Lay components out on a grid so wires stay orthogonal.
5. Connect with wires. add-wire <file> <x1> <y1> <x2> <y2>. Endpoints must land on pin coordinates (component origin + pin offset from pins).
6. Label nets. add-flag <file> <x> <y> <name>. Use name=0 for ground (every analog circuit needs at least one ground reference). Use descriptive net names (VIN, VOUT, VDD) for nodes you'll probe later.
7. Add an analysis directive. add-directive <file> ".tran 1m" (transient), ".ac dec 10 1 1Meg" (AC sweep), ".dc V1 0 5 0.01" (DC sweep), or ".op" (operating point).
8. Simulate and visualize. Run sim, then plot the signals of interest, then Read the PNG.

Visualization rule

Always prefer plot + Read the PNG over numeric probe summaries when communicating what a signal is doing.

• Claude Code can see images. A waveform PNG conveys oscillations, glitches, ringing, slow exponential settling, overshoot, distortion, and asymmetry instantly.
• Scalar numbers from probe hide everything except the value at one instant. A circuit that looks fine at t=5ms might be ringing wildly between 1ms and 4ms.
• Use probe for precision (exact numeric answers like "what's V_OUT at steady state?") after you've understood the shape from a plot, not instead.

Schematic location

Keep all schematics under ./circuits/ in whatever working directory the user is in. Two reasons:

1. GUI access. .asc files are registered to LTspice on Windows (verified via the registry). The user can double-click any file in ./circuits/ in File Explorer and it opens immediately in the LTspice GUI for visual inspection.
2. open subcommand. Use py ... ltspice_cli.py open <file> to launch the LTspice GUI on a file from the CLI. This is the right move when the user says "show me the schematic" or "let me see it in LTspice."

The CLI auto-detects the LTspice executable (env vars LTSPICEEXECUTABLE/LTSPICEFOLDER, then the standard ADI / LTspice XVII / macOS install paths). Batch mode flag is -b — the sim subcommand handles this automatically.

Memory references

For deeper detail on the .asc format, component symbols, analysis directives, or source syntax, consult these reference files bundled with the plugin (consult them when you need specifics that aren't in this skill):

• ${CLAUDE_PLUGIN_ROOT}/references/reference_ltspice_asc_format.md — full .asc file grammar, coordinate system, header conventions.
• ${CLAUDE_PLUGIN_ROOT}/references/reference_ltspice_components.md — symbol library, pin offsets, default attributes.
• ${CLAUDE_PLUGIN_ROOT}/references/reference_ltspice_analyses.md — every analysis directive (.tran, .ac, .dc, .noise, .tf, .four, .meas) with syntax and examples.
• ${CLAUDE_PLUGIN_ROOT}/references/reference_ltspice_sources.md — voltage/current source syntax: PULSE, SIN, EXP, PWL, SFFM, AC.
• ${CLAUDE_PLUGIN_ROOT}/references/reference_ltspice_directives.md — .param, .step, .func, .global, .inc, .lib, .model.
• ${CLAUDE_PLUGIN_ROOT}/references/reference_ltspice_toolkit.md — the CLI wrapper internals, spicelib notes, raw-file structure.

Common gotchas

• Stale .raw files lie silently. If you edit a .asc and forget to re-sim, every subsequent probe/plot reflects the old circuit. Re-sim after every edit. No exceptions.
• Stepped sweeps produce N traces per signal. When a .step param is active, signals shows one signal name but probe/plot returns N waveforms (one per step value). probe automatically reports every step; plot returns a multi-trace PNG (one curve per step value).
• Pin coordinates matter for wire connections. Wires that miss a pin by even one grid unit produce a floating node. Always run pins <symbol> before computing wire endpoints. The pin offset is relative to the component's (x, y) origin and changes with rotation.
• .inc and .lib paths must be absolute Windows paths with escaped backslashes. LTspice's directive parser doesn't expand ~ and doesn't tolerate forward slashes in include paths. Use a full path with double-backslashes inside directives, e.g. C:\\Users\\<you>\\models\\2N7000.LIB.
• Ground is mandatory. Every simulation needs at least one node labelled 0 (placed via add-flag <x> <y> 0). LTspice will refuse to converge without it. The inspect subcommand will surface this.
• Convergence failures usually mean: missing ground, unconnected node, a voltage source driving directly into a capacitor with no series resistance, or a model file the simulator can't find. Read the .log after every sim.

What NOT to do

• Don't render schematics yourself. Don't draw ASCII-art circuit diagrams or guess what a .asc looks like. Use inspect to read the real structure, or open to show the user the LTspice GUI.
• Don't guess simulation output. Never report waveform behavior, peak values, settling time, or gain figures from intuition. Run sim, then plot or probe, then report what the data actually says.
• Don't use the older ltspice pip package. Use spicelib (which is what this CLI wraps). The two have similar names but spicelib is the maintained, currently-correct library; the older ltspice package has incompatible APIs and known bugs around raw-file parsing.
• Don't edit the schematic without re-simming. Restated because it's the single most common failure mode.
• Don't compute circuit behavior analytically and present it as the simulation result. The point of LTspice is to verify intuition against numerics. Run the sim.