diff --git a/README.md b/README.md
index e3ab8aac94ff..491775224dd6 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ To install from source, follow the instructions in the [documentation](https://d
 Now that Qiskit is installed, it's time to begin working with Qiskit. The essential parts of a quantum program are:
 1. Define and build a quantum circuit that represents the quantum state
 2. Define the classical output by measurements or a set of observable operators
-3. Depending on the output, use the primitive function `sampler` to sample outcomes or the `estimator` to estimate values.
+3. Depending on the output, use the Sampler primitive to sample outcomes or the Estimator primitive to estimate expectation values.
 
 Create an example quantum circuit using the `QuantumCircuit` class:
 
@@ -48,22 +48,22 @@ Create an example quantum circuit using the `QuantumCircuit` class:
 import numpy as np
 from qiskit import QuantumCircuit
 
-# 1. A quantum circuit for preparing the quantum state |000> + i |111>
-qc_example = QuantumCircuit(3)
-qc_example.h(0)          # generate superpostion
-qc_example.p(np.pi/2,0)  # add quantum phase
-qc_example.cx(0,1)       # 0th-qubit-Controlled-NOT gate on 1st qubit
-qc_example.cx(0,2)       # 0th-qubit-Controlled-NOT gate on 2nd qubit
+# 1. A quantum circuit for preparing the quantum state |000> + i |111> / √2
+qc = QuantumCircuit(3)
+qc.h(0)             # generate superposition
+qc.p(np.pi / 2, 0)  # add quantum phase
+qc.cx(0, 1)         # 0th-qubit-Controlled-NOT gate on 1st qubit
+qc.cx(0, 2)         # 0th-qubit-Controlled-NOT gate on 2nd qubit
 ```
 
-This simple example makes an entangled state known as a [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) $(|000\rangle + i|111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (`h`), Phase gate (`p`), and CNOT gate (`cx`). 
+This simple example creates an entangled state known as a [GHZ state](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) $(|000\rangle + i|111\rangle)/\sqrt{2}$. It uses the standard quantum gates: Hadamard gate (`h`), Phase gate (`p`), and CNOT gate (`cx`). 
 
-Once you've made your first quantum circuit, choose which primitive function you will use. Starting with `sampler`,
+Once you've made your first quantum circuit, choose which primitive you will use. Starting with the Sampler,
 we use `measure_all(inplace=False)` to get a copy of the circuit in which all the qubits are measured:
 
 ```python
 # 2. Add the classical output in the form of measurement of all qubits
-qc_measured = qc_example.measure_all(inplace=False)
+qc_measured = qc.measure_all(inplace=False)
 
 # 3. Execute using the Sampler primitive
 from qiskit.primitives import StatevectorSampler
@@ -73,7 +73,7 @@ result = job.result()
 print(f" > Counts: {result[0].data["meas"].get_counts()}")
 ```
 Running this will give an outcome similar to `{'000': 497, '111': 503}` which is `000` 50% of the time and `111` 50% of the time up to statistical fluctuations.
-To illustrate the power of Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note the Estimator requires a circuit _**without**_ measurement, so we use the `qc_example` circuit we created earlier.
+To illustrate the power of the Estimator, we now use the quantum information toolbox to create the operator $XXY+XYX+YXX-YYY$ and pass it to the `run()` function, along with our quantum circuit. Note that the Estimator requires a circuit _**without**_ measurements, so we use the `qc` circuit we created earlier.
 
 ```python
 # 2. Define the observable to be measured 
@@ -83,7 +83,7 @@ operator = SparsePauliOp.from_list([("XXY", 1), ("XYX", 1), ("YXX", 1), ("YYY",
 # 3. Execute using the Estimator primitive
 from qiskit.primitives import StatevectorEstimator
 estimator = StatevectorEstimator()
-job = estimator.run([(qc_example, operator)], precision=1e-3)
+job = estimator.run([(qc, operator)], precision=1e-3)
 result = job.result()
 print(f" > Expectation values: {result[0].data.evs}")
 ```
@@ -96,17 +96,17 @@ The power of quantum computing cannot be simulated on classical computers and yo
 However, running a quantum circuit on hardware requires rewriting to the basis gates and connectivity of the quantum hardware.
 The tool that does this is the [transpiler](https://docs.quantum.ibm.com/api/qiskit/transpiler), and Qiskit includes transpiler passes for synthesis, optimization, mapping, and scheduling.
 However, it also includes a default compiler, which works very well in most examples.
-The following code will map the example circuit to the `basis_gates = ['cz', 'sx', 'rz']` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map =[[0, 1], [1, 2]]`.
+The following code will map the example circuit to the `basis_gates = ["cz", "sx", "rz"]` and a linear chain of qubits $0 \rightarrow 1 \rightarrow 2$ with the `coupling_map = [[0, 1], [1, 2]]`.
 
 ```python
 from qiskit import transpile
-qc_transpiled = transpile(qc_example, basis_gates = ['cz', 'sx', 'rz'], coupling_map =[[0, 1], [1, 2]] , optimization_level=3)
+qc_transpiled = transpile(qc, basis_gates=["cz", "sx", "rz"], coupling_map=[[0, 1], [1, 2]], optimization_level=3)
 ```
 
 ### Executing your code on real quantum hardware
 
 Qiskit provides an abstraction layer that lets users run quantum circuits on hardware from any vendor that provides a compatible interface. 
-The best way to use Qiskit is with a runtime environment that provides optimized implementations of `sampler` and `estimator` for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements `qiskit.primitives.BaseSamplerV2` and `qiskit.primitives.BaseEstimatorV2` interfaces. For example,
+The best way to use Qiskit is with a runtime environment that provides optimized implementations of Sampler and Estimator for a given hardware platform. This runtime may involve using pre- and post-processing, such as optimized transpiler passes with error suppression, error mitigation, and, eventually, error correction built in. A runtime implements `qiskit.primitives.BaseSamplerV2` and `qiskit.primitives.BaseEstimatorV2` interfaces. For example,
 some packages that provide implementations of a runtime primitive implementation are:
 
 * https://github.com/Qiskit/qiskit-ibm-runtime