What makes a skill 'complex' versus 'simple' in learning terms?

Simple skills can be broken down into independent, sequential steps that can be practiced in isolation (like making tea). Complex skills have interdependent parts that interact with each other, making it ineffective to practice components separately (like programming, where debugging, feature development, and performance optimization are all interconnected).

How does the 'rotating focus' method work in practice?

Instead of trying to master everything at once, you focus intensively on one aspect of the complex skill for several practice sessions, then rotate to focus on a different aspect. For example, when learning a web framework, spend a week on routing, then a week on state management, then a week on performance, cycling back to previous areas periodically.

Why is rotating focus more effective than practicing the whole skill or focusing on just one aspect?

Research shows that rotating focus outperforms both unfocused practice and single-aspect focus. It allows your brain to build strong 'building blocks' for each component while gradually integrating them into a cohesive skill. This prevents overwhelm while ensuring all parts develop together.

Can you give a specific example of how to apply this to learning programming?

If you're learning full-stack development, you might rotate between: frontend components (week 1), backend APIs (week 2), database design (week 3), testing strategies (week 4), then cycle back to frontend with your new knowledge. Each rotation builds on previous learning while developing new areas.

How long should I focus on each aspect before rotating?

The Space Fortress study used 3-session rotations, but for programming skills, a week or several practice sessions per focus area often works well. The key is spending enough time to make meaningful progress on that aspect while not getting stuck there too long before moving to the next area.

How to Learn Complex Skills: Insights for Programmers from Cognitive Science

As programmers, we often face the challenge of mastering complex skills—whether it’s learning a new framework, managing distributed systems, or designing scalable architectures. Recently, I came across a video by Benjamin Keep, PhD, JD, titled "A Simple Way to Learn Complex Skills", which explores research-backed strategies for learning skills that can’t easily be broken down into independent parts. I found the approach both practical and scientifically grounded, and I think it’s especially relevant for anyone in tech.

Why Some Skills Are Harder to Learn

The video starts by contrasting simple, sequential skills (like making tea) with complex, interdependent ones (like playing Starcraft or, in our case, building a modern web application). With simple skills, you can break the process into isolated steps and drill each one. But with complex skills, the parts interact so much that isolating them isn’t effective. For example, in software engineering, debugging, feature development, and system performance are deeply intertwined—improving one area often affects the others.

The Study: Rotating Your Focus

Benjamin Keep discusses a classic study using the game Space Fortress. Participants were divided into four groups:

Control Group: Practiced the game as a whole, with no special focus.
Group 2: Focused on ship controls for the first six sessions, then played normally.
Group 3: Focused on mine placement for the first six sessions, then played normally.
Group 4: Rotated focus—first three sessions on ship control, next three on mine placement, then played normally.

All groups spent the same amount of time practicing, but the only difference was what they paid attention to during practice.

The Results: Rotating Focus Wins

After the initial sessions, the control group scored the lowest. Groups 2 and 3, who focused on one aspect, did better. But Group 4, who rotated their focus between different aspects, outperformed everyone—both immediately and in continued learning sessions. This “rotating focus” or “variable-priority” approach has been validated in other studies as well.

Applying This as a Programmer

Here’s how you can use this insight in your own learning:

Don’t try to master everything at once. Instead, pick one aspect of a complex skill—like code readability, testing, or database optimization—and focus on it for a while.
Rotate your attention. After a few sessions, shift your focus to another aspect, such as API design or deployment pipelines.
Keep cycling. Return to previous focuses periodically, integrating what you’ve learned.

For example, if you’re learning a new web framework, you might spend a week focusing on routing, then a week on state management, then a week on performance, and so on. Over time, this rotation helps you build strong, integrated skills without being overwhelmed.

Why This Works

Focusing on one aspect at a time allows your brain to create meaningful “building blocks” for the larger skill. As you rotate your focus and revisit previous areas, you gradually integrate these building blocks into a cohesive, high-level ability.

Final Thoughts

Learning complex skills is a journey, not a sprint. The rotating focus method is a practical, research-backed way to accelerate your progress and avoid burnout. Next time you’re overwhelmed by a big learning goal, remember: Focus on one piece, rotate, revisit, and let the integration happen naturally.

Source: A Simple Way to Learn Complex Skills by Benjamin Keep, PhD, JD