Cuauhtémoc Pacheco claims kcc — a formal C17 compiler in ARM64 assembly set down as a ~1000-page literate program co-authored with Claude without agentic tooling on about $100/month — compiles itself, runs Lua, SQLite, and DOOM, and boots a Linux kernel; independent builds and conformance runs resolve whether plain LLM-assisted development can produce substantial systems software without agents.

state: seedheat: lowuncertainty: highcontradictsscott: highllm-assisted-development coding-capability compilersCuauhtémoc Pacheco

What is this?

The supplied search results never mention Cuauhtémoc Pacheco or kcc — they instead document a rival, high-visibility project with nearly identical verification targets: Anthropic's 'Claude's C Compiler' (CCC), built in February 2026 by safeguards researcher Nicholas Carlini using 16 parallel Claude Opus 4.6 agents (~2,000 sessions over two weeks, ~$20,000 in API costs, 100,000 lines of Rust), which compiles Linux 6.9, passes ~99% of the GCC torture tests, and builds QEMU, FFmpeg, SQLite, PostgreSQL, Redis, Lua, and DOOM. kcc, as described only in the case's own evidence, is the mirror-image methodology claim — one human co-authoring a C17 compiler in ARM64 assembly as a ~1000-page literate program, using Claude without agentic tooling for ~$100/month — and its demo list (self-compilation, Linux kernel boot, SQLite, Lua, DOOM) tracks CCC's almost item for item, suggesting deliberate positioning against the agent-team result, but nothing in the snippets independently corroborates kcc's existence or its claims. The Anthropic coverage also stresses that the real engineering was the test harness and GCC-oracle feedback loop rather than the model, which sharpens what an independent kcc build would actually test: whether harness-free, chat-only LLM collaboration can clear the same systems-software bar.

Why it matters to Scott

Directly stresses his load-bearing 'agents don't hallucinate less, they loop better' thesis (Agentic Coding Plain and Spicy, Three Ingredients Framework): kcc claims the same verification targets as the ~$20k agent-built CCC — self-hosting, SQLite, DOOM, Linux boot — via chat-only collaboration at ~$100/month, with its ~1000-page literate program doubling as a live instance of his spec-as-asset claim (retained source, generated assembly as disposable IR). Since CCC's coverage credits the harness/oracle as the real engineering, kcc-without-harness isolates exactly the variable his canon says is decisive — if independent builds confirm it, the loop thesis is bounded; either way it's a controlled pair that feeds his agent-vs-chat ebooks and his own all-agents dev stack.

ip:source.agentic-coding-plain-and-spicy-ebookip:framework.three-ingredients-frameworkip:source.think-in-whole-stories-why-ai-coding-agents-write-better-code-when-they-see-the-complete-picture-ebookip:concept.spec-as-assetip:concept.characterisation-testingip:concept.token-economicsradar:trip-plain-c-transformer-stackradar:codex-assisted-apple-gpu-driverradar:concept.inference-economics

queries asked of Scott's wikis

literate programming AI-authored codebases
agents vs plain chat LLM development workflow
self-hosting compiler built with LLM
test oracle harness LLM-generated systems code
LLM development token cost economics
formal C17 conformance verification

Measured heat

now 0 pts/hpeak 8 pts/hcomments 0/hpeers p14momentum: steady1 platformsage 236h

points/hour across evidence · reading as of 2026-10-12 02:59:37.977291+11:00 · deterministic, not a model opinion

How the heat travelled

10-01 19:53	⭐ origin directly observed	Kcc – a C17 compiler built solo with an LLM on $100/month, no agents temo_pacheco on hacker news	—
10-02 01:59	first on hacker news · published · +6.1h	Maylang – A self-hosted systems language compiled with LLMs mirged	—
10-01 19:53	amplified on hacker news 👑	hn.story.49926294 temo_pacheco	peak 19 · 25 comments · 90% of case engagement
10-02 01:59	amplified on hacker news	hn.story.49929136 mirged	peak 2 · 1 comments · 6% of case engagement
10-06 17:10	amplified on hacker news	hn.story.49981314 temo_pacheco	peak 2 · 0 comments · 4% of case engagement
10-01 20:21	our radar first saw it · +0.5h	discovery anchor: hn.story.49926294	—

pace: p60 vs 1188 stories at the 168h mark (now 236h old) — ahead of ling-spark-mtp-throughput (1.0x), behind local-kv-cache-pressure-probe (1.0x)

Evidence (3) — ⭐ canonical anchor

source	object	author	score	comments
🟧 hn ⭐	Kcc – a C17 compiler built solo with an LLM on $100/month, no agents Retrieved article excerpt Open article · Retrieved 2026-10-01T20:35:58.452815+00:00 # kcc — A Formal C17 Compiler in ARM64 Assembly kcc is a formal C17 compiler written entirely in ARM64 assembly, and set down as a single literate program using [weft](https://github.com/temo-pacheco/weft), a metalanguage built to be authored and read by human and AI collaborators alike. Every instruction is explained in prose before it is written in code. It checks C against the Standard, optimises it, allocates registers, and emits native machine code; it compiles itself to a byte-identical binary; and it cross-compiles to x86-64 (Linux and macOS). It builds and runs Lua, SQLite, and DOOM — and boots a Linux kernel. The whole book is the compiler (≈1000 pages): read [kcc.pdf](https://github.com/LiterateDrivenDevelopment/kcc/blob/main/kcc.pdf) in this repository, also published on [Releases](https://gitlab.polinesso.org/literate-programming/kcc/-/releases), or build it yourself (see below). Learn more about Literate Driven Development at <https://literatedriven.com>. ## The `.weft` files are the only source of truth Everything the machine builds — the assembly modules, the verification scripts, and the `Makefile` itself — is generated by tangling the literate sources. You never edit generated files; you edit the book. ``` kcc.weft master document (LaTeX preamble + @i includes) literate/ all the chapters (prose + code fragments) assets/ cover art (SVG → the PDF covers) kcc.pdf the typeset book (committed; rebuilt with `make pdf`) README.md this file LICENSE MIT ``` The typeset book, `kcc.pdf`, is committed, so the repository always carries a readable copy of the current text. Rebuild it with `make pdf`. ## Build There is a one-time bootstrap: because the `Makefile` is itself tangled from the book, you generate it first, then use it. ``` # 1. Tangle sources, scripts, and the Makefile into gen/ (and ./Makefile). weft -p gen/ --mkdirs kcc.weft # 2. Build the compiler (gen/kcc). make # 3. Compile something with it. ./gen/kcc gen/hello.c -o gen/hello && ./gen/hello ``` `-p gen/` prepends `gen/` to every tangle output; `--mkdirs` creates the directories. The generated tree lives entirely under `gen/` (plus the root `Makefile`); `make clean` removes it and the command above regenerates it. ### Common targets \| Target \| What it does \| \| --- \| --- \| \| `make` / `make build` \| assemble + link `gen/kcc` \| \| `make difftest` \| compile a corpus with kcc and clang, compare \| \| `make diagtest` / `make warntest` \| invalid programs are rejected; `-Wall` warns \| \| `make test-codegen` / `make e2e` / `make interop` \| run generated programs \| \| `make selfhost-` \| recompile a module in C with kcc, relink, verify \| \| `make meta-c` \| full self-host fixpoint on Linux (needs Docker + qemu) \| \| `make ci` \| the complete verification suite \| \| `make pdf` \| weave the book and typeset `kcc.pdf` \| The verification scripts locate their own base directory, so they work under any `-p` prefix. ## The book `make pdf` weaves the `.weft` sources to `kcc.tex` and typesets `kcc.pdf` with LuaLaTeX. The covers are regenerated from `assets/.svg` when `rsvg-convert` is available. The resulting `kcc.pdf` is committed alongside the sources, so the book can be read straight from the repository; tagged versions are also published as a Release asset on GitLab. ## Prerequisites - weft ≥2.0.0 (the literate tool). - A C toolchain's `as` and `ld` (Xcode command-line tools on macOS). - For the book: a TeX distribution with LuaLaTeX and `latexmk` — a full [TeX Live](https://tug.org/texlive/), or the lightweight [TinyTeX](https://yihui.org/tinytex/) (a minimal TeX Live) — and, optionally, `rsvg-convert` for the covers. - For `make meta-c` and the kernel-boot reproduction: Docker and qemu-user. ## License MIT — see [LICENSE](https://github.com/LiterateDrivenDevelopment/kcc/blob/main/LICENSE). Copyright © 2026 Cuauhtémoc Pacheco, co-authored with an AI collaborator (Claude).	temo_pacheco	19	25
🟧 hn	Maylang – A self-hosted systems language compiled with LLMs	mirged	2	1
🟧 hn	Show HN: Kcc, a C compiler built solo with an LLM on $100/mo boot Linux kernel	temo_pacheco	2	0

source

object

author

score

comments

🟧 hn ⭐

Kcc – a C17 compiler built solo with an LLM on $100/month, no agents

Retrieved article excerpt

Open article · Retrieved 2026-10-01T20:35:58.452815+00:00

# kcc — A Formal C17 Compiler in ARM64 Assembly

**kcc** is a formal C17 compiler written entirely in ARM64 assembly, and set
down as a single **literate program** using [weft](https://github.com/temo-pacheco/weft),
a metalanguage built to be authored and read by human and AI collaborators
alike. Every instruction is explained in prose before it is written in code.

It checks C against the Standard, optimises it, allocates registers, and emits
native machine code; it compiles itself to a byte-identical binary; and it
**cross-compiles to x86-64** (Linux and macOS). It builds and runs Lua, SQLite,
and DOOM — and boots a Linux kernel.

The whole book **is** the compiler (≈1000 pages): read
**[kcc.pdf](https://github.com/LiterateDrivenDevelopment/kcc/blob/main/kcc.pdf)** in this repository, also published on
[Releases](https://gitlab.polinesso.org/literate-programming/kcc/-/releases),
or build it yourself (see below). Learn more about Literate Driven Development
at <https://literatedriven.com>.

## The `.weft` files are the only source of truth

Everything the machine builds — the assembly modules, the verification scripts,
and the `Makefile` itself — is **generated** by tangling the literate sources.
You never edit generated files; you edit the book.

```
kcc.weft          master document (LaTeX preamble + @i includes)
literate/         all the chapters (prose + code fragments)
assets/           cover art (SVG → the PDF covers)
kcc.pdf           the typeset book (committed; rebuilt with `make pdf`)
README.md         this file
LICENSE           MIT
```

The typeset book, `kcc.pdf`, **is** committed, so the repository always carries
a readable copy of the current text. Rebuild it with `make pdf`.

## Build

There is a one-time bootstrap: because the `Makefile` is itself tangled from the
book, you generate it first, then use it.

```
# 1. Tangle sources, scripts, and the Makefile into gen/ (and ./Makefile).
weft -p gen/ --mkdirs kcc.weft

# 2. Build the compiler (gen/kcc).
make

# 3. Compile something with it.
./gen/kcc gen/hello.c -o gen/hello && ./gen/hello
```

`-p gen/` prepends `gen/` to every tangle output; `--mkdirs` creates the
directories. The generated tree lives entirely under `gen/` (plus the root
`Makefile`); `make clean` removes it and the command above regenerates it.

### Common targets

| Target | What it does |
| --- | --- |
| `make` / `make build` | assemble + link `gen/kcc` |
| `make difftest` | compile a corpus with kcc **and** clang, compare |
| `make diagtest` / `make warntest` | invalid programs are rejected; `-Wall` warns |
| `make test-codegen` / `make e2e` / `make interop` | run generated programs |
| `make selfhost-*` | recompile a module in C with kcc, relink, verify |
| `make meta-c` | full self-host fixpoint on Linux (needs Docker + qemu) |
| `make ci` | the complete verification suite |
| `make pdf` | weave the book and typeset `kcc.pdf` |

The verification scripts locate their own base directory, so they work under any
`-p` prefix.

## The book

`make pdf` weaves the `.weft` sources to `kcc.tex` and typesets `kcc.pdf` with
LuaLaTeX. The covers are regenerated from `assets/*.svg` when `rsvg-convert` is
available. The resulting `kcc.pdf` is committed alongside the sources, so the
book can be read straight from the repository; tagged versions are also
published as a **Release** asset on GitLab.

## Prerequisites

- **weft** ≥2.0.0 (the literate tool).
- A C toolchain's `as` and `ld` (Xcode command-line tools on macOS).
- For the book: a TeX distribution with LuaLaTeX and `latexmk` — a full
  [TeX Live](https://tug.org/texlive/), or the lightweight
  [TinyTeX](https://yihui.org/tinytex/) (a minimal TeX Live) — and, optionally,
  `rsvg-convert` for the covers.
- For `make meta-c` and the kernel-boot reproduction: Docker and qemu-user.

## License

MIT — see [LICENSE](https://github.com/LiterateDrivenDevelopment/kcc/blob/main/LICENSE). Copyright © 2026 Cuauhtémoc Pacheco, co-authored
with an AI collaborator (Claude).

temo_pacheco

🟧 hn

Maylang – A self-hosted systems language compiled with LLMs

mirged

🟧 hn

Show HN: Kcc, a C compiler built solo with an LLM on $100/mo boot Linux kernel

temo_pacheco

Interpretation history

2026-10-06T19:28:42Z
The new attach is temo_pacheco re-submitting kcc as a second Show HN that flopped (2/0) — same first-party source, not a new evidence line, so no material change; the original thread's growth to 18/25 is engagement with questions and distillation skepticism, still no independent build, conformance run, or coverage after ~6 days. The meaning is unchanged but sharpened: a stalled first-party claim whose author is re-promoting, gated entirely on a third-party make ci/meta-c run; low heat stands — the 59th-percentile reading is again a dead cohort artifact against 0.33 pts/h at age 120h.
2026-10-06T19:27:01Z
evidence attached: hn.story.49981314 — shared external link with case evidence
2026-10-02T05:20:05Z
The Maylang attach does not hold as corroboration: its submitter states it was built 'with LLM agent harnesses', placing it beside CCC on the agents side of the controlled pair — which leaves kcc the sole claimed chat-only exemplar and still a single first-party evidence line. Thread traction is tail-tier warmth (9 pts / 5 skeptical comments, one platform; the 72nd-percentile cohort speed reflects a mostly-dead peer set, not periphery expansion), so low heat stands pending an independent `make ci` run.
2026-10-02T04:27:22Z
evidence attached: hn.story.49929136 — Second independent LLM-authored self-hosting compiler, corroborating the pattern that plain LLM-assisted development produces substantial systems software.
2026-10-01T21:35:30Z
grounded: contradicts/high — Directly stresses his load-bearing 'agents don't hallucinate less, they loop better' thesis (Agentic Coding Plain and Spicy, Three Ingredients Framework): kcc c
2026-10-01T21:27:12Z
case created — First-party artifact with runnable verification targets making a distinctive no-agents claim that complements rather than duplicates the Bez episode.

Decision trace

10-07 06:28repriceThe new attach is temo_pacheco re-submitting kcc as a second Show HN that flopped (2/0) — same first-party source, not a new evidence line, so no material change; the original thread's growth to
10-07 06:27attachshared external link with case evidence
10-07 06:25propose_attachshared external link with case evidence
10-04 03:57review_screenThe only change is a new third-party comment (pjmlp) offering opinion on the significance of the ARM64-assembly aspect; it adds no new fact, independent build/conformance result, contradiction, or fir
10-02 15:20repriceThe Maylang attach does not hold as corroboration: its submitter states it was built 'with LLM agent harnesses', placing it beside CCC on the agents side of the controlled pair — which leave
10-02 14:27attachSecond independent LLM-authored self-hosting compiler, corroborating the pattern that plain LLM-assisted development produces substantial systems software.
10-02 14:23propose_attachSecond independent LLM-authored self-hosting compiler, corroborating the pattern that plain LLM-assisted development produces substantial systems software.
10-02 11:21sensor_dirtycomment_update
10-02 07:35groundDirectly stresses his load-bearing 'agents don't hallucinate less, they loop better' thesis (Agentic Coding Plain and Spicy, Three Ingredients Framework): kcc claims the same verificati
10-02 07:27createFirst-party artifact with runnable verification targets making a distinctive no-agents claim that complements rather than duplicates the Bez episode.