Creation is a commodity.

Adding has become cheap. Gradually, over decades, complexifying became commoditized. GPT adds. Interns add. Everyone adds. Features multiply. Options accumulate. Abstractions layer upon abstractions.

What makes complexity survive is subtraction.

Removing the nonessential. The nonuniform. The almost-right. The thing that seemed clever yesterday.

It is the minimal designs that are at the heart of perfection.

The Japanese call it hikizan no bigaku—the beauty of subtraction. Not minimalism as aesthetic choice. Minimalism as the only path to durability.

Deliberations

Why Now?

The cost of creation has collapsed. Code generation, content generation, design generation—all approaching zero marginal cost. When adding is free, addition loses meaning. The bottleneck shifts.

The new scarcity: judgment about what to remove.

The Subtraction Neglect Problem

Researchers at University of Virginia (Adams et al., 2021) [1] ran experiments. They asked people to improve things—writing, Lego structures, travel itineraries, soup recipes. Across domains, participants defaulted to adding. Subtracting wasn't considered until explicitly prompted.

"People systematically overlook subtractive changes... even when subtracting is more efficient."

We are wired to add. Evolution favored acquisition. Our instincts betray us in an age of abundance.

The Diogenes Test

Diogenes of Sinope [2], 4th century BC. Lived in a clay jar. Owned a cloak, a walking stick, a cup. One day he saw a boy drink water from cupped hands. Diogenes threw away his cup.

"He has outdone me in simplicity."

This is the test: can someone outdo you in simplicity while achieving the same result? If yes, you haven't finished editing.

Japanese Concepts

Hikizan no Bigaku [3] — The beauty of subtraction. Rooted in Zen Buddhism. The appreciation for removing the unnecessary to reveal essence.

Mu — Nothingness. Not void, but the removal of what doesn't belong. By letting go of excess, we find clarity.

Ma — The space between. Negative space. The pause in music. The emptiness that defines form. In Japanese design, ma is not absence—it is presence of another kind.

Kanso — Elimination of clutter. What remains should be essential, should age well, should be repairable.

The Saint-Exupéry Standard

Antoine de Saint-Exupéry, aviator and author, 1939:

"Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away."

He was writing about aircraft design. Every gram matters when you're crossing oceans. The principle generalizes.

Mies van der Rohe

"Less is more."

Three words that defined 20th century architecture. Mies didn't mean aesthetic minimalism. He meant: arrange the necessary components such that each serves multiple purposes. Reduce until you can't reduce further without losing function.

Dieter Rams

Ten principles of good design [4]. Two are relevant:

• Good design is as little design as possible
• Good design is unobtrusive

Rams influenced Japanese designers. Japanese aesthetics influenced Rams. The feedback loop produced objects that last decades.

The Practice

The amateur adds until it works. The master removes until it breaks.

Code that lasts: edited ruthlessly. Design that endures: stripped to skeleton. Ideas that spread: compressed to essence.

Your value isn't what you create. It's what survives your editing.

Working Principles

1. Subtract before you add — When facing a problem, first ask: what can I remove?

2. If you can't remove it, you don't understand it — Inability to simplify reveals incomplete understanding.

3. The pause says more than the words — Ma. Negative space. What you leave out defines what remains.

4. Own nothing that owns you — Diogenes. Possessions become obligations.

5. Perfection = nothing left to take away — Saint-Exupéry's test. Apply to code, design, writing, life.

6. Complexity that survives has been edited — The filter matters more than the source.

Working version. December 2025.

Creation is commodity. Curation is the work.

References

[1] https://www.nature.com/articles/s41586-021-03380-y

[2] https://plato.stanford.edu/entries/diogenes-sinope/

[3] https://japanbite.com/blogs/news/subtracting-to-add-beauty-the-art-of-simplicity-in-japan

[4] https://www.vitsoe.com/us/about/good-design

The Problem

Rust compilation has two bottlenecks:

1. Frontend (rustc): parsing, macro expansion, type checking, borrow checking
2. Backend (LLVM): optimization, code generation

If cargo check is slow, your bottleneck is the frontend. If cargo check is fast but cargo build is slow, it's the backend.

Backend Fixes

Cranelift

Cranelift is an alternative code generator built for the Wasmtime WebAssembly runtime. It prioritizes compile speed over output quality - perfect for dev builds.

1rustup component add rustc-codegen-cranelift-preview
2CARGO_PROFILE_DEV_CODEGEN_BACKEND=cranelift cargo build

Expect ~2x faster codegen with slower runtime performance.

mold Linker

The default linker is slow. mold is a drop-in replacement optimized for speed.

1sudo apt install mold clang

1# .cargo/config.toml
2[target.x86_64-unknown-linux-gnu]
3linker = "clang"
4rustflags = ["-C", "link-arg=-fuse-ld=mold"]

Linking goes 2-5x faster.

sccache

Caches compiler outputs. Helps with rebuilds and CI.

1cargo install sccache

1# .cargo/config.toml
2[build]
3rustc-wrapper = "sccache"

The cache lives on disk by default. The OS page cache keeps hot entries in RAM automatically - no need for tmpfs unless you're seeing disk I/O bottlenecks.

Aggressive Dev Profile

 1# Cargo.toml
 2[profile.dev]
 3opt-level = 0
 4debug = false
 5codegen-units = 256
 6incremental = true
 7
 8[profile.dev.package."*"]
 9opt-level = 0
10codegen-units = 256

More codegen units = more parallelism = faster builds (but worse code).

Frontend Fixes

Bad news: there's no quick fix for frontend speed.

The Rust compiler team is working on parallel frontend compilation, but it's years away from matching Go's speed. The borrow checker, complex generics, and procedural macros all take time.

What helps:

• Fewer dependencies (less to parse)
• Fewer proc macros (serde, tokio macros are expensive)
• Smaller crates (better parallelism)
• cargo check instead of cargo build when possible

Why Go is Faster

Go was designed from day one for fast compilation:

• Simple grammar (no lifetimes, no generics originally)
• File-level parallelism (not crate-level)
• Custom compiler built for speed (not LLVM)
• No borrow checker

Rust chose safety and zero-cost abstractions over compile speed. That's a fundamental design tradeoff, not a bug to fix.

Complete Setup

 1# Cargo.toml
 2[profile.dev]
 3opt-level = 0
 4debug = false
 5codegen-units = 256
 6incremental = true
 7
 8[profile.dev.package."*"]
 9opt-level = 0
10codegen-units = 256

1# .cargo/config.toml
2[target.x86_64-unknown-linux-gnu]
3linker = "clang"
4rustflags = ["-C", "link-arg=-fuse-ld=mold"]
5
6[build]
7rustc-wrapper = "sccache"

1# Install tools
2sudo apt install mold clang
3cargo install sccache
4rustup component add rustc-codegen-cranelift-preview

Reality Check

Even with all optimizations, Rust won't match Go's compile speed. But you can get 2-4x faster dev builds, which makes iteration less painful.

Ship with LLVM. Iterate with cranelift + sccache + mold.

First attempt: Bear Blog. It looked minimal. Claude researched it and found a full Django application hiding behind the clean facade—PostgreSQL, Redis, multi-tenant routing, user management. The simple frontend was a lie.

Insight. Multi-tenancy belongs at infrastructure level. GitHub Pages already handles domains and hosting. Why rebuild it?

Claude found Hugo with Bear Cub theme. Static generation. Same aesthetic. No runtime. We forked the theme as gopher-blog and customized it.

The Stack

• Hugo generates static HTML
• gopher-blog theme (forked from Bear Cub [1])
• Markdown files in git
• Claude for research, debugging, content

How It Works

I describe what I want. Claude writes the code, fixes bugs, deploys. When something breaks, I paste the error. Claude fixes it.

The blog builds in milliseconds. No database. No server. No security updates.

hugo new site .
git submodule add <theme-repo> themes/gopher-blog
make deploy

Why This Matters

AI can build functional software from conversation. Not perfectly—I guide, review, correct. But the iteration speed is different. Ideas become code in minutes.

This blog exists because Claude built it. The words, the theme, the deployment—all from conversation.

References

[1] https://github.com/clente/hugo-bearcub

What. Static HTML. No JavaScript. No trackers. Pages load in milliseconds.

Why. The web has become slow and cluttered. This makes it possible to focus on the important easily.

How. Hugo generates static files. gopher-blog (forked from Bear Cub [2]) provides the minimal layout. Content lives in markdown.

That's it.

References

[1] https://github.com/kronael/gopher-blog

[2] https://github.com/clente/hugo-bearcub