Generative models for protein design have matured rapidly. RFdiffusion, BindCraft, and Boltzgen can produce thousands of candidate backbones and sequences in hours. But generating designs is not the hard part. The hard part is knowing which ones will actually fold, bind, and express.
Most computational protein design campaigns fail not because the generative model was wrong, but because the pipeline between computation and experiment was incomplete. This post covers what that pipeline looks like when it works, and where it breaks down.
Generative Design Is Necessary but Not Sufficient
RFdiffusion generates protein backbones through a denoising diffusion process conditioned on a target structure. For binder design, you define a target surface (hotspot residues on your antigen), and the model generates backbone geometries predicted to make contacts at those positions. BindCraft takes a different approach: it optimizes sequences directly against an AlphaFold2 confidence objective, producing binders that are jointly optimized for structure and binding.
Both methods work. Published benchmarks show experimental hit rates in the range of 1% to 15% for naive RFdiffusion campaigns and higher for BindCraft when the target is well suited (rigid, structured epitopes). At Ranomics, we see BindCraft hit rates around 46% after computational filtering, though that number reflects filtered candidates entering experimental validation, not the full generated library.
The failure mode most teams encounter is not that these tools produce bad designs. It is that they produce designs that look good in silico and fail in the lab. The gap between a predicted binding interface and a functional protein is where most campaigns stall.
The Sequence Design and Validation Stack
Once you have a backbone (from RFdiffusion or Boltzgen), you need a sequence. ProteinMPNN is the standard tool here. It takes a fixed backbone and generates amino acid sequences predicted to fold into that structure. The key parameter is temperature: lower temperatures produce more conservative, higher confidence sequences. Higher temperatures explore more sequence space but increase the risk of misfolding.
After sequence design, you need structure validation. This is where ESMFold, ColabFold, and Boltz-2 come in. The question you are answering is simple: does the predicted structure of my designed sequence match the intended backbone? If your ProteinMPNN output, when folded by an independent predictor, reproduces the target backbone with an RMSD below 1.5 to 2 Angstroms, you have a candidate worth testing. If it does not, the sequence is not encoding the structure you designed.
This “self-consistency” filter is the single most important computational quality gate. Campaigns that skip it waste weeks of experimental time on designs that were never going to fold correctly.
Why Computational Filters Are Not Enough
Even with self-consistency filtering, computed metrics do not capture everything that matters experimentally. A design can pass every in silico filter and still fail to express in your host organism, aggregate in solution, or bind an off-target surface.
Three failure modes dominate:
Expression failure. The protein does not express or is insoluble. Generative models do not optimize for expression. Codon usage, glycosylation sites, and hydrophobic surface patches all affect expression and are largely invisible to structure prediction tools.
Aggregation. The designed protein folds but forms oligomers or aggregates. This is especially common with de novo scaffolds that have exposed hydrophobic surfaces. Solubility predictors catch some of these, but not all.
Off-target binding. The binder contacts the target at the intended interface but also binds other surfaces. Specificity is harder to design than affinity, and most generative models do not explicitly optimize for it.
These failure modes are why experimental validation is not optional. It is the rate-limiting step in every serious design campaign.
Experimental Validation: Yeast Display and Beyond
Yeast display is the workhorse platform for validating computationally designed binders. You express your designed library on the yeast cell surface, incubate with fluorescently labeled target, and sort by binding signal using FACS. In a single experiment, you can screen 10,000+ designs and recover the ones that bind.
The advantage of yeast display is throughput and quantitation. You get binding signal, expression level, and relative affinity data in one experiment. Coupled with deep sequencing, you can map the full fitness landscape of your designed library.
Mammalian display offers a complementary path when your protein requires mammalian post-translational modifications or when you need to validate in a more physiologically relevant context. It is slower and lower throughput than yeast, but for certain targets (particularly glycoproteins), it eliminates an entire class of false negatives.
Deep mutational scanning (DMS) comes after initial hit identification. Once you have binders that work, DMS tells you which positions tolerate substitution and which are critical. This data feeds directly back into the next round of computational design, creating a closed loop between experiment and model.
What Separates Successful Campaigns from Failed Ones
After running dozens of binder design campaigns, the pattern is clear. Success correlates with three factors:
Target characterization. Campaigns succeed when the target structure is high quality and the binding site is well defined. Designing against a homology model with a disordered loop at the epitope is a recipe for failure. If your target structure is not confident, fix that first.
Aggressive computational filtering. The ratio of designs generated to designs tested experimentally should be at least 100:1, often 1000:1. Self-consistency, predicted binding energy, solubility scores, and interface metrics all contribute. No single filter is sufficient. The combination is what matters.
Fast experimental iteration. The first round of designs rarely produces a final lead. Successful campaigns plan for two to three rounds of design, test, and redesign. Each round uses experimental data to refine the computational model. Teams that treat computation as a one-shot prediction and experimentation as a one-shot validation consistently underperform.
The Takeaway
Computational protein design tools are powerful, but they are tools, not solutions. The difference between a successful binder campaign and a failed one is almost never the choice of generative model. It is the quality of the pipeline connecting computation to experiment: the filtering, the validation, the iteration speed, and the willingness to let experimental data override computational predictions.
The teams that win are the ones that treat this as an engineering problem, not a prediction problem.
Related Ranomics services
- Compute-to-clone: End-to-end AI design → validated clone pipeline.
- AI Binder Sprint: Multi-algorithm binder design with 100% binder guarantee.