Checking whether a plan works is far easier than coming up with one, so why do AI models struggle with the second?

This explores why judging a plan is easier than producing one. The corpus never states that asymmetry as a headline result, so the answer below is assembled from notes on why generation is hard and what evaluation buys you. The pieces fit together.

Generation is a search problem, and current models search badly. Reasoning models wander. They take invalid steps and abandon promising paths too early, and their odds of success drop exponentially as a problem gets deeper, so medium problems are solvable and deep ones are catastrophically harder (Why do reasoning LLMs fail at deeper problem solving?). The failure is also more about organization than effort: in one note, a penalty on switching thoughts improved accuracy with no retraining, which suggests good solution paths were already in reach and got dropped (Why do reasoning models abandon promising solution paths?). Planning adds a second difficulty. LLMs know what the pieces of a plan are, but only 12% of GPT-4's plans were executable, because assembling them means handling how subgoals and resources interact (Can large language models actually create executable plans?). Every step has to stay consistent with every other step.

Evaluation skips all of that. You are handed a finished candidate and only have to judge it, not find it among an enormous number of possibilities. The cost of checking grows with the length of the plan, while the cost of searching grows with the depth of the problem. That scaling argument is general computer-science logic, not something the corpus measures, but several notes are consistent with it. Critique fine-tuning on a single problem, using teacher critiques of varied solutions, unlocked reasoning about as well as reinforcement learning. Seeing correct and incorrect reasoning side by side was enough signal (Can a single problem unlock reasoning through solution critique?). So a model can learn from judging even where it struggles to produce. Pairing forward and backward planning with a verification step improved success by 4–24%, using the check as a cheap filter on candidates (Does planning direction affect how hard problems become?). That note also shows generation difficulty depends on search order. A bottleneck near the goal makes backward planning easier, while a verifier just reads the finished plan whichever way it was built.

The same idea shows up in how models learn to search. Training on messy search traces with mistakes and backtracking produced 25% better problem-solvers than training on clean optimal paths only (Does training on messy search processes improve reasoning?). Backtracking depends on recognizing a dead end, which is an evaluation skill applied in the middle of generation.

The gap has a limit, though. Evaluation is cheap only when you know what good looks like. Planning problems usually have crisp goals and constraints, so a plan either reaches the goal state or it doesn't. For open-ended goals, fixed objective functions are imperfect proxies that can be gamed. There the note argues the bottleneck is deciding what to optimize, not searching faster (Why is objective design the real bottleneck in AI discovery?). In short, generation is expensive because the search grows with depth, and checking is cheap only while the goal is well defined.