What if NL's ambiguity is the strength rather than the flaw?The usual rebuttal to natural language as the apex abstraction is that compilers are deterministic and NL is not. What if the ambiguity is the strength rather than the flaw?
- 01Code has always been climbing the abstraction ladder.
- 02A spec that pins down every edge case converges on being code. The claim is intent coverage, not precision.
- 03If a spec carries the intent, the code under it could be revised autonomously as the models improve.
WARNING - OPINION:
Arguments welcome. Let's chat
Is code becoming obsolete?
A very popular argument circling around is that natural language pushes out code as the apex abstraction.
These people claim that code has been going through constant evolution where we’ve been raising the abstraction bar: punch cards to Python, which is almost as legible as natural language (hence NL).
Where the blogs stop
A quick popular rebuttal is that compilers are deterministic, and NL is not.
Usually this is where I’ve seen the blogs end. I don’t have a side, but I’d like to propose the following. What if nondeterminism is not a downside, but is actually the greatest strength of NL specs?
It’s important to note that the core argument around code becoming obsolete comes from the notion that we won’t need to interact with it. I don’t think it’s a stretch to state that for the vast majority of SWE tasks, vibe coding outputs will reach the same level of competency as SWE-developed projects.
What is most curious in these arguments for me is a strong rejection of NL becoming the new spec.
The narrow claim
I am not ready to defend the extreme end of the supporting stance, i.e. code is replaced by prompts and docs. I simply want to point out that the ambiguity and lack of singular semantic functions in NL could be advantageous for software quality.
Here I am making two assumptions. First, we will continue to enjoy a substantial degree of improvement in the coding capabilities of LLMs. Secondly, an NL spec can carry the intent behind a unit of software well enough to rebuild it.
That last one is not a claim that NL is more precise or less verbose than code. A spec that pins down every edge case converges on being code. It’s a claim that there is sufficient mechanism and intent coverage.
What I have in mind
As model capabilities improve and new tools and frameworks get introduced, what if the underlying code was semi-autonomously or even fully autonomously revised from the NL specs?
NL can offer a rich view into what thinking was behind the code. If the models can produce working code today, what’s the damage if they produced better code tomorrow?
The reading problem
I still read every line that goes into production. However, it becomes more and more unmanageable as we continue to ramp up the speed of execution. We’ve crossed the point where there’s already more code that can be written than what could be physically read and verified by a human.
And while now it’s mostly garbage in this setting, one day we’ll get closer to the state of magic. Eventually a change is coming, or we’d need to slow down.
Where that leaves me
NL or not, the code as we know it today may not be as future proof as some want to believe. I am personally dying for a better way to validate output.
My only opinion here is that ambiguity is not the enemy.
