Clone an insert into a vector, and prove it worked
The route: open the parts → open the vector → assemble → check the product → verify the real construct against it.
This is the workflow the cloning half of the workbench is built around, and every step hands its output to the next without you re-entering anything. It takes about five minutes in the app, and it is the honest version of the loop you run at the bench over a week.
Before you start: you need a vector and an insert that share terminal homology, or a vector you can open with an enzyme. The Gibson test starter in the lobby has both, on real files, and this page uses it so every number below is reproducible.
Step 1 — Get your fragments in
Tool: the lobby, or File → Import.
Open the Gibson test starter. It carries two real files:
| File | Length | What it is |
|---|---|---|
data/samples/Gibson/gibson-vector.fasta | 8,355 bp | A linearized backbone |
data/samples/Gibson/gibson-insert.fasta | 2,283 bp | An insert sharing 40 bp with each vector end |
Your own files work the same way: GenBank, FASTA, SnapGene .dna, EMBL and a dozen others open
directly, and what each format keeps or drops is stated per format.
Check before moving on: the vector should be linear. A circular molecule has no ends, so it has no terminal homology to find — and this is the single most common reason an assembly refuses to run. If yours is a closed plasmid, that is Step 2.
Step 2 — Open the vector (only if it is circular)
Tool: Restriction Digest, or the Linearize control inside the Gibson panel itself.
Pick an enzyme that cuts your backbone once. The picker shows every enzyme's real cut count on the open construct, so you are choosing from what actually cuts rather than from a catalogue.
The trap worth knowing: a complete digest cuts every site, so an enzyme with two sites in your backbone only ever gives you the two arcs. The whole plasmid opened once — usually the piece you want — exists only in the partial digest set. The panel has a Partial digest switch for exactly this, and lists the whole-opened piece flagged.
Check: each resulting piece is listed with its length, the enzyme that made each end, its end structure, and how many features survived. If your insertion site sits inside a feature you care about, you will see it here rather than discovering it later.
→ The Gibson test vector is already linear, so skip this.
Step 3 — Assemble
Tool: Gibson Assembly. (For type-IIS overhangs use Golden Gate; for att sites, Recombination Cloning. The rest of this workflow is the same.)
Opening the panel adds the open project's sequences as fragments automatically — this is what "shared context" means in practice; nothing is pasted.
Flag the vector as the backbone, leave the homology window at 20–80 bp, topology circular, keep vector origin on, and run:
product gibson_test_vector 10558 bp circular
order gibson_test_vector -> gibson_test_insert
junction 1 40 bp Tm 106 °C GC 32.5% at 8235..8274
junction 2 ↺ 40 bp Tm 118 °C GC 47.5% at 10478..10517Read the length first. 8,355 + 2,283 − 40 − 40 = 10,558. Shared sequence appears once in the product, so if your number is the plain sum of the fragments, an overlap was duplicated rather than consumed.
Read junction 2 second. The ↺ marks the junction that closes the circle. A circular product has as many junctions as fragments; a table showing one fewer is missing the closing one.
Do not carry the junction "Tm" to the bench. At 40 bp it reads 106 °C, which no duplex does — it is a length-and-GC score reproduced faithfully from the upstream library's own homology check, not a melting temperature. For a real Tm, that is Melting Temperature.
Check: errors empty. If it is not, each entry names the fragments involved and what to change —
no path through the fragments, an unused fragment, a dead end, or a fragment that forks into two
possible partners. A fragment that cannot reach the others is an error with a reason, never a
silently missing product.
Step 4 — Predict what you should see on a gel
Tool: Restriction Digest → send to gel, or the Gel Bench.
Before you touch a pipette, work out the diagnostic digest that would distinguish a correct clone from an empty vector. Cut the predicted product in silico, send the fragments to the virtual gel, and read the band pattern you are hoping for.
This is the step people skip, and it is the cheapest one: choosing the enzyme here costs a minute, and choosing it after a failed gel costs a day.
Check: the bands are far enough apart to tell apart on the % agarose you will actually run. The gel bench takes the percentage and the ladder, so this is a real prediction rather than a guess.
Step 5 — Verify the construct you actually built
Tool: Sequencing Verification, with Compare to Reference and the Chromatogram viewer.
Your colonies come back as Sanger reads (or a Plasmidsaurus run). Open them and grade them against the construct you designed in Step 3 — not against a sequence you paste in, against the actual product, which is already in the project.
- The chromatogram viewer shows the trace itself: peak heights, quality, mixed/heterozygous peaks where two bases are present.
- Compare to reference aligns the reads against the predicted construct and calls the differences.
- Verification grades the read set against the construct as a whole.
Check: the differences are where you expect (nowhere), and any that are not are real rather than low-quality basecalls. A mismatch in a low-quality region at the end of a read is normally the read, not the clone — the trace is the evidence, which is why the viewer shows it rather than only calling it.
Step 6 — Keep the record
Tool: Provenance.
Opening the assembly product as a new project — the default, and non-destructive — writes a provenance record: which fragments went in, and what came out. That record renders as a lineage tree, a protocol recipe and a step list.
This is the difference between a sequence and a construct: a construct knows what it was made from. Six months later, "what is in this tube" has an answer that is not someone's memory.
Two limits worth knowing: provenance nests by product name, so it does not yet carry an exact link back to the source projects; and a GenBank download carries the features and notes but not the provenance record.
What you did, and where each piece lives
| Step | Tool | Hand-off |
|---|---|---|
| 1 | Import / lobby | Sequences into the project |
| 2 | Restriction Digest | A linear backbone |
| 3 | Gibson Assembly | The predicted construct |
| 4 | Digest → Gel Bench | The band pattern to expect |
| 5 | Verification · Compare · Chromatogram | Reads graded against the construct |
| 6 | Provenance | The lineage |
Nothing in that chain was copy-pasted between tools. Each step read the project's shared context and wrote back into it — which is the design, and the reason this is one workbench rather than six utilities.
If it does not work
| Symptom | Where to look |
|---|---|
| Assembly refuses: "circular backbone" | Step 2 — open the plasmid first |
| Assembly refuses: no path / unused fragment / forking | The error names the fragments. Usually a missing or too-short overlap; check the per-fragment homology readout under each row before running |
| Product length is the plain sum of the fragments | An overlap was not consumed — check the homology window is not larger than your real overlap |
| More than one product | Not a failure. Two fragments share compatible ends; every construct is listed and you pick |
| Fragments have no homology at all | You need primers with tails — the Gibson panel designs them, and so does the Primer Designer |
Related
The tools, in depth: Gibson Assembly · Restriction Digest · Gel Bench · Sequencing Verification · Provenance
The alternatives at step 3: Golden Gate for type-IIS overhangs · Grammar Assembly for MoClo/GoldenBraid hierarchies · Recombination Cloning for Gateway att sites.
The canvas all of this draws on: the sequence map.