In my daily work, “vintage coding” (old-fashioned way) is becoming increasingly rare, replaced by all-day “Vibe Coding.” AI now dominates nearly every layer of the coding workflow: it is faster, often more accurate, and increasingly hard to ignore. Yet, staring at the Scala and Python code generated by AI, I often feel an absurd sense of dislocation, especially after my company migrated its AI tooling from Cursor to Codex and Claude Code.
On the other side of the input box sits an agent capable of understanding complex contexts and even proactively planning system architectures. On my end, however, I often find myself lazily typing micromanaging commands such as, “Change this for loop to a map here.” Watching AI obediently generate Scala code for me evokes a strange feeling: it is like asking a robot to operate an abacus for arithmetic.
When we use natural language to command or even “micromanage” AI into executing details that could be handled by higher-level abstractions, we are using a highly capable reasoning system as a low-level translator. Machines operate on a logic grounded in silicon circuits and binary computation, which is worlds apart from humans manually flicking beads on an abacus. Following this logic: if AI’s coding capabilities continue to evolve, its ultimate form of problem-solving probably shouldn’t be writing high-level language code designed for human readability.
The Machine’s Native Tongue#
My first compiler course at the University of Waterloo was CS 241. I remember a bonus question in the first assignment: write an O(nlogn) sorting algorithm in Assembly. That was my first intuitive taste of how programmers “flicked abacus beads” in the “barbaric era” of computing: you had to force your brain to simulate the CPU’s operation: rote-memorizing register numbers, manually calculating memory offsets, and painstakingly handling convoluted jump instructions.
This is precisely why we desperately needed high-level languages. Over the past half-century, countless pioneers have created and iterated upon hundreds of programming languages, from Fortran and C to Java and Python. Their core evolutionary objective has always been singular: to liberate humans from the underlying logic of machines.
Thus, we got variables and loops, later introduced object-oriented programming, and eventually layered on syntactic sugar and garbage collection mechanisms. The ultimate purpose of these designs was never to make machines run more efficiently, but to minimize human cognitive load. High-level languages are, in essence, an “anthropomorphic coat” draped over code to make machines adapt to human thinking habits. We willingly sacrificed some execution efficiency in exchange for readability, maintainability, and the possibility of team collaboration.
But herein lies the problem.
When AI becomes the primary producer of code, this “coat” tailor-made for humans suddenly becomes redundant, or even a burden.
AI doesn’t need sweet syntactic sugar, camelCase naming that aligns with human intuition, or layers of abstraction wrapped for “readability.” For large language models, parsing a structured JSON, an abstract syntax tree, or even directly generating low-level Intermediate Representation is far more efficient, accurate, and likely consumes significantly fewer tokens than generating Python code that strictly adheres to PEP8.
We spent decades meticulously designing a set of languages to make it easier for humans to understand machines. Yet now, we are forcing an agent that can inherently understand machine logic to wear this linguistic coat and “report” its work to us line by line.
This is the root of “robots using abacuses”: we possess the capability to parse high-dimensional logic, yet we still rely on low-dimensional text formats, compromised for human visual habits, as the sole medium for human-machine collaboration.
The Migration of Trust#
Theoretically, I should review AI-generated code line by line. In reality, I rarely scrutinize it closely. More often than not, my approach is to have the AI write a set of test cases, and then use those to verify the reliability of the code it just wrote. I believe this is far from an isolated case among my colleagues, especially as the speed and volume of code generation grow exponentially. This raises a sharp question: if humans no longer review code line by line, what exactly serves as the safety net for a product’s security and stability?
The Industrial Revolution actually provided the perfect metaphor long ago: we never trust an assembly-line car by manually dismantling its engine; instead, we rely on crash tests, certification standards, and long-term quality statistics. Software engineering might be undergoing a similar “paradigm shift of trust.”
Taking a step back, was our traditional Code Review ever truly reliable? Faced with complex business logic, most of the time, rather than verifying the absolute correctness of a program, we are merely checking if the architecture is reasonable, if there are any obvious bugs, and if team conventions are followed. In essence, this is just a “heuristic check” based on human experience.
When faced with AI-generated code that far exceeds human reading limits, this heuristic check will completely fail. What will inevitably replace it is a system-level, automated verification pipeline led by machines, no longer relying on the human eye.
I cannot accurately predict the final form of this system-level verification pipeline. It might be full-stack continuous validation spanning from code generation to runtime, rather than just gatekeeping tests before deployment. Or, as my friend Leni is currently exploring, it might evolve toward mathematical proofs based on formal methods, replacing probabilistic guessing with rigorous logic. But regardless of how the technical paths converge, I am certain of one irreversible trend: when “trust” no longer relies on humans reading code line by line, the high-level languages we are familiar with today—compromised for human cognitive habits—will inevitably be completely replaced in the near future.
The Shadow of the Black Box#
Rationally, I accept this relinquishment of control. Just as modern humans have long abandoned the skills of surviving bare-handed in the primeval jungle in exchange for the conveniences of modern civilization, surrendering absolute control over underlying code is an inevitable cost of technological evolution.
Yet, deep down emotionally, the unease remains like a shadow. Having grown up watching sci-fi movies like The Matrix, we have a bone-deep vigilance against “creation turning against its creator.” Today, watching the human hand on the machine’s steering wheel grow increasingly loose, that subtle dread of the unknown black box is something no perfect test case can ever completely soothe.