Code Evolution: Self-Improving Software with LLMs and Python

Code Evolution: Self-Improving Software with LLMs and Python
This repository hosts a workshop designed for PyDay Barcelona 2025, focusing on harnessing the power of Large Language Models (LLMs) combined with evolutionary computation to create software that improves itself. Targeted at individuals with basic Python knowledge and familiarity with APIs, this workshop offers an engaging exploration into self-improving software.

Workshop Overview

What if software could autonomously find and fix its bugs, evolve to deliver better solutions, and even develop new capabilities on-the-fly? This workshop invites participants to engage in hands-on demos covering various self-improvement patterns, progressing from simple error correction to advanced evolutionary coding practices. The practical demonstrations will include:

1. Self-Reparation: Automating the bug-fixing process.
2. Code Evolution: Implementing a genetic algorithm where LLMs serve as mutation operators.
3. The Toolmaker: Creating functionality on-the-go through runtime self-modification.
4. The Evolving Team: Exploring multi-agent competition to improve programming capabilities.

Workshop Structure

Section	Description
Introduction	Theory: Why combine Evolution + LLMs?
Environment Setup	API keys and Google Colab configuration
Demo 1: Self-Reparation	Basic error correction loop
Demo 2: Code Evolution	Genetic algorithms with LLM operators
Demo 3: Toolmaker	Runtime self-modification
Demo 4: Evolving Team	Multi-agent prompt evolution

Demos Explained

Demo 1: The Self-Reparation

Concept: Self-Correction / Reflection
This demo features a script capable of fixing its own bugs by executing code, capturing errors, and prompting an LLM with the buggy code and traceback to receive corrections. This establishes a fundamental feedback loop, where execution results serve as learning signals for self-improvement.

Demo 2: Code Evolution

Concept: Genetic Algorithm with LLM as Mutation Operator
Instead of merely fixing errors, this demo utilizes an LLM to optimize solutions through an evolutionary process. Here, LLM-generated candidates are evaluated, selected, and mutated across generations, culminating in optimized password generation that adheres to complex constraints.

Demo 3: The Agent Toolmaker

Concept: Self-Modification / Hot-swapping
This demonstration showcases an agent's ability to create tools it lacks by detecting requests for missing functionalities, leveraging an LLM to generate new Python functions, and hot-reloading them to meet user demands. This encompasses the evolution of software complexity with continuous use.

Demo 4: The Evolving Dev Team

Concept: Self-Evolving Agent Prompts / Multi-Agent Competition
Two AI developer agents engage in a competitive task to solve coding problems, reflecting on their performance and evolving their prompts autonomously. This competition allows for the discovery of emergent strategies that enhance coding approaches through feedback and revision.

Technical Requirements

To participate in this workshop, users must have:

• A Google account for Colab access
• An API key from one of the following providers:
  • OpenAI (recommended)
  • Google Gemini (free option)
  • Groq (speedy and free)
• A modern web browser

Technologies Employed

• Python 3.10+
• LLM APIs (OpenAI, Google Gemini, or Groq Llama 3.1)
• Google Colab
• TextBlob for sentiment analysis demonstration

Key Learning Outcomes

• Understanding the Feedback Loop: An action leads to an outcome, evaluated and improved via LLMs, enhancing future actions.
• Recognizing LLMs as Intelligent Operators: Utilizing semantic understanding and directed improvement over random exploration in traditional algorithms.
• Exploring Open-Ended Systems: Systems capable of evolving complexity without predefined limits demonstrated effectively through agent toolmaking.
• Engaging with Self-Evolving Prompts: Agents improving their internal instructions through competitive learning and self-reflection.

Safety Considerations

Participants are advised to employ safety measures when executing dynamic code generation, including sandboxing LLM-generated code, validating it prior to execution, and ensuring human oversight for critical modifications.

For more details, check out the presentation slides.

This workshop not only enhances coding skills but also introduces innovative concepts in software evolution, making it a great resource for developers looking to leverage AI for improved programming solutions.