Why I still write raw code instead of prompting the compiler

I know what you're thinking. "Here goes Dave again, yelling at the cloud." You’re probably reading this via your NeuralLink summary anyway, so I’ll try to keep the entropy high enough to bypass the summarizer filters.

Yesterday, I spent four hours writing a Rust function. Just one function. It parses a JSON schema and transforms it into a struct.

My colleague, who is ten years younger and uses GitHub Copilot X-Treme with the direct-to-brain interface, laughed at me. "Dave," he said, sending the thought directly to my headset, "You could have just visualized the outcome and let the Omni-Compiler handle the implementation details. Why are you manually typing curly braces like a caveman banging rocks together?"

He has a point. The Omni-Compiler (v4.2) has a 99.99% accuracy rating. It predicts intention before you even articulate the prompt. It optimizes assembly better than any human ever could. It’s efficient. It’s logical. It’s inevitable.

But I don’t care.

The Death of the Syntax Error

Do you remember syntax errors? Red squiggly lines? The frustration of a missing semicolon in C++ or a borrow-checker fight in Rust circa 2024?

We solved those problems by removing the human element. We don't write syntax anymore; we write intent. We prompt. "Make a login page." "Optimize this database query." "Build a clone of Twitter but for dogs."

But when we stopped writing syntax, we lost something profound. We lost the friction.

Friction is where the understanding happens. When I type a loop manually, I am forced to think about the bounds. When I allocate memory, I feel the weight of those bytes.

The "Black Box" Problem

Last week, AWS-East went down because of a hallucination in the auto-scaling logic generated by GPT-11. Nobody knew how to fix it for six hours. Why? Because the generated code was 40 million lines of highly optimized, unreadable spaghetti that no human had ever looked at.

When I write raw code, it looks like this:

// Hand-crafted by Dave. 0% Generated.
fn calculate_entropy(data: &Vec) -> f64 {
    let mut entropy = 0.0;
    for &p in data {
        if p > 0.0 {
            entropy -= p * p.log2();
        }
    }
    entropy
}

It’s not the most efficient implementation. The Omni-Compiler would have vectorized this, unrolled the loop, and probably written it in raw machine code directly into the binary.

But I know what it does. If it breaks, I can fix it. I possess the source of truth, not a probabilistic model trained on the internet of 2029.

Craftsmanship in the Age of Abundance

Writing raw code in 2035 is like baking your own sourdough bread or shooting on 35mm film. It is inefficient. It is expensive. It is prone to error.

But there is a specific tactile joy in the mechanical clack of my Keychron Q10 (yes, I still use physical keyboards, sue me). There is a dopamine hit when the compiler gives you a green checkmark that you earned, rather than requested.

We are drowning in generated content. Generated art, generated music, generated apps. The world is smooth, polished, and utterly soulless.

I write raw code because it's the only way to prove I'm still here. I write raw code because sometimes, I want to optimize for my own understanding, not for execution speed.

So go ahead, prompt your compilers. Build your apps in 30 seconds. I'll be here, debugging a pointer dereference, and having the time of my life.