Coding in natural language
I’ve been thinking about whether humans need to maintain conventional source code now that machines write most of it. Today, we still treat the generated code as the source of truth, but increasingly the bit we actually care about is the outcome and intent behind it.
What if we moved a step higher? What if natural language was the source code, and conventional code was just the compiled output?
The implementation could be regenerated at will. TypeScript today, Rust tomorrow. Hell, machine code the day after.
This is crazy early, but my first thought is almost three levels:
- Human written spec — the canonical source
- AI written spec — still natural language, fills in the gaps and makes assumptions explicit, anything useful can be promoted to the human layer
- Generated code — disposable implementation
You could get more or less granular with the same system. Your whole app could be a single high-level spec file, or it could be almost 1:1 with the expected source code. A detailed spec would lead to more-or-less the same result every compilation. A less detailed spec could vary each build, which could be useful for prototyping.
You could write “super-powered pseudocode” like:
if user is talking {
wait until they finish, then {
store what they said
transcribe it
summarize themes and store deduped in db
}
}This is completely language agnostic. The compiler can convert to Ruby, TypeScript, Assembly, anything. The implementation can be thrown away and regenerated at will, or generated in multiple languages, or for different targets.
It’s almost like a pure function (as much as something non-determinstic can be). Stable intent in -> implementation out. The contract can stay fixed while the implementation stays fluid.
Instead of trying to figure out which bits of the context in your long running LLM conversations mattered, it’s right there in front of you. Like code but way higher level. Easy to read regardless of whether you know how to code. A place to embed human judgement and requirements, without getting bogged down in details that don’t matter to the product.
Maybe we find it hard to give up source code because we’ve spent decades putting so much time and effort into it.
Now machines can write it, perhaps we can let go and focus on what matters: what we’re trying to build.