AI mistakes aren't random noise: they pile up in the same predictable places, and those places reveal what the model really learned.

This explores why the cases AI systems fail to get right pile up along predictable fault lines instead of scattering like noise. The corpus has no note on "unresolved items" as such, but many notes describe failures with this pattern. The shared answer is that errors follow the structure of what the model actually learned, not the structure of the task we assume it's doing.

Language is the cleanest case. Models like Llama3-70b handle simple sentences but keep misidentifying embedded clauses, verb phrases and complex nominals, and the errors get worse in step with syntactic depth (Why do large language models fail at complex linguistic tasks?, Does LLM grammatical performance decline with structural complexity?). A model that had learned grammar rules wouldn't care much about nesting depth. A model that learned surface heuristics works until nesting outruns them. Reasoning shows the same thing, with a twist. Reasoning models don't break at a complexity threshold. They break at instance-novelty boundaries, and a chain of any length works if the model trained on similar instances (Do language models fail at reasoning due to complexity or novelty?). Reasoning-trace length tracks problem difficulty only in-distribution and decouples from it outside (Does longer reasoning actually mean harder problems?). So the fault line is distance from the training data, which has structure, and that's why the failures do too.

Average scores hide this. Models trained with SGD can reach perfect accuracy with every needed feature linearly decodable while their internal organization is fractured, and that stays invisible until perturbation or distribution shift exposes it (Can models be smart without organized internal structure?). The failure clusters sit in the regions a standard test set never probes.

Pipelines cluster failures for a different reason: failures share an upstream cause. RAG failures are architectural. Embeddings measure association rather than relevance, and embedding dimension limits which sets of documents can be represented at all, so the same kinds of queries fail repeatedly (Where do retrieval systems fail and why?). Structural near-misses that look topically right get confused with true matches, and a verifier working on full token-interaction patterns catches what compressed vectors miss (Can verification separate structural near-misses from topical matches?). In skill retrieval, LLM task decomposition reaches only 34% step-level recall, and correcting the step count alone recovers 75% of the gains (What blocks skill retrieval in task decomposition?). One bad upstream choice produces a correlated heap of downstream misses. Reasoning models add a behavioral version: they wander, or abandon promising paths too early, and a decoding penalty on thought-switching helps without any fine-tuning (Why do reasoning models abandon promising solution paths?).

The corpus also suggests that clustering is itself a signal. Taobao's Swing algorithm finds structural patterns noise-resistant because several independent noisy edges rarely line up by coincidence (Can graph structure patterns outperform direct edge signals in noisy data?). That note is about product graphs, not model failures, but the logic carries over. Random errors don't align, so when failures do align, something shared is causing them. This also explains why the fixes in the corpus match structure to structure: routing each query to the knowledge format its task needs, such as tables, graphs or chunks (Can routing queries to task-matched structures improve RAG reasoning?), or deriving symbolic rules from a knowledge graph's topology so reasoning follows the graph instead of similarity (Can symbolic rules from knowledge graphs guide complex reasoning?).