7 Ways 'Friction-Maxxing' Can Transform How You Learn to Code

In a world obsessed with optimization, we often chase the smoothest, easiest path to success. But a counter-movement called 'friction-maxxing' argues that deliberately adding difficulty can actually make us smarter, more resilient, and better learners. Originating from an essay by sociologist Kathryn Jezer-Morton, this concept encourages embracing hard things—especially when learning technical skills like coding. Here are seven key insights about friction-maxxing and how it can reshape your approach to programming.

1. What Is 'Friction-Maxxing'?

Friction-maxxing is the practice of intentionally increasing the amount of friction in your daily life. Instead of optimizing for convenience, you seek out challenges that require effort. The term gained traction online as a response to hyper-efficient lifestyles. In learning, this means resisting the urge to use tools that make everything too easy—like AI code generators that give you answers instantly. By adding small obstacles—like handwriting notes or debugging without auto-fixes—you force your brain to engage more deeply. Research in education suggests that desirable difficulties improve long-term retention. Friction-maxxing isn't about being masochistic; it's about recognizing that growth often comes from struggle.

7 Ways 'Friction-Maxxing' Can Transform How You Learn to Code — Source: blog.jetbrains.com

2. The Hidden Downside of 'Smooth-Maxxing' Your Learning

Modern learning platforms promise a smooth ride: videos, interactive tutorials, and AI assistants that remove all barriers. But does that actually help? Studies show that when information comes too easily, we feel like we're learning more than we actually are. This is called the 'fluency illusion.' You might watch a dozen coding tutorials, yet struggle to write a simple program from scratch. Smooth-maxxing your education leads to passive consumption, not active mastery. Without friction, your brain doesn't form strong neural pathways. The result? You become a hoarder of courses—never truly building the skills needed to solve real problems. Friction-maxxing flips this by forcing you to wrestle with concepts until they stick.

3. Learning to Code Has Always Been a Friction-Filled Journey

Introductory computer science courses have some of the lowest pass rates among STEM fields—around 30-40% at many universities. But this isn't because only a tiny fraction of brains are wired for code. It's largely a cultural belief turned self-fulfilling prophecy. The steep learning curve is real, but it's not insurmountable. The key is to reframe that difficulty as a feature, not a bug. Friction-maxxing here means embracing the struggle: writing code that doesn't compile, debugging for hours, and reading documentation. These activities build computational thinking and resilience. The most successful learners don't avoid friction; they lean into it, knowing that each error is a stepping stone to deeper understanding.

4. How Friction Improves Retention and Understanding

Educational research on 'desirable difficulties' shows that harder learning conditions often produce better long-term results. For example, mixing up practice problems (interleaving) or testing yourself before studying (retrieval practice) adds friction but boosts memory. When you force yourself to solve a problem without hints, you engage in productive struggle. This activates deeper cognitive processes. In coding, this means typing out code instead of copy-pasting, or trying to fix a bug without Stack Overflow for the first 15 minutes. The temporary frustration pays off because your brain builds stronger connections. Friction-maxxing is essentially a commitment to doing things the hard way—so that when it counts, the knowledge is truly yours.

5. Practical Ways to Introduce Friction Into Your Coding Practice

Start by turning off autocomplete for a week. Write code by hand on paper before typing it. Set a timer and try to solve a problem without any external help. Another tactic: teach a concept to someone else without notes—that forces you to recall and organize information. For reading code, print it out and annotate with a pen. When using tutorials, pause before the solution and try to work it out yourself. These small acts of friction add up. They slow you down initially, but speed comes later as mastery grows. The goal isn't to make everything miserable, but to strategically add obstacles that lead to deeper learning. Over time, you'll find that problems you once struggled with become intuitive.

6. The Role of Community and Feedback in Friction-Maxxing

Learning alone can be frictionless in a bad way—you skip the messy parts. But when you share your code with peers or a mentor, you invite constructive friction. Code reviews, pair programming, and study groups add the productive discomfort of explaining your decisions and receiving feedback. This social friction helps you see blind spots and think more critically. The author of the original essay experienced this firsthand by drawing comics on physical paper, scanning them, and then debating with a design team about 'professional image.' That friction improved the final product. In coding, embrace code reviews, even when they sting. They build resilience and a sharper eye for quality.

7. Friction-Maxxing Prepares You for a Wild Job Market

The tech job market is unpredictable—new frameworks appear daily, and AI is reshaping roles. The one skill that remains valuable is the ability to learn hard things quickly. Friction-maxxing trains your brain to handle uncertainty and complexity. When you've regularly faced frustration in your learning, job interviews or new tech stacks seem less daunting. You've built a tolerance for the 'I don't know' feeling and the persistence to figure it out. Companies need problem-solvers who can push through ambiguity, not just those who took the easiest path. By embracing friction now, you're not just learning to code—you're building the mindset to thrive in a constantly evolving landscape.

Conclusion

Friction-maxxing isn't about making life harder for no reason. It's a deliberate strategy to deepen learning, build resilience, and prepare for real-world challenges. By adding small, intentional obstacles to your coding practice, you transform passive consumption into active mastery. The next time you're tempted to take the smoothest path, pause—and choose the one that makes you struggle a little more. That struggle is where growth happens. So go ahead, turn off autocomplete, write code by hand, and lean into the friction. Your future self—and your career—will thank you.

Tags: