What to Fix First When Squash-and-Stretch Creates Volume Drift in Procedural Rigs

You're five frames into a walk cycle, and the character's arm looks like a balloon losing air. The volume's gone. That's creep—the quiet betrayer of procedural squash-and-stretch. Every rigger hits this wall. The fix isn't obvious, and the wrong primary move can waste days. So before you touch a single node, you need a decision frame: what's the root cause, and which patch do you apply primary?

Who Must Choose and by When—The Decision Frame

Identifying the rigger's role: pipeline vs. shot-specific

Volume slippage is a setup problem. Not a keyframe error. I have watched animators waste half a morning dialing in squash compensations that the rig should have handled before they touched the initial pose. The decision lands on you—the rigger—before animation lock. That means before the animator commits to a timing pass. Not during polish. Not after. The catch is that slippage looks like an animation problem: the belly bulges sideways when the character crouches, the forearm inflates during a fast punch, the head elongates when the child giggles. Every one of those cases made me open the graph editor opening. Wrong reflex. Nine times out of ten, the fix lives in the stretch-mapping node or the topology flow, not in a broken key tangent.

You have to judge whether the wander is pipeline-level (same error across every shot, every character variant) or shot-specific (one unique interaction with a prop, one unusual camera angle). Pipeline slippage belongs to you alone. Shot-specific wander might belong to the animator—but only if the rig's base behavior is clean. Most teams skip this: they treat all wander as a rigging ticket, flood the rigger's queue, and then complain about turnaround window. Distinguish the two before you open the file. That saves a day.

Deadline pressure: pre-rig vs. live animation fixes

The decision frame is tighter than most riggers admit. A pre-rig fix—rebuilding the stretch map, re-topologizing the joint distribution, or authoring a blend shape—costs you three hours before the rig ships. A live animation fix, after the rig is in the animator's scene, costs you three hours plus an hour of handoff negotiation plus whatever the animator already adjusted to work around your creep. That math is brutal. And yet I see riggers kick the can: "I'll patch it later, they're only blocking." Later never arrives. By the phase the animator has shaped the timing, your topology change will break their arcs, and the blend shape you add mid-shot will shift their contact points. The choice belongs in pre-rig. Not yet? Then you accept that the fix sits on a list that nobody actually revisits.

Signs that slippage is a setup problem, not a keyframe error

How do you spot the difference without guessing? Three tells. primary: the slippage reproduces identically on every controller move. Rotate the forearm one degree left—same bulge. Rotate it right—same bulge mirrored. That's not animation noise; that's a stretch-map math error baked into the deformation chain. Second: the wander appears at rest pose when you scrub through the squash value. Zero squash, clean shape. Twenty percent squash, side-flare. Eighty percent squash, explosion. The correlation is linear, not organic. That points to a missing volume-preservation formula or a broken scaling axis. Third: the slippage follows the same vertices across character clones. If four identical rigs all show the same waist inflation when the character jumps, you have a topology problem—the edge loops can't handle the stretch direction. Those three patterns account for roughly eighty percent of the drift tickets I have seen filed against procedural squash rigs. The rest are genuine animation errors. Wrong order.

'Volume drift that reproduces identically on every controller move is a rig bug, not a keyframe fix. Quit tweaking curves.'

— internal note from a feature animation pipeline review, 2023

Three Roads to Fix Drift—and One Dead End

Stretch-map recalibration (attribute limits)

The primary route sounds boring—and that's exactly why most people skip it. You open the stretch map, find the attribute that controls maximum elongation, and clamp it. Hard. The drift disappears because the geometry never reaches the threshold where volume bleeds out. We fixed a cartoon arm this way last month: the bicep was inflating like a balloon every window the character reached for a cup. Upper limit moved from 2.4 to 1.7. Done. The catch is brutal, though—you lose squash range. If your rig needs that extreme 2.4 for a specific punch pose, recalibration becomes a compromise. I have seen teams spend three hours tweaking limits, only to realize the animator needed the full stretch for one shot. Trade-off: predictable fix, but you amputate expressiveness.

Topology flow edits on the base mesh

Drift is often a topology problem wearing a rigging costume. The stretch deformer reads edge loops that pinch or fan out wrong, so the volume migrates to the weakest loop. You fix this by editing the base mesh—redistributing edge density, adding support loops where the stretch concentrates, or realigning the flow parallel to the deformation axis. One concrete anecdote: a leg rig we inherited had volume pooling at the knee, no matter what the stretch map said. The mesh had a tri-fan there. We rebuilt eight quads, and the drift vanished. The ugly part—this fix is irreversible. Once you retopo, the rig's shape changes permanently. Animators may hate the new silhouette. And you can't undo topology edits mid-project without a full rebuild. The odd part is—it works best when the drift pattern stays consistent across poses. If the volume jumps around depending on angle, topology flow won't help.

Corrective blend shapes driven by squash-stretch state

This is the fix you reach for when limits feel too restrictive and retopo feels too permanent. You build blend shapes that counter the drift—pulling volume back into place as the stretch map hits specific thresholds. The driver is the stretch state itself: a scalar attribute from the rig feeds into the blend shape weight, so the correction fires exactly when the drift appears. Most teams skip this because it sounds complex. Wrong call. I have done this in under forty minutes for a character that drifted at the shoulder joint. Three blend shapes—one for the armpit bulge, one for the collarbone migration, one for the deltoid collapse. The drift dropped to zero. However: blend shapes multiply fast. One drift point turns into five corrections if the mesh deforms differently in twist versus pure stretch. And blend shapes don't fix topology problems—they mask them. That hurts if you ship and realize the mask only works for one animation cycle.

'We clamped the stretch map. Drift stopped. Then the animator's key pose looked dead. We unclamped it.'

— technical director on a production rig, talking about the recalibration trap

The dead end: scaling the entire rig uniformly

This one surfaces every few weeks in forums. The logic is seductive: "If the volume drifts outward, just scale the whole rig down during the stretch." Don't do this. Scaling the entire rig uniformly compresses the bones, the skin weights, the constraints—everything. You break joint rotations, foot contacts, and eye line targets. I saw a character whose hand drifted because the whole arm scaled 95% during a reach. The fingers curled inward from the scaling. The wrist joint popped through the mesh. That fix took three days to undo. Uniform scaling is not a fix—it's a rig-level virus. The only scenario where it might work is a single-axis stretch on a prop with zero deformable geometry. Even then, you're better off with a stretch map. The dead end is dead because it trades a local drift for a global breakage. And nobody wants to explain to a supervisor why the character's eyeballs shrunk.

How to Judge Which Fix Fits Your Rig—Criteria That Matter

Rig Architecture: Procedural vs. Manual Deformation Stack

The hardest part isn't picking a fix—it's knowing whether your rig will tolerate the fix. I once watched a senior TD spend two hours converting a stretch-map solution for a purely procedural character, only to discover the downstream cloth sim used the raw joint chain as input. Every slot the stretch map recalculated volume, the cloth sim snapped back to the pre-drift pose. Wrong order.

Ask yourself: is your stack a black-box procedural chain or a layered manual build? Procedural rigs—the ones built with nodes, wiring, and math—hate external corrections that skip upstream logic. You can inject a post-deformation volume fix, but the procedural solver will fight it unless you recalculate the entire chain. Manual stacks, by contrast, let you slip a blend shape between two joints without rewriting the spine solver. The catch is that manual stacks drift differently—they accumulate error per control, not per calculation.

If your rig uses a stretch matrix driven by a single curve, the matrix itself is the drift source. A local stretch-map correction works because it overrides the matrix per vertex. But if your rig has five overlapping deformers—squash, twist, bend, taper, another squash—the stack order decides whether the fix holds or the last deformer wipes it out. Most teams skip this: they test the fix on a clean mesh, not on the full deformation stack. That hurts.

Odd bit about animation: the dull step fails primary.

Odd bit about animation: the dull step fails initial.

‘A fix that works on frame 10 might break on frame 120 simply because the joint rotation order flips.’

— observed during a production crash, not a textbook rule

Deformation Density: High-Poly vs. Low-Poly Meshes

The same stretch-map retarget that looks flawless on a 50,000-vertex character will tear a 1,500-vertex game prop apart. Why? Low-poly meshes lack edge loops to absorb the correction. Each vertex carries more deformation responsibility, so a volume-preserving offset that pulls two vertices toward each other creates a collapsed region that no smoothing can fix.

For high-poly meshes, blend shapes often win because you can sculpt the exact volume recovery per shape key—ten targets, ten regions, one clean solve. The trade-off is that blend shapes are static; they don't respond to extreme stretch ranges. Push a blend shape past its sculpted limit and the mesh balloons instead of drifting. I have seen riggers solve this by baking three intermediate blend shapes for the same stretch axis—messy, but it worked.

Low-poly rigs should lean on topology fixes primary. Add one or two support edges around the high-stretch areas—elbow creases, hip flex zones—and the drift often disappears without any corrective math. That sounds trivial until you realize that re-topologizing a game character takes four hours while debugging a stretch-map solution takes two weeks. The right fix isn't always the clever one.

Performance Budget: Real-window vs. Render-phase Tolerance

Real-slot rigs—think games, VR, or mocap previews—can't afford per-frame blend-shape interpolation across twenty targets. The GPU chokes. Your fix becomes the bottleneck. For these rigs, a single stretch-map shader that recalculates volume in the vertex shader is the only viable path. The downside is that stretch maps are approximations; they preserve volume mathematically but often produce a slight pillowy look under extreme squash. That pillowy look is invisible during gameplay but glaring in a cinematic close-up.

Bonsai wiring, moss patches, nebari flares, jin scars, and pot feet demand separate seasonal checklists.

Fjords kelp basalt look wild.

Render-phase rigs, by contrast, can burn cycles. A thirty-target blend-shape stack that runs in 0.04 seconds per frame? Fine—you have hours of render time. But here is the trap: render-time rigs often get handed to lighting teams who don't know the rig's drift history. They move a control, the drift reappears, and suddenly you're in a meeting explaining why the fix didn't survive a normal pipeline handoff. The fix itself was solid; the handoff was the failure point.

What usually breaks primary is the real-time rig that tries to borrow a render-time solution. The blend shapes interpolate smoothly but the frame rate tanks. Or the stretch map that works on a high-poly hero character gets copied to a low-poly crowd agent and the seams blow open. Judge by constraints, not by elegance.

Stretch Map vs. Topology vs. Blend Shapes—Trade-offs at a Glance

Speed of implementation per method

Stretch maps win the sprint. A competent rigger can wire a stretch-aware attribute into an existing deformation chain inside an afternoon—provided the topology is already quad-heavy and the UV layout doesn’t fight the stretch direction. The catch: fast doesn't mean safe. I have seen teams celebrate a stretch-map fix at 4 PM only to discover by 5:30 that the character’s forearm grows visibly longer during a simple arm-swing cycle. That speed premium disappears when you must unpick the map and re-paint influence weights.

Topology edits sit at the opposite end of the clock. Cutting edge loops, redistributing poles, or rebuilding a joint-span section to better handle compression—these changes take days, not hours. What saves them is durability: once the mesh is right, it stays right across blendshape stacks and retargeting passes. The trade-off is brutal for deadline-heavy productions, however. You can’t partially commit to a topology rewrite; either you rebuild the region or you don’t.

Blend shapes land somewhere in the messy middle. Implementation time depends entirely on whether you already have a clean neutral model and a tested shape-transfer pipeline. If you do, sculpting a “squash” target and a “stretch” target for the drifting area takes maybe half a day. If you don’t—if you're sculpting from scratch or wrestling with vertex-order mismatches—that half day becomes four.

Reversibility and iteration cost

The odd part is—riggers rarely ask about reversibility until they need it. Stretch maps are reversible in theory but destructive in practice: removing a stretch map after it has been weighted often leaves residual scaling that must be zeroed manually per joint. Not impossible, but the iteration cost spikes with every retest. One artist I worked with called it “the regret tax.”

Topology changes are effectively irreversible mid-project. Once you cut or merge edges, the old vertex arrangement is gone unless you have a backup saved before the edit. That hurts most when the drift only appears in a single extreme pose and the topology rewrite introduces a seam elsewhere. You fixed one problem; you inherited another.

“Blend shapes are the only method where you can toggle the fix on and off without touching the rig structure at all.”

— observation from a senior character TD on a 40-episode series

That toggle-ability makes blend shapes the safe bet for any rig that still has animation lock-down weeks away. The downside? A rig weighed down by too many corrective targets becomes brittle; animators start hitting “target-order” problems that are miserable to debug.

Honestly — most animation posts skip this.

Honestly — most animation posts skip this.

Impact on downstream animation workflow

Stretch maps feel invisible to animators—until they aren’t. Most animators never touch stretch attributes directly, but they do notice when the character’s hand passes through the hip because the stretch map extended the forearm beyond its intended range. The fix then becomes an animator problem: key the stretch off at frame 42, key it back on at frame 55. That's workflow friction disguised as technical success.

Topology edits are invisible to animators entirely. The mesh just behaves. No extra controls, no per-frame workarounds. The high cost was paid upstream, and the downstream team reaps the benefit without even knowing a fix happened. That's the ideal, assuming the topology rewrite didn’t break something else—which it sometimes does.

Blend shapes sit in plain view. Animators either see a corrective slider they must remember to use, or they see nothing if the shape is driven automatically by squash-stretch values. Automation is cleaner, but it relies on the blend shape being triggered at the right threshold. Wrong order in the stack, and the corrective fires too late—or too early—producing a twitch that looks like bad interpolation. Pick your poison: extra slider in the UI, or automated shape that fights the rest of the deformation chain.

Step-by-Step: Applying Your Chosen Fix Without Breaking the Rig

Lock pivot points before any volume adjustment

The fastest way to wreck a squash-and-stretch rig is to adjust volume while the pivot floats. I have seen animators grab the stretch multiplier, see drift, and immediately dial back the squash—only to discover the character’s foot now slides across the floor during recoil. That's a cascade failure: one fix breaks the contact constraint, which breaks the IK chain, which forces a re-bind. Lock every pivot point initial. Select the joint that shows drift, freeze its world-space transform, and confirm the rotation axis stays fixed when you scrub through the frame range. Most teams skip this step; they pay for it with an extra hour of re-rigging.

‘A drifting pivot is not a volume problem—it's a parent-space problem wearing volume’s clothes.’

— conversation during a crunch-week review, 2023

Test in isolation: isolate the drifting joint

Don't test the whole arm when only the wrist drifts. Duplicate the wrist joint, disconnect it from the forearm chain, and apply your stretch map in a clean scene. Watch what happens when the joint scales past 1.0—does the mesh push outward symmetrically, or does it bulge toward the elbow? The catch is that a shared stretch map hides per-joint errors. If you test the full rig, the forearm compensates for the wrist, and you fix the wrong node. Isolate the drift source opening. I once watched a rigger spend four hours adjusting blend shapes on a spine controller only to discover the drift came from a mis-parented aim constraint on the pelvis. Isolated testing would have shown the problem in twelve minutes.

That hurts—because time spent diagnosing a phantom volume bug is time stolen from animation polish. Use a test sphere parented to the drifting joint. If the sphere’s volume stays constant while the mesh drifts, the topology is the culprit, not the scale logic. If the sphere also drifts, your stretch map or constraint chain is broken. No guesswork.

Iterate with live animation playback, not static poses

Static poses lie. A stretch map that looks perfect at frame 12 often fails at frame 37 when the joint swings through an arc and the volume recovers late. The fix: run a looping playback of the offending motion (a reach, a squash-to-ground, a fast recoil) and watch the drift in real time. Pause at the worst frame, adjust the stretch falloff or blend-shape weight by 0.02, then let the loop run again. Small deltas, live feedback. The odd part is—riggers who iterate on static stills chase the wrong peak every time. They fix the drift at frame 12, break frame 37, and call it a smoothing issue. It's not a smoothing issue; it's a sequencing mistake.

We fixed this once by switching from slider tweaks to a MIDI controller mapped to the blend-shape influence. Live adjustment under playback let us hear the timing—yes, hear—because squash-and-stretch drift often correlates with audible pops in the joint rotation. That was weird, but it worked. End the session with a specific test pose: a fast overshoot from extension to full compression. If the mesh holds volume through that transition, your fix is stable. Otherwise, you still have drift waiting to surface during the next review.

What Goes Wrong When You Pick the Wrong Fix First

Cascade deformations from misaligned stretch maps

The most insidious failure begins with a stretch map that drifts off pace from the rig's actual arc. You fix volume loss by painting a weight onto a map that wasn't built for the joint's full range—say, a 90-degree bend when the map only stabilizes at 45. Everything looks fine in the T-pose. Then you rotate the elbow and the bicep collapses, not because the topology is bad, but because the stretch map is fighting the skin cluster underneath. I have seen a production waste two full days trying to paint corrective blends on a rig that simply needed a remapped stretch gradient. The odd part is—artists often blame the geometry first, so they rebuild loops, add edge rings, and the drift gets worse. That hurts.

Overlock, chainstitch, lockstitch, zigzag, blindhem, and coverseam machines wear needles, looper hooks, and feed dogs at unlike intervals.

Letterpress quoins reward slow hands.

'We painted stretch weights for three hours. The volume kept sliding. Turned out the map was reading from the wrong joint chain the whole time.'

—Lead rigger, mid-budget feature film

The cascade happens because stretch maps influence where the mesh thinks its rest pose lives. If the map is misaligned, every subsequent deformation—squash, twist, taper—magnifies the offset. You don't fix drift with more corrective shapes; you fix it by auditing the map's reference frame first. Most teams skip this.

Topology edits that create pinching or shearing

So you decide the quickest fix is cutting new edge loops around the drifting area. That can work—if the drift is purely a loop-resolution problem. But squash-and-stretch rigs are rarely that forgiving. Adding geometry mid-arm often shifts the strain onto adjacent edge rows that were never designed to handle extreme deformation. The result? Pinching at the elbow crease and shearing across the bicep peak. We fixed this once by removing eight loops the previous artist had added—the drift vanished because the stretch solver wasn't fighting extra vertices it didn't need. The catch is that topology edits are permanent changes to the base mesh; you can't undo them without re-exporting the asset. Wrong fix first, and you lock yourself into a mesh that now needs blend shape band-aids for every new pose.

Pinching creates a visual artifact that your eye catches instantly—a hard line where the volume should flow. Shearing is subtler: the texture slides sideways under rotation, making cloth or skin look like rubber dragged over sandpaper. Production horror stories usually involve a rig that went through three topology passes before someone realized the original edge flow was fine. The problem was the stretch map. Not the mesh.

Flag this for animation: shortcuts cost a day.

Flag this for animation: shortcuts cost a day.

Blend shape explosion: too many corrective targets

This is the dead end that keeps on costing. You notice drift at frame 240, so you build one corrective blend shape for that pose. It works. Then you notice drift at frame 310—another target. By the end of the shot you have fourteen corrective shapes, each fighting the other, and the rig's evaluation time triples. Blend shapes are local by nature: they fix one pose, one angle, one specific volume loss. They don't fix the underlying drift cause—they mask it. I have watched a rig accumulate thirty-seven corrective targets before someone checked the stretch map and found it was referencing a joint offset by 0.3 units. One map fix killed thirty-five of those shapes. That's a day of work gone, plus the cognitive load of managing a blend shape library nobody else wants to touch.

Wrong order. You pick blend shapes first when the drift looks small, but small drifts compound. Three days later, every new pose needs its own corrective, and the rig becomes a patchwork no one trusts. The better move: test the stretch map and topology for fifteen minutes before writing a single blend shape target. That fifteen minutes saves you from owning a shape explosion that will follow the rig into lighting.

Mini-FAQ: Quick Answers to Common Drift Questions

Can I fix drift with just the stretch map?

Short answer: sometimes. The stretch map—that scalar multiplier driving your deformation—can reduce volume drift if you pair it with a corrective blend shape or a secondary lattice. But alone? Not a full fix. I have seen teams slap a stretch map onto a rig, watch the character shrink during a reach, and declare the problem solved. It wasn't. The map controls how far vertices travel, not where they settle after the stretch recedes. You end up with a puppet that snaps back to wrong proportions—drift disguised as recovery.

The catch is subtle: stretch maps handle linear displacement well, but procedural squash-and-stretch rigs bend volumes in non-linear ways. Your elbow compresses, your shoulder bulges—the map sees a uniform scale and applies a uniform correction. That mismatch creates drift at the joint. So yes, use the stretch map for global control. But treat it like a rough pass, not a final lock. If your rig drifts more than 3% over a full range of motion, the map alone won't pull it back.

Do I need to rebuild the rig from scratch?

Not yet—and probably never. That instinct to scrap and restart costs you time, not quality. Nine times out of ten, volume drift lives in the weight distribution, not the skeleton hierarchy. We fixed a production rig once where the entire chest drifted sideways during a squat cycle. Rebuild looked like the answer. Three days wasted. The actual problem? Two vertex groups with overlapping influence from the spine and clavicle joints. A single blend shape corrected it in under an hour.

What usually breaks first is trust—animators see drift, blame the rigger, and the rig gets flagged for rebuild. Resist that pull. Instead, isolate the drift to a specific joint or pose range. If it appears only at extreme compression, it's not a skeleton problem—it's a topology smoothing issue. If it appears everywhere, check your stretch-map falloff first. Rebuild only when you have exhausted those two paths and the rig has broken deformation across multiple axes. That's rare.

How do I test for drift before handing off to animators?

Quick, brutal, and manual. Create a test primitive—a simple box or cylinder parented to the rig's root joint. Drive it through the full range of motion: idle, full stretch, full squash, twisted reach. Measure the bounding box volume at each extreme. If it fluctuates more than 5%, you have drift. Most teams skip this step—they eyeball the mesh and call it good. Don't. A mesh can look fine while volume migrates to an untracked area, like the armpit or inner thigh.

„I caught a 12% volume shift in a spine rig by measuring a test cube. The mesh looked fine. The numbers didn't lie.“

— Rigger on a mid-budget feature, explaining why test primitives survive handoffs

Better yet, automate it. Write a Maya Python or Blender driver script that prints volume deltas per frame during a stretch cycle. Compare against the rest pose. If you see a 4% drift on frame 12 and 11% on frame 25, you know exactly where the fix must land—not blindly across the whole rig. Handoffs get smoother when you deliver not just the rig, but a test card showing those numbers. Animators trust what they can verify.

So Which One Do You Reach For First?

Start here: the stretch-map test

You have read the trade-offs. Now you're staring at a rig that bloats every time the character reaches for a prop—which button do you press first? I have walked into this exact room maybe forty times, and the answer has not changed. Test the stretch map before you touch topology or blend shapes. Always. The logic is boring but brutal: a stretch-map fix takes thirty minutes to prove or disprove. The other two roads cost you half a day or more before you know whether they work—and they often don't work at all for simple drift.

The catch? Stretch maps can't fix every case. If your geometry has extreme edge-flow asymmetries—say, a shoulder that fans into a neck cluster—the map will fight you. That's when you walk toward topology. But ninety percent of the drift I see at 'blitzify.top' reviews comes from a single bad curve node or a weight that bleeds into a squash group it should never touch. Not a topology problem. Not a blend-shape mismatch. Just a map that lies about the rest length.

Summary decision tree based on rig type and deadline

Production tonight? Reach for the stretch map. R&D rig with six months of shelf life? You have room to rebuild topology. The decision lives on two axes: how much time you have and how messy the geometry is.

• Under 2 hours to deadline: Stretch map only. Re-weight the offending joint chain, recalculate rest-length per frame, and move on. Wrong order? That hurts—but a map fix is reversible in seconds. Topology cuts are not.
• Geometry has visible pole pinching or non-quad flow: Topology fix first. The map can't smooth a bad mesh, and blend shapes will fight the deformation on every extreme pose. I learned this the hard way on a cartoon elephant—three days of blend-shape tuning that collapsed because the trunk edge loops spiraled the wrong way.
• Your rig needs volume precision in one specific pose only: Blend shapes win. The trade-off is maintenance—every future change to the base rig breaks the shape target. But for a single hero shot? Worth it.

No silver bullet—but a clear starting point

'The fastest fix is almost never the permanent fix. That's fine. Ship the shot, then rebuild the rig.'

— said by a lead rigger I respect, after we patched a drifting space-suit arm at 2 a.m.

Most teams skip the stretch-map test because it feels like guesswork. It's not. You map the stretch to a normalized curve, clamp the output, and check whether the drift follows the squash group or the stretch group. When it follows the stretch group, you win. When it follows the squash group, you need topology or blend shapes—but you know that in forty minutes, not four hours. What usually breaks first is the confidence to stop early. You reach for the stretch map, it fails, and you think you wasted time. Wrong. You saved the afternoon.

Final honest advice: test the stretch map first, always. If it holds, you ship. If it doesn't, you have a precise diagnosis for the topology rebuild. That's not hype—it's the lowest-risk step I have seen survive every production crunch from student shorts to broadcast series. Press the map button. Stare at the drift. Decide. Then fix.