Guide · Agent skill
How to use the Qiskit Quantum Computing agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
The qiskit skill is an instruction package that teaches an AI agent how to write, check and run quantum programs with the Qiskit SDK and IBM Quantum Runtime. This guide explains what the skill makes the agent do, how to install it, how to ask for things in plain language, and what to check before running anything on real hardware. You do not need prior experience with agent skills to follow it.
Qiskit Quantum ComputingK-Dense-AI/scientific-agent-skills · MIT Download the skill Quick start
- 1Download and unzip. Download the qiskit skill ZIP from this page and unzip it. Keep the folder name qiskit.
- 2Place the folder. Move the qiskit folder to ~/.claude/skills/ for personal use, or to .claude/skills/ in your project. Alternatively, upload the ZIP under Settings, then Capabilities, then Skills.
- 3Create a Python environment. Use Python 3.10 or newer in an isolated environment and install qiskit with the visualization extra. Add qiskit-aer or qiskit-ibm-runtime only if you need them.
- 4Ask for a local example. Describe a small circuit in plain language and ask for a local sampling or estimation run first.
- 5Check results locally. Confirm the counts or expectation values make sense on the local simulator before any hardware work.
- 6Connect to IBM only when needed. Save your IBM Quantum Platform API key securely as the setup reference describes, then ask the agent to inspect a backend and transpile for it.
- 7Review before submitting. Check the backend, transpiled circuit, shots and precision settings, then approve the hardware job and save its job ID.
What the qiskit skill makes the agent do
Once the skill is loaded, the agent follows Qiskit 2.x conventions when it builds quantum circuits and operators. It can run circuits on local simulators, including noisy simulation, prepare circuits for IBM quantum hardware through target-aware transpilation, and submit jobs through the V2 Sampler and Estimator interfaces.
The skill also includes reference notes on migration, transpilation, visualization and testing, plus small scripts that check the installed environment, inspect IBM backends and run local examples.
- Build and inspect QuantumCircuit objects
- Sample measurement results and estimate expectation values locally
- Simulate ideal and noisy circuits
- Transpile circuits for a specific IBM backend
- Run Runtime sessions or batches on IBM quantum processors (QPUs)
Install the qiskit skill with a ZIP download
Download the skill ZIP from the qiskit page on this directory, then unzip it. Put the resulting qiskit folder in one of these locations:
For a personal setup available in every project, place it in ~/.claude/skills/. For a single project, place it in that project's .claude/skills/ folder so it only applies there.
In the Claude apps, you can instead upload the ZIP under Settings, then Capabilities, then Skills.
- Personal: ~/.claude/skills/qiskit
- Project only: .claude/skills/qiskit inside your project folder
- Claude apps: Settings → Capabilities → Skills, then upload the ZIP
Set up Python and the Qiskit packages
The skill expects Python 3.10 or newer on a supported 64-bit platform. The skill's own setup notes recommend an isolated environment. The core Qiskit SDK is needed for local work. Add the visualization extra if you want plots, qiskit-aer for noisy simulation, and qiskit-ibm-runtime only when you need IBM hardware.
Do not install qiskit-terra. The source says it has been superseded by the qiskit distribution. The skill's setup reference covers IBM account setup, credential handling and environment repair.
- Required for local work: qiskit (with the visualization extra for plotting)
- Required for noisy simulation: qiskit-aer
- Required for IBM hardware: qiskit-ibm-runtime, network access, an IBM Quantum Platform account and an API key
uv venv --python 3.13
source .venv/bin/activate
uv pip install "qiskit[visualization]==2.5.2"Trigger the skill with natural requests
You usually do not need to name the skill. The skill is written to load when your request involves Qiskit circuits, primitives, transpilation, simulation, IBM QPU execution, Runtime sessions or batches, or error mitigation. Say what you want to achieve and mention Qiskit if you want to be sure.
Be specific about the backend and whether the run should be local or on hardware. A clear request gets a clear plan from the agent, and it makes it easier to review what will be submitted.
- Build a two-qubit Bell state in Qiskit and sample it locally with 1024 shots.
- Write a Qiskit Estimator example that measures a ZZ observable on a parameterized circuit.
- Simulate this circuit with a noise model using Qiskit Aer and compare with the ideal result.
- Transpile my circuit for an IBM backend with optimization level 1 and show the layout.
- Check my Python environment for Qiskit and Runtime compatibility before we start.
Run a local example first
Ask the agent to start locally. The skill's quick local sampling example builds a two-qubit circuit, measures it, and runs it on the StatevectorSampler from qiskit.primitives. The measurement counts are read by register name. measure_all() creates a register called meas.
Local runs need no IBM account and submit nothing to hardware, so they are the safest way to check logic before you move to a QPU.
- Sampler V2 keeps shots and classical register structure.
- For circuits with several classical registers, use SamplerPubResult.join_data with an explicit register order when you need joint bitstrings.
- Estimator circuits should not contain final measurements.
from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()
sampler = StatevectorSampler(seed=7)
pub_result = sampler.run([circuit], shots=1024).result()[0]
counts = pub_result.data.meas.get_counts()
print(counts)Move to IBM hardware safely
Running on a real QPU requires your IBM Quantum Platform credentials. The skill's examples are written so the API key is never embedded in code or printed. The skill says to save credentials securely, as described in its setup reference.
The skill's hardware examples submit real jobs. Ask the agent to show you the backend it chose, the transpiled circuit and the shot or precision settings before it submits. Save the job ID before waiting for results so you can retrieve the job later. A dry_run call is still a server submission that returns randomized mock data, so it is not a local simulation.
- Pick the backend deliberately; the example uses least_busy with simulator=False.
- Transpile the circuit for that backend before running it.
- Apply the layout to every Estimator observable with observable.apply_layout(isa_circuit.layout).
- Record finalized options and usage for later review.
- Do not transpile inside an optimizer loop; transpile once and pass parameter arrays.
Safety notes: scripts and network access
This skill runs scripts and uses the network. The skill's scripts include a check_environment.py, an inspect_runtime.py for IBM backends and a run_local_primitives.py for local examples. Read a script before you let the agent run it, especially any that touch your IBM account.
Error mitigation is not guaranteed to improve every result and it increases cost. Open-system dynamics and differentiable quantum machine learning are outside the skill's focus, and the skill itself recommends QuTiP or PennyLane for those.
- Never paste your API key into a chat or a file in the project.
- Review scripts before running them, and keep hardware runs small until results look right.
- Use local simulators for development, and reserve QPU time for runs you have checked.
What people use it for
- Teaching a Bell state or GHZ state experiment with local sampling and counts
- Comparing ideal and noisy results for a circuit using Qiskit Aer
- Estimating a Hamiltonian expectation value with a parameter sweep on a local Estimator
- Preparing a circuit for a specific IBM backend and reviewing its layout before a hardware run
- Running a small, reviewed batch of jobs on IBM quantum hardware to move code from simulation to hardware
Frequently asked questions
How do I install the qiskit agent skill?
Download the skill ZIP from this page and unzip it. Place the qiskit folder in ~/.claude/skills/ for personal use or in a project's .claude/skills/ folder, or upload the ZIP in the Claude apps under Settings, then Capabilities, then Skills.
What do I need to use the qiskit skill?
You need Python 3.10 or newer and the qiskit package for local work. Noisy simulation needs qiskit-aer, and real IBM hardware needs qiskit-ibm-runtime, network access, an IBM Quantum Platform account and an API key.
Is the qiskit skill free to use?
The directory lists the skill's licence as MIT, but the SKILL.md file declares Apache-2.0, so check the LICENSE file in the source repository before you reuse the code. The source does not state prices for the Qiskit SDK or IBM quantum hardware, so check IBM's terms for any QPU access costs.
Do I need an IBM Quantum account?
Not for local simulation with the StatevectorSampler, StatevectorEstimator or Qiskit Aer. You need an IBM Quantum Platform account and API key only for running on IBM quantum processors.
What is the difference between qiskit and qiskit-ibm-runtime?
qiskit is the core SDK for building, transpiling and simulating circuits locally. qiskit-ibm-runtime connects to IBM quantum hardware and provides the Runtime Sampler and Estimator used for QPU jobs.
Should I use this skill or another tool for quantum machine learning or open-system dynamics?
For open-system or master-equation dynamics, the skill recommends QuTiP. For differentiable quantum machine learning, it recommends PennyLane unless you specifically need Qiskit integration.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use the qiskit skill if you are a developer, student or researcher who wants an agent to write and check Qiskit code, test it on local simulators and then prepare it for IBM hardware. Pick another tool if you only need open-system dynamics or differentiable quantum machine learning, or if you want hardware runs without an IBM account.
Download the skill