Ask a model to start a new project and it settles the language for you, usually without mentioning that it did. Across 25 models and 28 briefs drawn from areas where Python is a poor fit, models wrote Python 35.3% of the time while recommending it for only 10.7% of the same briefs — and fewer than half of all implementations used any of the model's own top three recommendations. Reading 9,826 of their reasoning traces explains it: 69.8% never weighed the language at all, and 7.8% invented a reason.
The design is simple enough to be hard to argue with. The same project brief is put to a model twice: once as "write code for this", once as "what are the best languages for this". Nothing else changes. Drag through the 25 models — they are ordered by how often each one reaches for Python — and watch the two bars separate.
Two patterns worth carrying away. Smaller models lean on Python harder — 66.5% for the smallest Nemotron against 18.3% for GPT-5.4 — and code-specialised models are not the exception you would expect: Codestral and both Code Nemotrons write Python for more than half of these projects, and adding code specialisation to Kimi K2.6 raised its Python rate by six points.
The benchmark is not a trick. Seven areas were picked so that each captures a distinct reason Python is a poor default — a runtime that will not fit, a platform that will not run it, a latency budget it cannot meet — with four concise, language-agnostic briefs in each. Two developers with seven or more years of experience independently rated Python weak, acceptable or strong for every one. Step through the areas.
Aggregated over every model and every one of those briefs, Python is still the most common answer at 35.3%, with JavaScript at 19.0%, C at 13.4% and C++ at 8.0% — four languages covering 75.7% of all responses and every other language at 4% or less. On a benchmark constructed entirely from projects where the familiar default is the wrong one.
This is the part that turns a preference finding into an engineering one. Every Python implementation from the 15 models that expose raw reasoning traces was classified by what the trace actually says about the language choice — 9,826 of them, by a judge validated at 96.0% accuracy against hand labels on a held-out set. Step through what it found.
The phrase to remember is the authors': the chain of thought starts too late. It reasons carefully about how to implement a stack it never chose. And the two error categories underneath — 7.8% fabricating a requirement that was never in the prompt, 1.9% naming one language and shipping another — are not preferences at all. They are a grounding failure and a consistency failure, and both are things you can test for.
Plot every model twice: how often it writes Python, against how often its implementation lands in its own top three recommended languages. Points below the dashed line are models that write Python more than they follow their own advice. Drag to inspect one.
The best rank correlation on the board is 0.36, and one model is negative at −0.10 — the languages it pushes hardest are not the ones it writes. So a model's stated recommendation is close to useless as a predictor of what it will hand you, which means asking it "what should I use here?" and then telling it to build the thing are two independent draws, not one decision.
The relevant question is not whether models like Python. It is how many of the scaffolds your agent produces get a stack nobody chose. Set your volume and how much of it sits in areas where the familiar default is wrong.
The cheap control is structural, not a better prompt. Make the stack decision its own step with its own output — a short written comparison of two or three candidates against the actual constraints, produced and reviewed before any file is created — and then check that the code you got back is in the language that step chose. That single check catches the 1.9% outright mismatches for free, and it forces the deliberation that 69.8% of traces skipped.