---
title: "All our houses are built on sand now"
slug: all-our-houses-are-built-on-sand-now
url: https://listedarticles.com/articles/all-our-houses-are-built-on-sand-now
canonical_url: https://po-ru.com/2026/10/07/all-our-houses-are-built-on-sand-now
content_type: blog_post
language: en
published_at: 2026-10-07T00:00:00.000Z
updated_at: 2026-10-07T23:15:14.650Z
author: "Paul Battley"
authored_by: human
publisher: "po-ru.com"
publisher_url: https://po-ru.com/
topics: ["Programming Languages", "AI", "Open Source", "Opinion"]
license: all-rights-reserved
word_count: 792
reading_minutes: 3
citation: "Paul Battley, po-ru.com. \"All our houses are built on sand now.\" 7 Oct 2026. https://po-ru.com/2026/10/07/all-our-houses-are-built-on-sand-now (all-rights-reserved)"
# The full text follows. The web page shows an extract and sends readers
# to the source above; quote the citation and link the canonical URL.
---

# All our houses are built on sand now

> Paul Battley measured how many recent commits to major programming language implementations are LLM-assisted, finding about a third for C# and Ruby and over half for Julia, while Perl, Lua and Chicken Scheme stay near zero. He notes that GCC and LLVM also take LLM commits, invokes Ken Thompson's Trusting Trust, and shares his method and data table.

# All our houses are built on sand now

## They took all the rock away

  And every one that heareth these sayings of mine, and doeth them not, shall be likened unto a foolish man, which built his house upon the sand: And the rain descended, and the floods came, and the winds blew, and beat upon that house; and it fell: and great was the fall of it.

This was originally going to be called something like, “How slopcoded is your programming language?” But as I gathered the data, I found something else – something worse.

Almost every popular language is now substantially developed using LLMs. Particularly notable are C# and Ruby (both approximately one third of recent commits) and Julia (over half!). The languages that stand out in retaining their humanity are Chicken Scheme, Perl, Lua, Clojure, and – perhaps surprisingly for a project so closely associated with Oracle, a company who have gone all-in on hyperscale data centres and “AI” in everything – Java.

However, all of these rely on a C compiler (indirectly via the JVM in the case of Clojure), and both of the main C compilers now receive significant amounts of LLM commits. I’m not so surprised by LLVM (15.9%), but I am disappointed by GCC (3.1% and apparently rising). Outsourcing your thinking to megacorporations and commercial tools seems out of step with the GNU ethos of freely available source that anyone can modify: code that is generated by machines quickly becomes code that is only parsed and modified by machines, and a subscription to OpenAI or Anthropic becomes the (financial, environmental, and geopolitical) price of entry.

In 1984, in his acceptance speech for the ACM Turing Award, [Ken Thompson
described a method](https://web.archive.org/web/20010606172606/http://www.acm.org/classics/sep95/) by which a compiler could be subverted so that it would
always insert a backdoor into the UNIX `login` command, and, furthermore, when
used to compile itself would insert a similar subversion into new versions of
the compiler. Once this has been achieved, no one has access to an
uncompromised compiler.

  The moral is obvious. You can’t trust code that you did not totally create yourself. (Especially code from companies that employ people like me.) No amount of source-level verification or scrutiny will protect you from using untrusted code. In demonstrating the possibility of this kind of attack, I picked on the C compiler. I could have picked on any program-handling program such as an assembler, a loader, or even hardware microcode. As the level of program gets lower, these bugs will be harder and harder to detect. A well installed microcode bug will be almost impossible to detect.

Does it matter how slopcoded your language is or isn’t, when everything below it is slop?

### Methodology

I cloned the source repositories for implementations of programming languages
that ranked highly on [TIOBE](https://www.tiobe.com/tiobe-index/) and [LangPop](https://langpop.com/rankings). For each, I performed a shallow
clone going back to the start of July:

```
git clone --shallow-since=2026-07-01 ${url}
```
I then wrote a short script that takes a three-month period and counts the number of commits that appear to be LLM-assisted. This is determined by:

- The phrase “AI disclosure” or “LLM disclosure”
- An `Assisted-by:` field
- a `Co-authored-by:` field with the email address of a known bot

This isn’t perfect – I saw one commit that had a disclosure field followed by “none” and a link to a manifesto opposing LLM-assisted coding, but I don’t think those edge cases are significant.

```
#!/bin/bash
bots="ai disclosure|llm disclosure|assisted-by:|co-authored-by:.*(noreply@openai.com|noreply@anthropic.com|cursoragent@cursor.com|copilot@users.noreply.github.com)"
date_since="2026-07-05"
date_until="2026-10-06"
cd repos
for repo in *; do
  cd ${repo}
  total="$(
    git log --oneline \
      --since=${date_since} \
      --until=${date_until} \
    | wc -l
  )"
  botted="$(
    git log --oneline \
      --since=${date_since} \
      --until=${date_until} \
      -E -i --grep "${bots}" \
    | wc -l
  )"
  percent="$(printf %.1f $((10000 * ${botted}/${total}))e-2)"
  echo "|${repo}|${botted}|${total}|${percent}%|"
  cd - >/dev/null
done
cd - >/dev/null
```
### Results

This yielded the following table, which I have sorted and annotated:

| Language(s) | Repository | LLM-assisted | Total | Percent | 
|---|---|---|---|---|
| C, C++, … | gcc | 86 | 2778 | 3.1% | 
| C, C++, … | llvm-project | 2229 | 13981 | 15.9% | 
| C#, Visual Basic | roslyn | 350 | 1114 | 31.4% | 
| Clojure | clojure | 0 | 98 | 0.0% | 
| Elixir | elixir | 73 | 364 | 20.0% | 
| Go | go | 12 | 1092 | 1.1% | 
| Haskell | ghc | 42 | 287 | 14.6% | 
| JavaScript (NodeJS) | node | 395 | 1605 | 24.6% | 
| Java | jdk | 0 | 1194 | 0.0% | 
| Julia | julia | 489 | 918 | 53.3% | 
| Kotlin | kotlin | 398 | 4612 | 8.6% | 
| Lua | lua | 0 | 12 | 0.0% | 
| PHP | php-src | 2 | 2124 | 0.1% | 
| Perl | perl5 | 0 | 851 | 0.0% | 
| Python | cpython | 219 | 1339 | 16.4% | 
| Ruby | ruby | 881 | 2717 | 32.4% | 
| Rust | rust | 41 | 10020 | 0.4% | 
| Scala | scala3 | 18 | 538 | 3.3% | 
| Scheme (Chicken) | chicken-core | 0 | 208 | 0.0% | 
| Swift | swift | 135 | 4831 | 2.8% | 
| TypeScript | TypeScript | 70 | 409 | 17.1% | 

Repositories don’t map one-to-one to programming languages: some implementations cover multiple languages, and some languages have multiple implementations.