Site-Directed Mutagenesis

Pick a coding sequence, state the change you want, and get the mutagenesis primers for it.

What it doesCopy Anchor Link

You point it at a coding sequence, say which residues you want changed, and it designs the oligonucleotides that make the change — with the melting temperature, GC content, hairpin and dimer energy of every primer it proposes, and the exact position each one binds on your plasmid.

It covers seven jobs that are usually seven separate tools: single substitutions (Mutate), degenerate codon libraries (Library), saturating one residue to all 20 amino acids (SSM), changing several residues in one reaction (QCLM), walking a whole gene one codon at a time (Tiling), insertions and deletions (Indel), and removing a restriction site without changing the protein (Scrub).

When you’d use thisCopy Anchor Link

• You want to test whether one residue matters. Mutate. One substitution, a QuikChange-style primer pair, and the edge cases handled when the site sits near the start of the gene.
• You want every amino acid at one position. SSM — it saturates the codon and matches the overlap and 3′ melting temperatures across sites so a single reaction condition works for all of them.
• You want several changes in one reaction. QCLM. Substitutions close enough together share one oligo; the rest get their own.
• You want a designed library, not a saturation. Library, where you choose which amino acids appear at each position and it finds the degenerate codons that cover them.
• You need to remove a restriction site before cloning. Scrub changes the DNA and not the protein, and tells you which sites are actually present first.

The usual route is: pick the CDS → design → check the melting temperatures and dimers → place the primers on the map → export the order list.

What this computesCopy Anchor Link

The change itself, before any oligo: the wild-type codon and the one that replaces it (ACC → TAT), its nucleotide position in the CDS, and how many nucleotides differ — the number that decides whether one primer pair can install it at all. A wild-type letter that does not match the sequence is reported with what is actually there, because that is almost always an off-by-one between numbering conventions rather than a typo.

Per candidate primer pair (several are returned, ranked, never one):

• Length, melting temperature and GC% of each strand, under the Tm model you chose
• A score, which is the ranking, and the arm sizes either side of the mutation — with the short-arm flag (under 45 — short arm) that says which candidate is geometrically weak even when its temperature looks fine
• Four thermodynamic energies per strand, in kcal/mol — ΔG fold, hairpin, self-dimer and cross-dimer, plus 3′-end stability — each one clickable, opening the structure it refers to rather than leaving you with a number
• The outer pair, Type IIS-tailed (BsaI by default), for the SOE assembly the inner pair feeds

The reading itself, in words, generated from the design rather than from a template: which codon was installed and how many bases that took, the best pair's length, melting temperature and GC, and — only when the design earned them — the cautions that would change what you order. A primer that folds on itself or self-dimerises past the energies the ranking penalises is still offered and still ranked first if it scores best, so the reading says so rather than letting the rank imply the structure is harmless. A design with a single surviving candidate says that too, because there is then no second choice if the first fails at the bench.

Why a design was refused, when one is. A scan that finds no usable primer pair is a real answer, and the reason matters more than the refusal: the classical message blames the ends of the coding sequence, and for a residue in the middle of a gene that is almost never what happened. The readout reports what the search actually saw — how many candidate primers were considered, how many fell inside the melting-temperature window, how many inside the GC band, and whether any single primer cleared both at once. Those are different failures with different fixes. The temperature window is calibrated for a nearest-neighbour Tm, so a candidate set judged on the 2·AT+4·GC rule of thumb can be rejected wholesale by a ceiling that was never meant for that scale — in which case the melting model, not the site, is what to change.

Per tab, the question changes and so do the readouts. Every tab states, in words generated from its own run, what it decided and what that costs:

• Saturation (SSM) — the one overlap and 3′-end melting temperature the whole reaction settled on, how far that is from the optimum you aimed at, and which sites fall outside a window you set. Sites outside their window are the ordinary price of designing every site for a single tube, not a failed design, and the reading says so rather than leaving a warning mark to be read as an error.
• Multi-site (QCLM) — the amino-acid coverage achieved, which constraints any returned primer breaks, and the seed, because the codon cover is drawn rather than derived and the same request with another seed gives different oligos.
• Library — the diversity, and the gap between what you asked for and what you get: the amino acids a degenerate codon drags in unasked, which you will screen whether you wanted them or not, and any requested residue no codon in the table can reach. Whether a stop codon is reachable is called out, because that part of the library is truncated protein rather than a variant.
• Tiling — the melting-temperature span across the whole set, and the fact that each primer is designed alone: nothing matches them to a shared reaction temperature, so a wide span means pooling by temperature or running in batches rather than one programme for all of them.
• Indel — the net change in bases and whether it is a whole number of codons. Addressing the edit in residues is what makes the reading frame safe by construction, and the product is a blunt, linear whole-plasmid amplicon that needs re-circularising before transformation.
• Scrub — which sites it removed and in which codons, and the guarantee the whole tab rests on: every substitution is synonymous, so the translated protein is identical. It also states the cost that guarantee hides — a synonymous swap can pick a rarer codon, so expression can shift even though the protein does not — and that only the sites in the set you chose were ever searched for.

Per variant, once a library exists: a language-model score in nats for every substitution the library reaches, under the scoring strategy you chose, with the number of forward passes that took. The score is a likelihood ratio and never a stability measurement; the section below says what it is and is not for.

What it does not compute: whether the variant is good. Nothing here predicts stability, activity or expression — a designed primer is a molecule you can order, not a prediction that the protein will fold.

Where it livesCopy Anchor Link

Tools → Site-Directed Mutagenesis, from the command palette, or by right-clicking a CDS feature on the map — which opens the panel already pointed at that gene.

Picking a coding sequence selects it on the map, so you can always see what you are about to act on. When you add designed primers to the map they become real annotations at their true coordinates, and the view jumps to the first one.

Inputs and outputsCopy Anchor Link

In: any sequence the editor can open, circular or linear, with a coding feature — or a selection you make yourself, which it will treat as a CDS. Changes are written the way you would say them: Y66F (residue 66, tyrosine to phenylalanine), or protein-level HGVS such as p.Ala120_Lys125del.

Out: primer sequences with length, melting temperature, GC content, folding energy, hairpin and self-dimer energy, and — for a pair — cross-dimer and 3′-end stability. Primers can be placed on the map or exported as CSV.

What it refuses, and what it says. Nothing fails silently:

• The target is not a whole number of codons → "…is 721 bp, not a multiple of 3 — its codons cannot be addressed."
• A position past the end of the gene → "Position 9999 is outside neomycin phosphotransferase (1-264 residues)."
• Settings that cannot produce a primer → the arithmetic is named, e.g. "Max primer size (12) is below the smallest legal primer (23 nt = 10 + 3 + 10)."
• No codon clears your rarity threshold → "No codon for 'F' is above the usage threshold 0.99 — lower it, or pick a usage table that covers this amino acid."

The wild-type letter is checked against your sequence, and a mismatch is refused. If you write Y66F on a gene whose residue 66 is threonine, it tells you: "Position 66 is T (ACC), not Y (Y is at 67)" — the residue that is really there, the codon it is spelled with, and the nearby position that does carry the letter you typed. That last part is the useful half, because a mismatch is almost always an off-by-one between numbering conventions: a construct carrying an extra N-terminal residue shifts every number by one relative to the numbering in the literature.

All three designers refuse it — single substitution, saturation and multi-site alike, whether you reach them through the panel, the assistant, a workflow, the HTTP API or MCP. Saturation and multi-site designs used to warn and run on the grounds that the chemistry stays valid. It does, and that is not the same as the answer being right: saturation would report the site under a residue your sequence does not carry there, and multi-site is worse. Every multi-site request carries the unchanged codon as a library member, and that member's codon is read off your template rather than from the letter you typed — so a wrong letter comes back as an extra oligo, labelled with a substitution you never asked for, whose bases are identical to your template. It is reported as a successful design and it mutates nothing.

DemoCopy Anchor Link

Not recorded yet. A screencast belongs here and does not exist. The worked example above is a real run on a bundled starter, reproducible number for number.

Worked exampleCopy Anchor Link

One substitution on a real plasmid, start to finish. Open the Site-directed mutagenesis sample project and pick CVU55762 — the cloning vector pEGFP-N1, 4,733 bp, circular.

1. Choose the gene. Target CDS → egfp (720 bp). The panel reports `720 bp · 239 aa ·

   • strandand the map selects the gene,679–1,398`, so you can see what you are about to change.

2. Say what you want. Type A207K — alanine 207 to lysine, the substitution that stops EGFP dimerising at high concentration.

   Why 207 and not 206? The mutation is called A206K in the literature. This construct carries an extra residue near the N-terminus, so every number is shifted by one: its residue 206 is serine and the alanine is at 207. Typing A206K here is refused with "Position 206 is S (AGC), not A (A is at 207)" — which is the tool telling you your numbering does not match this sequence, and where the alanine you meant actually is, not that the mutation is wrong. This is the single most common mistake in mutagenesis design, and it is caught before a primer is made rather than after an order arrives.

3. Design. The result reads GCC → AAA at nt 619, three nucleotide changes — a whole-codon swap rather than the minimum edit, because lysine has no codon one base away from GCC.

4. Read the primers. Five candidate pairs come back, ranked. The best is 26 nt, Tm 59.4 °C, GC 50%, score −0.55:

   Copy Text

   FWD  AGTCCAAACTGAGCAAAGACCCCAAC
   REV  GTTGGGGTCTTTGCTCAGTTTGGACT

   Under each pair are the numbers that decide whether it will work at the bench, per strand: folding ΔG −0.3, hairpin 0.2, self-dimer −2.8, cross-dimer −28.2 and 3′-end stability −28.2 kcal/mol. The second-ranked pair is one base longer at Tm 60.1 °C but folds harder (−2.2) and forms a stronger self-dimer (−3.0) — which is what the ranking is weighing.

5. Place them. Add to map writes the primers as real annotations at their true coordinates and jumps the view to the first one, so the design lives in the record rather than in a table you copy out of.

ControlsCopy Anchor Link

Nothing in this panel is a fixed default you cannot see. The controls common to every tab:

• Target CDS — any coding feature on the open sequence, or your own selection. Picking one selects it on the map; right-clicking a CDS on the map opens the panel already pointed at it.
• Codon table — which organism's codon usage chooses the replacement codon. Two tables ship with the tool, and any table you resolve in the Codon Usage tool appears here as a third.
• Melting-temperature model — SantaLucia nearest-neighbour by default, the GC-based formulas that particular published methods were calibrated against, or the editor-wide Tm conditions (model, buffer, salt, magnesium) so every tool in the workbench agrees on one number.

Every candidate also carries, without a control to switch on: the four structure energies (each one clickable, opening the structure itself), and the two arm scores described below.

Per tab, beyond those:

• Mutate — the substitution itself, written as Y66F or as protein-level HGVS, and a batch list for many at once.
• SSM — the sites to saturate, the degenerate codon (a preset such as NNK — all 20 amino acids and one stop in 32 codons — or your own, or several comma-separated for a mixed order), the flanking primer pair that sets the 3′ melting-temperature window, whether the forward and reverse 3′ temperatures are optimised independently, whether you set that window yourself, and whether hairpins and dimers are penalised during the search (slower, roughly doubles the run).
• SSM / QCLM, under Show geometry, temperatures and score weights — minimum, optimum and maximum primer size, 5′ and 3′ arm sizes, overlap size, the temperature scan bounds, the GC window, every scoring weight, the codon-rarity threshold and the oligo name prefix.
• QCLM — the substitution list, and a seed, because the published method draws its mutagenic codons at random: the same seed reproduces the same oligos, which is how you re-derive a primer you have already ordered.
• Tiling — the start primer length (odd, since the flanks are (n−3)/2 per side) and the melting temperature window to hold across the walk.
• Indel — insert, delete or replace, and the residue range it applies to.
• Scrub — which restriction sites to remove; it lists the ones actually present in your sequence first.

What the library will actually containCopy Anchor Link

The Library tab reports the degenerate codons it chose and, under them, a grid: one row per amino acid, one column per saturated site, and in each cell how many DNA codons of that site's set produce that residue.

That count is the library's real composition, and it is what a screen is planned from. A site covered by NNK reaches Leu through three codons and Trp through one, so 96 colonies give you roughly nine Leu and three Trp — the set of residues alone cannot tell you that, and a screen sized from the set will under-sample exactly the rare ones. A hatched cell means the site cannot reach that residue at all, which is a different statement from "zero copies of something it can".

Stops appear as their own row when the chosen codons can produce one, because the screen will see them whether or not the table mentions them.

Keeping a library after you close the tabCopy Anchor Link

Save library writes the design into your project as a document and opens it. It is a real file: it is there after a reload, it appears in the file list, and you can send it to someone.

What it keeps is more than the sites. A library is a list of residue positions, and residue positions are numbered within a protein — so the record carries the coding sequence it was designed against, its length in residues, which strand it is on, and when you designed it. Without those, a saved list of positions is unusable the moment it leaves the session that made it, and worse than unusable if it is opened against a different protein.

Reopening it shows the target and the date, the diversity and the number of primer codon sets, and one row per site: the wild-type residue and its codon, what you asked for, the degenerate codons chosen, anything those codons also encode, and how many residues the site actually reaches. A site whose codons can produce a stop says so, because a stop is a truncated variant your screen will see.

If a record cannot be read in full it is refused by field name rather than partly loaded. These are files people hand-edit and pass around, and "could not parse" tells you nothing about which line to look at.

Which variants a protein language model thinks are badCopy Anchor Link

Once the Library tab has a designed set, it can rank it. Each substitution is scored by a protein language model — ESM-2, trained on UniRef and used here exactly as its authors published it for this purpose — which answers one question per site: given the rest of this protein, how likely is this residue here? The score is the difference between the mutant and the wild type, in nats. A negative number means the model finds the substitution less ordinary than what nature put there; the more negative, the more unusual.

This is a ranking, not a measurement. It is not a ΔΔG, it carries no kcal/mol, it is not calibrated against any assay, and it says nothing about your assay's readout. What it is good for is ordering a list you were going to screen anyway, so the variants a language model finds most surprising get a well early rather than at position 380. Every readout on the panel says this in words, in every mode, because the number is easy to mistake for a stability prediction.

Three ways to compute it, and they answer slightly different questions.

• Masked marginals hides the site before asking, so the model cannot see the residue it is being asked about. This is the strategy the method's authors recommend, and it costs one pass per residue in the protein — not per variant, so scoring one substitution and scoring four hundred cost the same.
• Wild-type marginals asks once, over the unmodified sequence. One pass in total, and the original paper reports it as the weaker of the two.
• Pseudo-perplexity scores the whole mutant sequence rather than one position. It is the expensive one by two orders of magnitude — one pass per residue per variant — and its numbers are comparable only to each other, never to a marginal score.

The panel states the cost before you start: how many forward passes the run will take, and how large the model is to download the first time. Three model sizes are offered, from a small one that ranks in seconds to the one the zero-shot papers report; the weights are fetched when you first ask for them and cached afterwards, and the download size is on the option so the choice is yours rather than a default made for you.

A caution worth stating plainly: these models rank evolutionary plausibility. A substitution your protein has never needed can be perfectly functional, and a conserved residue can be conserved for a reason your experiment does not care about. Read the ranking as a screening order, not as a verdict.

Algorithms you can chooseCopy Anchor Link

Seven tabs, and they are seven different questions — not seven settings of one. Which one you want is decided by what you are making, so nothing here is a "default method":

Within the Mutate tab the choices are the model, not the method:

• The melting-temperature model — SantaLucia nearest-neighbour (the default), the GC-based formulas particular published protocols were calibrated against, or the editor-wide Tm conditions so this panel, the primer designer and the Tm tool all report one number for one oligo. Changing it moves which candidate ranks first, which is why it is on screen rather than buried.
• The codon table — which organism's usage picks the replacement codon. Two ship built in, and any table you resolve in Codon Usage appears here as a third. It changes the codon installed, not the residue.
• How the change is written — Y66F or protein-level HGVS (p.Tyr66Phe), and a batch list for many at once. Both parse to the same thing.

Candidates are ranked, not chosen for you. A run returns several inner pairs with their scores, and the one marked best is a ranking, not a verdict — the arm scores and the structure energies beside it are what you overrule it with.

Bring your own: mutDesignInner and mutDesignOuter in @ports/mutagenesis are plain functions over a CDS string, callable from the Python and JavaScript consoles with no editor state.

The scienceCopy Anchor Link

Primer design balances several competing constraints at once: each oligo must melt in the right window, carry enough correctly-matched sequence on both sides of the change to bind, avoid folding back on itself, avoid pairing with its partner, and sit in a sensible GC range. The solvers here search that space explicitly — for multi-site designs, over every legal way of splitting the requested sites between oligos — and score each candidate on melting temperature, length, 3′ and 5′ arm size, GC content, coverage of the amino acids you asked for, and hairpin and dimer penalties. Every one of those weights is a control you can change.

Melting temperatures come from a nearest-neighbour model with salt and magnesium corrections (SantaLucia by default) or, where the published method requires it, the GC-based formula that method was calibrated against. Hairpin, homodimer and heterodimer energies are real thermodynamic calculations, not heuristics.

On correctness: the design engines are checked byte-for-byte against the original published implementations — every melting temperature, every primer, every field — and the codon-usage tables are checked against every record rather than a sample. Cut sites used by the Scrub tab are checked against REBASE.

Reading a primer's secondary structureCopy Anchor Link

Every primer the tool proposes carries four energies: how strongly it folds back on itself (hairpin), how strongly two copies of it stick together (self-dimer), how strongly it sticks to its partner (cross), and how strongly it does so at its own 3′ end (3′ end). The last is the one that matters most and the one a whole-oligo check can miss: a strong pairing in the middle of two primers is largely harmless, while a weak one at the extendable 3′ end is what actually primes off-target.

Each of those four numbers opens the structure it is describing. Click it and you get the alignment itself — which bases pair with which, drawn the way the thermodynamic engine found them:

Click any energy to see the structure behind it. Here the two overlapping mutagenic primers pair along their whole 22-base length — which is what −26 kcal/mol means, and why that number is expected rather than alarming for a QuikChange pair.

A hairpin in an outer primer: a four-base stem closing a loop. The tics mark the paired bases; the base drawn at the apex is the unpaired one at the top of the loop.

Reading the structure is what turns a number into a decision. A −3 kcal/mol self-dimer spread thinly across the middle of an oligo is usually fine; the same −3 concentrated on the last four bases of the 3′ end is not, and the two are indistinguishable until you look. Where no structure exists at all, the panel says so in words rather than showing an empty box — for a primer, that is the best possible answer.

Do both arms of the primer actually bind?Copy Anchor Link

A mutagenic primer has to hold the template on both sides of the change it carries. Its melting temperature is computed over the whole oligo, so a primer can land exactly on target overall while one of its two arms is too short, or too AT-rich, to anneal on its own.

The panel therefore reports each arm separately, as arms x / y — the 5′ arm and the 3′ arm, scored on the same scale an independent published QuikChange designer uses, which asks for more than 45 on each. Anything below is flagged:

Five candidates for T66S, all within a degree of the 60 °C target — and every one with a 3′ arm well under the threshold. The flag is information, not an error.

This is deliberately a second opinion, not a filter. The ranking you see is the published method's own, reproduced faithfully; the arm scores are the other method's criterion shown beside it. They often disagree, and the disagreement is the useful part: a 21-base primer wrapped around a 3-base codon simply cannot give both arms twelve bases, so choosing a longer primer to satisfy both criteria is a trade against melting temperature that only you can make. Lengthen the primer if your template is AT-rich around the site, or if a first attempt fails at the bench; keep the shorter, on-target design otherwise.

LimitationsCopy Anchor Link

• Multi-site designs draw their codons at random. The published method picks mutagenic codons by random sampling, so the same request has many valid answers. Every design therefore carries a seed: the same seed reproduces the same oligos, which is what lets you re-derive a primer you already ordered. Asking for another design may legitimately return the same one — where a single degenerate codon is both the most specific and the most common choice, every seed finds it.
• The organism's codon usage applies only to the non-degenerate path. With codon collapsing on, the degenerate solution uses the E. coli table whichever organism is selected. This is the published method's behaviour, reproduced deliberately, and the panel says so next to the control.
• Codon-usage tables are offline snapshots. Two ship with the tool; the authority is Kazusa/NCBI, and a table fetched in the Codon Usage tool appears here as a third option.
• Variant effect is not predicted. The tool designs the library; it does not rank which substitutions will help. No stability or fitness score is shown, because showing an approximated one would be inventing a number.
• The insertion/deletion designer is clean-room, not a port of an existing tool, and says so.
• The arm scores apply to the mutagenic primers only. The outer primers carry no change, so they have no two arms to score, and the column is left empty for them rather than filled with a zero. The independent method the criterion comes from designs whole-plasmid substitutions only, so it offers no opinion at all on the overlap-extension half of a design.

Compared with other toolsCopy Anchor Link

Sources, first-party and dated: https://www.snapgene.com/features, retrieved 2026-08-08, quoted verbatim; https://www.geneious.com/features, same date, which does not name mutagenesis among its cloning tools.

What SnapGene has that this does not: its mutagenesis sits inside a mature cloning workflow with decades of vector handling around it, and "add a restriction site" is a first-class operation there while here it is the inverse (Scrub removes sites) plus a manual edit. Read the blanks honestly — "not listed" is what the vendor's own page says, not a measurement of the product, and neither is runnable here to check.

ExportCopy Anchor Link

• Add primers to map — the selected pair becomes real annotations at their true coordinates, so they live in the record, in its version history, and in whatever you export it as. Nothing is written until you press it; the panel is a proposal until then.
• Apply point mutation to sequence — the separate, explicit act of changing the molecule itself. Designing primers never edits your sequence, and this is why the two are different buttons. It rewrites only the bases that change, so the CDS annotation it acts on survives the edit and the next mutation can be designed against the same feature. The same is true of the silent scrub, which typically alters a handful of bases scattered across the gene.
• All primers CSV — every candidate, not just the selected one: sequence, length, Tm, GC, the score, the arm sizes and the four thermodynamic energies per strand. A batch list exports as one file across every mutation in it.
• Copy — each sequence on its own, forward or reverse, from the copy button on its row.
• The outer pair travels with the inner one, so a SOE assembly can be ordered from a single export rather than reconciling two.

APICopy Anchor Link

@ports/mutagenesis — the design, over plain strings:

import { mutParse, mutDesignInner, mutDesignOuter, mutExtractCds } from '@ports/mutagenesis';

const [wtAa, pos1, mutAa] = mutParse('T66Y');      // also accepts p.Thr66Tyr
const inner = mutDesignInner(cds, pos1, mutAa, wtAa);
// inner.mut_codon 'TAT' · inner.wt_codon 'ACC' · inner.nt_position · inner.nt_changes 3
// inner.candidates[] → sequence, length, Tm, GC, score, arm sizes, structure energies
const outer = mutDesignOuter(cds, /* Type IIS tail */);

mutExtractCds pulls the coding sequence out of a record in frame, mutTranslate and mutRevcomp are the same helpers the panel uses, and thermodynamics are injectable (MutThermo): the panel feeds it the app's SantaLucia model from @ports/tm, and the port's own default is SpliceCraft's deterministic Wallace fallback so a call with nothing supplied is still reproducible.

A wild-type letter that does not match the sequence is reported, not ignored — the position and what is actually there — because that mismatch is almost always an off-by-one between numbering conventions rather than a typo.

AutomationCopy Anchor Link

• Workflow DAG: the node is design_mutagenesis_primers, category design. It is a write node, so it goes through the approval gate before it runs. Inputs are cds (the coding sequence, in frame from the start codon) and mutation written as [WT][pos][MUT] — W140F, 1-based residue.
• Outputs: mutCodon (the codon installed), wtCodon (the one replaced), ntPosition (0-based nucleotide offset of the changed codon), ntChanges (how many nucleotides differ) and candidates (the inner pairs with their Tms). A missing cds or mutation is refused by name, saying which one to provide.
• The copilot calls the same tool with the same parameters, and the same approval gate applies.
• Batch is the panel's own path today: a batch list designs every substitution in one run and exports them as one CSV. The SSM and QCLM tabs have no pipeline step at all — a known gap, stated here rather than left as a surprise.

ProvenanceCopy Anchor Link

Two acts, two records. Designing primers changes nothing: the panel proposes, and Add primers to map is what writes annotations into the record. Apply point mutation to sequence is the other, separate act, and it is the one that edits the molecule — so a design session leaves no trace on your sequence unless you asked it to.

Once either lands it is an ordinary edit, carried by the record's own step log and version history: restoring a version brings back exactly the primers or the base change that was applied, and the history entry names the mutation it came from.

The reading beside a result describes the run that produced it, not the panel as it now stands. Change the Tm model or the codon table after a design and the numbers do not silently re-label themselves: they keep the model and table they were computed under, and a line says the controls have moved since. This matters more than it sounds. The same 28-mer is 60.1 °C on the nearest-neighbour scale and 79.4 °C on the QuikChange GC formula — a gap wide enough to move it from inside the designer's accepted temperature window to outside it — so a figure quoted under the wrong model is not a rounding difference but a different answer.

What makes a run reproducible is on screen: the CDS and its length, the substitution as written, the codon table that chose the replacement codon, and the melting-temperature model. Given those the design is deterministic — with one exception the panel is explicit about: QCLM draws its mutagenic codons at random and therefore carries a seed, and the same seed reproduces the same oligos, which is how you re-derive a primer you already ordered.

Citing the method: the SOE-PCR/QuikChange design is a port of SpliceCraft (SC-07), with melting temperatures from the model you selected; SSM and QCLM are ports of Mutation Maker (Merck, GPL-3). Name the method, the Tm model and the codon table — those are what another lab needs to re-derive the same primers.

ScreenshotsCopy Anchor Link

T66Y on the 720 bp egfp CDS of CVU55762: the change stated first (ACC → TAT at nt 196, 3 nt changes), then five inner pairs ranked by score — #1 at Tm 60.3 / GC 60% / 25 nt / s1.44 against #4 at s6.78 — each with its arm sizes, its short-arm flag, and both strands' ΔG fold, hairpin, self-dimer, cross-dimer and 3′-end energies. Every energy is a link to the structure behind it, and neither the primers nor the mutation touch the record until the two buttons above say so.

The panel as it opens.

The indel tab.

The library tab.

The mutate tab.

The scrub tab.

The wild-type check, before the run. Y66F N68D T108K is a reasonable-looking request that is wrong for this construct: its residue 66 is threonine, 68 is glycine, and 108 is already lysine. The classic chromophore numbering is shifted by one here, so the message names the residue really present and the position that does carry the letter you typed, and the design is refused rather than run.

Nothing is hidden: primer geometry, the temperature scan, the melting-temperature model, salt and magnesium, the GC window, all eight scoring weights, the codon rarity threshold and the oligo name prefix are controls, not fixed defaults.

The worked example above, on screen. The gene is selected on the map while you work on it, the result names the codon change and its position, and each candidate pair carries its melting temperature, GC, length and the four thermodynamic numbers that decide whether it will behave.

Site validation before the run. Y66X T203X are both well-formed sites whose wild-type letters do not match this construct, and each is named with the residue really there, its codon, and the neighbouring position that does carry the letter typed: 66 is T and the tyrosine is at 67; 203 is S and the threonine is at 204. Design 2 sites is disabled. A malformed site (145, naming no residue at all) is refused separately and says so about the letter rather than the number, so the two kinds of mistake never get one diagnosis. Neither is discovered by an empty results table.

RelatedCopy Anchor Link

In this group: Restriction Digest · Ligation · Gibson Assembly · Golden Gate Assembly · Grammar Assembly · Assembly Plan · Recombination Cloning · Site-saturation mutagenesis · Multi-site mutagenesis