Climbing Like You Code: Refactoring Your Movement

You can stick a boulder and still know—deep down—that you didn’t really own it. It goes today, sure. But try it tomorrow and it’s a coin flip. In software, Martin Fowler popularized a word for this: refactoring—rewriting the internal structure without changing the outcome, so it holds up over time. On the wall, the idea is simple and slightly annoying: progress isn’t always about getting stronger. A lot of the time, it’s about reorganizing a move until it’s stable, clear, and repeatable.

(cc) Tofan Teodor et Walkator / Unsplash - Montage Vertige Media

It’s Tuesday night. The gym is packed, the music’s too loud, people keep brushing past each other. A boulder that “goes” eventually lands in the sent column: three tries, a grimace, one last move yanked out, and then that quick smile halfway between relief and self-belief—the one that says you barely got away with it, but you’d rather tell yourself it was under control. It looks clean on the scorecard. In your body, it feels… questionable. You won it with tension more than understanding.

So you do it again. Not because you’re a masochist—because something feels off.

This time you prop a phone on the ground and film the whole thing. On screen, the diagnosis is instant: shoulders creeping up, hips drifting out, feet tapping instead of settling, a chain of tiny panic-corrections. A system that survives.

And that’s exactly the problem.

This is where Fowler’s refactoring mindset—built for code—turns out to be a useful method for climbing. Refactoring, in the most practical sense, isn’t “doing more.” It’s making the structure readable. And readable climbing is often worth more than extra strength: you can repeat it, you can use it elsewhere, and it holds up when conditions aren’t perfect.

You sent. So what?

There’s a stubborn misunderstanding in climbing: people confuse success with solidity. Success is an event. Solidity is an architecture.

An architecture can be wobbly and still stand—until the day something changes: you’re tired, your skin’s thin, you’re stressed, the humidity’s up, the move’s just slightly different. That’s when the “it goes” style shows what it always was: a stack of compensations.

The trap is that this kind of climbing validates itself. Since it worked, it becomes your method. Since it paid off, it pushes you to add another layer: a little more power, a little more core tension, a little more stubbornness. Strength becomes a patch—effective, immediate, rewarding.

And deeply misleading.

Because what we call “getting better” can just be getting better at compensating. The mistake isn’t fixed; you’ve just increased your margin for slop. Then one day the hold isn’t as positive, or your focus is off, and the whole thing falls apart—not because you “lost your level,” but because you built up too much debt.

Refactoring Without Changing the Score

In software, Fowler’s idea is almost provocative in a speed-obsessed world: refactoring means changing a program’s internal structure without changing what it does from the outside. You’re not shipping a “new feature.” You’re making it possible to keep shipping without everything catching fire later. It’s a promise to your future self, not a present-day fireworks show.

On the wall, it’s the same. You redo the same boulder—but differently. The goal isn’t a harder grade. It’s the stable version: the one that survives repetition, fatigue, and surprises. The one where you can say—without lying to yourself—“I can do that again.”

In a sport obsessed with “I sent” (send, meaning you climb it clean without falling), that shift is almost subversive.

Refactoring is the difference between a momentary win and an actual skill. One is a fluke you can’t bank on. The other is something you can carry.

If you want progress that lasts, you need structures: readable code, readable movement, readable climbing.

Feet: The Forgotten Syntax

A lot of climbers think “strength” when they should be thinking “syntax.”

In plenty of failures, the issue isn’t weak muscles—it’s a badly written sentence: a foot placed too late, hips left out, a path that wastes motion, a breath held at the worst moment. You pull to cover for positioning that never happened. Then you call it “I’m not strong enough,” when what you’re really missing is structure.

In climbing, your body is a language. Your feet are the grammar. Ignore them and it’s like writing without punctuation: the message might get across, but everything becomes expensive, violent, and sloppy. And that cost gets mistaken for “power.” It’s hard, so I need to get stronger. Not necessarily. It’s messy, so you need to get clearer.

Refactoring here is painfully concrete: place the same foot differently, weight it earlier, accept losing half a second to save three at the crux (the hardest part of the problem). Spend less emotional energy “trying hard,” and more attention placing things correctly.

That kind of attention eventually produces a rarer kind of strength—the kind you don’t notice, because it lasts.

Movement Debt

“Dirty” climbing is climbing on credit.

You borrow from your skin, your tendons, your headspace, your confidence. You borrow from the future to pay for the present. In the moment, it works: you get up, you tick the box, you move on.

But the debt piles up quietly, with no immediate receipt. Then one day you stop improving and you reach for a noble explanation for a basic problem: plateau, no motivation, bad style. Sometimes it’s simpler than that.

Sometimes it’s just the bill coming due.

Refactoring is about paying down that debt instead of chasing more power. It’s not flashy. It asks you to redo problems below your ego, to replay sequences without the dopamine hit of novelty, to let a session feel like a workshop instead of an exam.

And, most of all, it asks you to give up a piece of identity—the part built around this is how I climb.

But it’s also the only road that doesn’t end in a crash. In climbing and in code, what matters isn’t sending once. It’s building a system that keeps working when conditions get worse.

And they always do: fatigue, stress, cold, pride, age, life.

The Protocol: Same Boulder, New Architecture

Refactoring isn’t a vibe. It’s a practice.

Pick a boulder you can do “with tricks,” the one you can muscle through when you have to. Then impose a quality constraint—not an outcome constraint: quiet feet, hips in, steady breathing, fingers placed exactly where you want them. Do it again. Adjust. Do it again.

Same result. Different structure.

One thing almost always happens: for a while, you get worse. The patches stop working. The compensations get rejected. The little cheats disappear.

That’s normal. A new internal logic often feels fragile before it feels efficient.

Then, without warning, it goes—with a calm obviousness. Not the loud kind of obvious that says watch this, but the quiet kind that says yeah, that was it.

And in that moment, you get something strength doesn’t always buy: margin.

Margin that makes your climbing steadier. More transferable. More durable.