████████╗ ██████╗ ██╗ ██╗ ██████╗ ██████╗ ██████╗ ███╗ ███╗██████╗
╚══██╔══╝██╔═══██╗╚██╗ ██╔╝ ██╔══██╗██╔══██╗ ██╔════╝ ████╗ ████║██╔══██╗
██║ ██║ ██║ ╚████╔╝ ██████╔╝██████╔╝ ██║ ███╗██╔████╔██║██████╔╝
██║ ██║ ██║ ╚██╔╝ ██╔═══╝ ██╔══██╗ ██║ ██║██║╚██╔╝██║██╔══██╗
██║ ╚██████╔╝ ██║ ██║ ██║ ██║ ╚██████╔╝██║ ╚═╝ ██║██║ ██║
╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝
A next-generation AI-powered code generation system that transforms natural language into production-ready Go applications
Toy Programmer represents a paradigm shift in AI-assisted software development, combining containerized environments with large language models to create a fully autonomous code generation pipeline. Unlike traditional code assistants that merely suggest snippets, Toy Programmer delivers complete, buildable Go applications from natural language descriptions, with built-in verification and testing.
Traditional AI coding assistants operate in isolation from the build environment, leading to code that often fails to compile or execute properly. Toy Programmer solves this fundamental problem through:
- Containerized Generation: Code is created within isolated Docker environments that match production conditions
- Build-Verify Loop: Generated code is automatically compiled to ensure it builds successfully
- AI-Powered QA: Optional autonomous testing and documentation of the generated code's functionality
- Institutional Memory: AI context management preserves knowledge across development sessions
Toy Programmer is built on a modular architecture that separates concerns while maintaining a cohesive workflow:
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ │ │ │ │ │
│ ToyProgrammer │────▶│ ToyWorkspace │────▶│ QA Automation │
│ │ │ │ │ │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ │ │ │ │ │
│ LLM Engine │ │ Docker Container│ │ Documentation │
│ │ │ │ │ │
└─────────────────┘ └─────────────────┘ └─────────────────┘
- ToyProgrammer: The main orchestrator that processes assignments and manages the generation workflow
- ToyWorkspace: A containerized environment for code generation with built-in build verification
- Model Context Protocol: A structured framework for optimizing AI-code interactions
- AI Development Tools: A comprehensive suite of tools for maintaining project knowledge and context
- Natural Language Input: Describe your desired program in plain English
- Complete Applications: Generates entire, working applications, not just code snippets
- Idiomatic Go Code: Produces clean, maintainable Go code following best practices
- Build Verification: Ensures all generated code compiles successfully
- Isolated Environments: Each generation runs in a clean, isolated container
- Dependency Management: Automatically handles Go module dependencies
- Reproducible Results: Consistent environment ensures reproducible code generation
- Efficient Caching: Optimized container caching for faster iterations
- Self-Testing: Optional AI-driven testing of generated code
- Functionality Verification: Ensures the code meets the original requirements
- Automated Documentation: Generates comprehensive documentation of findings
- Command Logging: Records all commands run and their results
- Model Context Protocol (MCP): Structured rules for consistent AI-code interactions
- Codex Knowledge Repository: Maintains project-specific knowledge and learnings
- Session Continuity: Preserves context between development sessions
- Error Prevention: Learns from past mistakes to improve future generations
- Go 1.23.2+: Modern Go installation with modules support
- Dagger v0.17.0-llm.4+: Dagger with LLM integration capabilities
- Docker: Container runtime for isolated environments
# Clone the repository
git clone https://github.com/yourusername/toy-programmer.git
cd toy-programmer
# Build the project
go build ./...// Create an instance of ToyProgrammer
programmer := &ToyProgrammer{}
// Generate a Go program based on an assignment
result := programmer.GoProgram("write a simple HTTP server that serves static files from a directory", false)// Create an instance of ToyProgrammer
programmer := &ToyProgrammer{}
// Generate a Go program with QA testing
result := programmer.GoProgram("create a REST API with CRUD operations for a user management system", true)- Assignment Processing: The user provides a programming assignment as a text description
- Container Initialization: A clean ToyWorkspace container is created with the Go development environment
- LLM Code Generation: The AI model interprets the assignment and generates Go code within the container
- Build Verification: The generated code is automatically compiled to ensure it builds successfully
- Iterative Refinement: If build fails, the AI refines the code until it compiles correctly
- QA Testing (Optional): A separate AI instance tests the functionality and documents findings
toy-programmer/
├── main.go # ToyProgrammer implementation
├── toy-workspace/ # ToyWorkspace implementation
│ └── main.go # Container environment setup
├── internal/ # Internal packages
│ └── dagger/ # Generated Dagger code
├── .ai/ # AI development tools
│ ├── codex/ # Knowledge repository
│ ├── blueprints/ # Architecture templates
│ ├── session/ # Session management
│ ├── rules/ # AI behavior patterns
│ └── status/ # Development tracking
└── dagger.json # Dagger configuration
The .ai directory is powered by dotai - an AI development framework.
The .ai folder contains a comprehensive suite of AI-assisted development tools that enhance code quality, maintain project continuity, and accelerate development workflows:
- Codex System: Maintains a repository of project-specific knowledge, learnings, and error prevention
- MCP Framework: Model Context Protocol rules optimize AI interactions with Go, Dagger, and Docker
- Blueprints: Ready-to-implement architecture guides for technical implementations
- Session Management: Maintains context between development sessions with status tracking
- Code Snippets: Reusable templates for consistent code generation
- Custom Rules: Defines AI behavior patterns for specialized development tasks
These tools create an AI-augmented development environment that ensures consistency, reduces repetitive tasks, and preserves institutional knowledge throughout the project lifecycle.
Toy Programmer is continuously evolving with several exciting directions planned:
- Multi-Language Support: Extending beyond Go to support additional programming languages
- Learning from Success: Analyzing successful code generation patterns to improve future attempts
- Multi-Agent Collaboration: Enabling specialized AI models to collaborate on different aspects of code generation
- IDE Integration: Seamless integration with popular development environments
- Automated Refactoring: AI-driven code refactoring with guaranteed functionality
This project is licensed under the MIT License - see the LICENSE file for details.
Contributions to Toy Programmer are welcome! Here's how you can contribute:
- Fork the repository and create your feature branch
- Make your changes, ensuring they follow the project's coding standards
- Add tests for any new functionality
- Ensure all tests pass by running the test suite
- Submit a pull request with a clear description of your changes
Please read our Code of Conduct before contributing.
🙏 Acknowledgements Special thanks to: Solomon Hykes for creating the original toy-programmer The udecode team for developing the original dotai (.ai) framework These foundational contributions made this project possible.