Neurotypica

Control is layered: higher goals set constraints, intermediate levels coordinate sub-goals, and lower levels implement action primitives. This lets you flexibly combine familiar skills to serve new aims without rebuilding them from scratch. The hierarchy works when each layer does its job and the hand-offs are clean---the high layer sets the goal, the mid layer queues the next step, the low layer executes.

So what can you do? Match your intervention to the right layer. If low-level execution is fine but sequencing is wrong, fix the mid-level plan. If the plan is sound but the goal keeps shifting, clarify the high-level constraint. Don't micromanage every step---set up the hierarchy so the right routines fire at the right time, and let the lower layers run on autopilot where they can.

Hierarchies add switch costs: changing the high-level goal mid-flow can momentarily freeze or confuse the lower levels. You lose your place, you stumble, you have to reorient. And if the top constraints are too tight, they can suppress useful bottom-up signals that would otherwise correct errors or suggest better routes.

So what can you do? Minimise high-level switches during execution. Decide the goal in advance and commit to it for the duration of the episode. If you need to change course, do it at a natural break between episodes, not mid-sequence. And balance top-down constraints with openness to bottom-up correction---rigid goals can blind you to better options that emerge along the way.

The hierarchy doesn't just coordinate physical movement; it coordinates thinking too. High-level reasoning goals bias which details you attend to and in what order they're bound. Breaking a complex task into subgoals lets you hold less in working memory at any one time, because the active subgoal defines what's relevant and the rest can stay in the background until needed.

So what can you do? Chunk complex plans into subgoals that can be executed sequentially with clear hand-offs. Each subgoal should be simple enough to hold in mind while executing, and the transition to the next should be obvious. This reduces the load on working memory and makes the whole sequence more robust to interruption.

The high-level goal acts as a frame that determines which lower-level routines are relevant. This framing isn't neutral---it highlights certain action possibilities and obscures others. Different high-level goals activate different configurations of the hierarchy, which means changing the goal changes what's available at the lower levels.

So what can you do? Recognise that the high-level constraint shapes what actions you can even consider. If you're stuck, the issue might not be execution---it might be that the current goal frame makes the solution invisible. Reframe the problem at the high level, and different lower-level routines become available.

Higher levels generate predictions about what should happen at lower levels, and these predictions constrain which routines get activated. When the hierarchy is well-calibrated, the predictions are accurate and execution is smooth. When it's miscalibrated, you get prediction errors---the lower level tries to run a routine that doesn't fit the higher-level expectation.

So what can you do? Align the levels before execution. Make sure the high-level goal generates accurate predictions about what the mid and low levels can actually deliver. And when you're learning a new skill, expect miscalibration at first---the high level doesn't yet know what the low level can do, so the predictions will be off until practice brings them into sync.

The hierarchy is cooperative, not competitive. Each layer does what it's good at: the high level maintains the goal and adjusts constraints, the mid level sequences subgoals and manages hand-offs, the low level executes primitives. When the layers work together, behaviour is flexible and robust. When they compete, you get conflict---the high level tries to micromanage, or the low level resists constraints.

So what can you do? Trust the layers to do their jobs. Don't override low-level execution from the top unless there's a clear error. And don't let low-level habits override high-level goals without checking whether the goal still applies. The hierarchy works when each layer respects what the others contribute.

Hierarchical control involves both top-down signals (goals, predictions, constraints) and bottom-up signals (sensory input, execution feedback, errors). The system works when these converge: the top-down goal matches what the bottom-up signals support, and bottom-up feedback updates top-down predictions. When they diverge, you get conflict or confusion.

So what can you do? Design contexts where top-down and bottom-up align. Set goals that match what the environment and your skills support. And stay open to bottom-up feedback---if execution keeps failing, that's a signal to revise the high-level plan, not to double down on willpower.