I had been trying to write a complex piece of software to test the true capabilities of existing AI coding agents. The idea was to build a Python like compiler native to a web framework. The compiler is completely written in JavaScript. The user is given a window to enter Python like code that closely follows Python syntax. In the backend, the script is tokenized and then interpreted on the fly to produce results.
Initially, the goal was to understand how the Python compiler works under the hood. I knew that existing language models have a strong understanding of Python because the internet is full of Python code and the world is full of Python developers. So, I had a fair expectation that coding agents could generate a decent Python compiler implementation. Since a staggering amount of the web is written in JavaScript, coding agents are also good at JavaScript. So, in relatively little time and effort I was able to get a basic compiler running within a few days. Later I added support for classes, with statements, and basic decorators as the need arose.
One interesting observation was the importance of asking coding agents to create modular and extensible components. Missing this in the early stages is disastrous. As the codebase grows large, it becomes unmanageable to modify or add new features without breaking the existing architecture. Software is full of such tradeoffs, and engineers make these decisions daily without explicitly documenting the thought process. In the beginning, AI can quickly create folder structures, modularize the code, build frontend UI components, backend APIs, and hook them together. From zero to a demonstration level system, code generation is rapid. It starts working quickly. However, poor architectural decisions made early on constrain future development. Navigating these increasingly complex landscapes becomes difficult.
You can check this web python animation framework here https://manim.varunrao.com/
Software development using AI tools has what I call a butterfly effect. When developing from scratch, each word you feed into the AI coder can come back to haunt you later. If that were the only issue, it would not be so troublesome. The real problem is that the keywords you miss also come back later. For example, you might forget to say make sure the code is well modularized to support future features.
As the codebase grows larger, a few prompts are not enough to bring it to production. It involves hundreds of fine-tuned features to meet client requirements. The same developer is still needed to craft prompts and align the software with business needs. The business context itself becomes the bottleneck for AI to make fine grained decisions. A fully autonomous AI would require complete knowledge of the world and deep understanding of the business context along with tradeoffs that comes from the hardware constraint. That level of awareness is still far from reality.
Optimization is another area where AI frequently falls short. In the application I was building, the compiled Python DSL bakes basic shapes and animations over time. Optimizing bloated code required careful evaluation to decide which optimization efforts were actually worthwhile. One might ask why not simply tell the AI to optimize everything. This is risky. The codebase had grown to tens of files with hundreds of lines in each. Blind optimization could break working functionality or worsen performance in unexpected areas. Asking the AI to write unit tests at each stage and ensuring the code is modular enough to test without needing full context of the entire codebase proved to be very good practice. After every incremental feature addition, it is essential to run unit tests and verify that existing test cases still pass. Along with unit testing, integration testing ensures that new features continue to work with other modules.
Every codebase has its own development and production setup. There is no generic prompt that makes AI handle this automatically. A well-crafted folder structure and well-chosen dev and prod environments go a long way in making AI assistance sustainable and reducing manual effort over time.
In conclusion, this experience convinced me that this is a golden era for good software developers. If we have an idea, we can focus on the holistic vision instead of worrying about memory allocation or repeatedly debating design patterns. We are still far from AI making us completely redundant.
Discussion
0Join the conversation
Sign in with Google to post your thoughts, reply to other readers, and like insightful reflections.
No comments yet.
Be the first to share an insight or question.