I Taught My JavaScript AI to Rewrite Its Own Code

What if the AI systems we build could take an active role in their own evolution? This is the question that drove my latest experiment.

Many of you are familiar with my from-scratch neural network library, slmnet. After porting it from the browser to Node.js, I set myself a challenge: to stay within a pure JavaScript and Node.js environment. No Python wrappers, no C++ bindings. This constraint was intentional—it forced a deeper understanding and ensured that every part of the system was transparent and malleable.

This foundation allowed me to explore a fascinating, advanced AI concept: creating a system that could learn to optimize itself.

I architected a high-level supervisor, the Meta-Controller, designed to guide an AI agent (powered by slmnet itself) through a cycle of self-improvement. The process is a fully automated loop:

1. Benchmark: The cycle begins by measuring the current performance of the slmnet library. A standardized script runs a short training session and outputs two key metrics: final loss (accuracy) and execution time (speed). This gives us a hard, numerical baseline.




2. Analyze & Decide: The Meta-Controller then presents the AI agent with a choice. It shows it the current, stable code of a core file (e.g., Ops.js) and a pre-written "mutation"—an alternative version containing a potential optimization. The AI's task is not to generate complex code from nothing, but to act as an engineer in a code review. It must analyze the difference, form a hypothesis, and make a simple, critical decision: is this change worth testing?




3. Automated Testing: If the AI agrees, the Meta-Controller temporarily overwrites the live code with the proposed mutation. It then immediately re-runs the exact same benchmark to measure the impact of the change.



4. 
   

   Evolve or Revert: This is the core of the feedback loop. The new performance metrics are compared to the baseline.

   
   
   
   
   
   • If the change was beneficial—faster execution or a lower loss—it's deemed a successful evolution. The new code becomes the new standard.
   
   
   • If the change was detrimental or made no difference, it’s a failure. The Meta-Controller instantly reverts the code back to its last known stable version.
   
   
   
   

The first time I ran this loop, the AI—being very new—produced a nonsensical answer. But the system itself performed flawlessly. It correctly identified the invalid response, logged the failure, and maintained the stability of the codebase without human intervention. The architecture for self-optimization was proven to work.

What this experiment demonstrates is that the core concepts of meta-learning and self-improving systems are not exclusively the domain of massive, closed-off models. We can build, test, and understand these feedback loops using accessible tools. By confining the project to pure JavaScript, I built a transparent testbed where the process of an AI reasoning about its own code is not a black box, but a clear, observable engineering cycle.

https://github.com/Xzdes/reasoningHeuristicAI