Thoughts on Large Language Models and Low Context Window Programming Language (LCWPL)

Recent Experience with AI-Assisted Programming

Recently, I have been using AI to assist with programming, and my biggest impression is that the context window is too small. Although LLM (Large Language Model) capabilities are very strong, due to the large amount of code that needs to be output and remembered in software development, it often forgets what it was doing. If you ask it to only output the code for a single file (a few hundred lines), most current large language models can handle it. This explains why many people’s evaluations of current AI programming capabilities are polarized - many people’s work involves secondary development and optimization of existing systems, which have a large amount of historical code. Current LLMs have difficulty reading and remembering all of this code. This is similar to humans, as no one can accurately remember every line of code in an operating system kernel.

Predictions for the Future of AI-Assisted Software Development

Therefore, it can be predicted that in the near future, AI-assisted software development will split into two branches:

1. AI-agent: in this branch, a large-scale software development project will be broken down into many small functional modules, and each module will be written and tested by an AI-agent that has received specialized training (trained only on relevant code, such as only responsible for writing backend code). This is likely to be a consensus among everyone. The biggest problem with AI-agent systems is that they have high resource overhead, and this idea is not innovative, it’s just using AI to replace humans.
2. A new programming language will be designed with low context overhead (Low Context Window Programming Language, LCWPL). This language will be designed to be suitable for current AI programming, while also ensuring basic syntax that is easy for humans to maintain (at this stage, AI maintenance is still early). Existing languages like Java and C++, which have long class names and complex programming paradigms, will be gradually abandoned (or, with human assistance, automatically translated from Java/C++ to LCWPL and replaced). Systems written in these languages will also be replaced by this new programming language (with this language, it’s not difficult to use AI to rewrite an operating system). Dynamic languages like Python may still survive in academic circles for a while due to their rich libraries, but will eventually disappear like Fortran.

Analysis of Current Programming Languages

Based on my personal experience, the current Go language is very suitable for LLM, mainly because Go’s syntax is simple and the way to solve similar problems is unified, unlike some languages that have multiple styles and a large number of peculiar libraries. This consistency makes it easier for the model to learn the single correct way, reducing context confusion. Similarly, some older, stricter languages (such as Ada, Eiffel) may be revalued in the future due to their normativity and used as the foundation for AI programming. In summary, we can predict that new programming languages will have the following characteristics:

1. They will definitely be compiled languages, rather than dynamic interpreted languages like Python. Because dynamic interpreted languages have high debug complexity for AI (the compilation process will automatically perform more checks, compiled languages will reduce the number of dynamic scenarios that AI needs to track, and compiled languages often have the benefit of explicit types).
2. They will definitely have simple syntax, possibly with syntactic sugar, but will not have many complex programming paradigms. Overly complex programming paradigms will lead to AI understanding confusion. Simplicity and convenience are the best for AI.
3. They will definitely support feature-oriented integration, that is, components will be developed (written by AI) according to the functions set by humans, and will be developed recursively one by one. This also allows AI to thoroughly test the implementation of new functions before incrementally integrating them into the system. In other words, AI will first develop the “skeleton” code (tree structure), and then develop small functional components and hang them on the tree. This programming development basically does not require “scaffolding” (except for underlying program libraries, which may require some scaffolding when building the skeleton, otherwise some components in the skeleton may not be usable before adding specific functions). After hanging the various functions on the skeleton, scaffolding is no longer needed, since each function is self-contained and will include its own supporting code.
4. This programming language will have a mechanism similar to Rust’s borrowing at the syntax level, which can explicitly tell AI which files and functions are strongly associated and which are weakly associated. This way, during development or subsequent modification, AI only needs to read in the associated files and functions, rather than the entire project. This will significantly reduce the overall complexity of system development. This is also similar to human development, where humans focus on their own developed functional modules and a limited number of associated modules, rather than trying to hold the entire system in their brain.

Old languages may not disappear immediately, but from the perspective of maintainability and AI compatibility, the emergence of new languages is a trend.