The Permission Structure
The $5 microcontroller goes in without checking the datasheet. The $80 dev board gets a careful read first.
Not because you've done the math. The cheap one just carries no weight. If it burns, you order another.
Lowering the price expands access. Which experiments people actually run is the less obvious shift, and the more consequential one.
When felt failure cost is high, you filter before you act. You run deliberate experiments: defined hypotheses and specific questions you're trying to answer. That's a reasonable way to work. When felt cost is low, you run all of that, and you also run the impulsive experiments. The "what if I just" move. The configuration that doesn't make theoretical sense but takes ten seconds to try. The stupid thing.
Felt cost diverges from actual cost. A $30 board that takes two weeks to ship and an afternoon to reconfigure back to a known state feels more expensive than a $150 board arriving next-day with a clean image to flash. The unit isn't dollars. It's friction to get back to baseline when something breaks, plus how permanent the damage is. Low felt cost means fast replacement and limited damage. Anything meeting those conditions is cheap in the sense that shapes behavior, whatever the price tag.
The impulsive experiments are mostly garbage. But not entirely, and that's the asymmetry. You can't plan an experiment you don't know to plan. The parameter you vary without a reason is often the one no reasonable person would have specified in advance. The failure mode you find by accident is usually the one the documentation skipped, because it's the one nobody thought to test deliberately. Discovery that depends on surprise only comes from experiments you'd never have intended to run. Those are exactly what high felt cost filters out.
There's a posture shift beyond selection. When you're not protective of the hardware, you stick it in configurations it wasn't designed for, combine things that weren't meant to go together. The carefulness expensive gear triggers is precisely what prevents the weird combination that turns out to work. Protective posture and exploratory posture don't coexist well.
The pattern holds in software. A local dev environment you can nuke and rebuild in three minutes is cheap in this sense. A shared staging environment that takes an hour to restore is expensive. The developer reaches for the impulsive test or decides to think it through, and the deciding factor is how much it hurts to be wrong. Thinking it through is often the right call. The experiments you think yourself out of running are still a real cost.
Compound this over time. Someone running impulsive experiments builds a catalog of failure modes you can't acquire another way. Intuitions that surface as "I'd seen something like that break before." The deliberate experimenter knows what they tested. The impulsive experimenter also knows what broke when nobody expected it to.
The design consideration for tool builders: price is one variable, recovery friction is the one that shapes behavior. Fast recovery from bad decisions means more experiments. Slow recovery produces caution. Caution has its place. New things tend to come from the other posture.
Cheap is how bad it would feel to light it on fire.