Building AutoMaintainer: An AI Engineering Team That Handles Your GitHub Issues

okuhlecharlieman — Fri, 05 Jun 2026 12:36:51 +0000

TL;DR

I built AutoMaintainer, a multi-agent AI system that transforms GitHub issues into production-ready pull requests during the Qwen Cloud AI Hackathon. It coordinates specialized agents (Issue Analyst, Developer, QA, Security, Documentation, Reviewer) to solve problems like a real engineering team—all while keeping humans in control. Here's what I learned.

The Problem

Open-source maintainers face a brutal reality:

📚 Overwhelming issue backlogs
🔄 Repetitive bug fixes and documentation gaps
⏱️ Code review bottlenecks
😴 Burnout from handling everything solo

Existing AI tools help write code, but they don't orchestrate the entire workflow: planning, development, testing, security review, documentation, and human approval.

What if we could build an AI engineering team that collaborates like real developers?

The Solution: AutoMaintainer

AutoMaintainer is a multi-agent orchestration system that mirrors a real software company:

Issue Analyst – Reads GitHub issues, extracts requirements, assesses severity
Architect – Analyzes repo structure, designs the implementation approach
Developer – Writes code, updates files, creates new modules
QA Tester – Generates tests, validates fixes, checks edge cases
Security Agent – Scans for vulnerabilities, prevents dangerous patterns
Documentation – Updates changelogs, PR summaries, release notes
Reviewer – Scores code quality, recommends improvements
Human Approval Gateway – Final human review before merge

The result? A pull request that's analyzed, built, tested, secured, documented, and reviewed—all before a human ever sees it.

Tech Stack

Frontend

Next.js – React framework for the dashboard UI
Tailwind CSS – Rapid, utility-first styling
TypeScript – Type safety for the frontend layer

Backend

FastAPI (Python) – Lightweight, async-first API
Qwen-compatible LLM API – AI model integration for all agents
SQLite + Async (aiosqlite) – Persistent pipeline and memory storage
Redis-ready architecture – Prepared for distributed queuing

Integrations

GitHub API – Issue fetching, context retrieval, PR creation
Docker sandbox – Isolated code execution environment

Deployment

Vercel – Frontend hosting
FastAPI + Uvicorn – Backend server
Prepared for Alibaba Cloud – Scalable backend infrastructure

Key Learnings

1. Agent Orchestration is Hard (But Worth It)

Managing multiple AI agents requires careful state management. Each agent needs:

Clear system prompts defining their role
Access to shared context (repo info, previous agent outputs)
Structured output formats
Error handling and recovery

Lesson: Use TypedDict/Pydantic models for inter-agent communication. Don't let agents operate in silos.

class BaseAgent(ABC):
    async def execute(self, pipeline: PipelineRun, context: Dict[str, Any]) -> Dict[str, Any]:
        # Each agent receives pipeline state + shared context
        pass

2. Human Approval is Non-Negotiable

Full automation sounds great until your AI agent merges a breaking change. The approval gateway—where humans review before merge—is the most important feature.

Lesson: Build trust through transparency. Show humans exactly what changed, why, and what the risks are.

3. Context is Everything

Agents perform better when they have:

Repository structure and file tree
README and documentation
Previous PRs and patterns used before
Code analysis from GitHub

Lesson: Invest in a memory system early. Store patterns, decisions, and failed attempts. Your second PR fix will be 10x better.

4. LLM Integration Requires Fallbacks

Qwen API calls can fail. Responses might be malformed JSON. Rate limits matter.

Lesson:

Implement retry logic with exponential backoff
Validate all LLM outputs
Have graceful degradation for non-critical agents
Monitor token usage and costs carefully

5. FastAPI's Async Model is Perfect for Agent Pipelines

Since agents run sequentially and each calls an LLM (I/O bound), async/await handles pipeline execution beautifully.

async def _run_pipeline(self, pipeline: PipelineRun, issue_body: str):
    # Run agents sequentially with async I/O
    await self.agents[AgentRole.ISSUE_ANALYST].execute(pipeline, context)
    await self.agents[AgentRole.ARCHITECT].execute(pipeline, context)
    # ... and so on

Lesson: Async from the start. Don't retrofit it later.

6. Testing AI Agents is Different

You can't just assert outputs are correct. Instead:

Mock the LLM responses for deterministic tests
Test that agents properly update pipeline state
Verify error handling and fallback paths
Use demo/example pipelines to showcase behavior

7. GitHub Integration is Underrated

GitHub's API is powerful but requires:

Proper pagination for large repos
Tree fetching for architecture context
Webhook handling for issue triggers
PR creation with proper formatting

Lesson: Read the GitHub API docs thoroughly. Small mistakes break your integration.

8. Qwen Models Are Excellent

Qwen-plus and Qwen-turbo performed well for:

Code analysis and generation
Structured reasoning
Following system prompts
Cost-effectiveness

Lesson: Qwen-compatible APIs are a solid alternative to closed models. Fast iteration during hackathons.

What Surprised Me

1. The value of specialized roles

I initially thought one "super agent" could do everything. Nope. Splitting concerns (analysis → planning → development → review) creates a pipeline where each step can fail gracefully and be improved independently.

2. Memory is a game-changer

After the first PR, the system learned the repo's patterns. The second issue fix was significantly better because the agents had context about previous decisions.

3. Security agents caught real issues

I expected security scanning to be a formality. It flagged actual vulnerabilities and dependency risks that other agents missed.

4. Humans still want to understand the "why"

Even if the AI is 99% confident, reviewers want to see:

What problem was solved?
Why was this approach chosen?
What alternatives were considered?

This means good documentation and explainability matter more than raw automation.

Challenges

1. Rate Limiting & Cost

Running multiple LLM calls per issue adds up fast. Caching agent responses and batching requests helps.

2. Handling Complex Repos

Large codebases with thousands of files are hard to summarize for LLM context windows. Need better summarization + semantic search.

3. Error Recovery

When an agent fails (malformed code, test failures), how do we recover? Current approach: retry with more context. Future: ask a different agent for help.

4. Async Debugging

Multi-agent pipelines running concurrently are hard to debug. Structured logging is essential.

Results

✅ Issues → PRs: Can process a GitHub issue from analysis to ready-for-review PR

✅ Human-in-the-loop: Maintainers always approve before merge

✅ Multi-agent coordination: Agents share context and build on each other's work

✅ Qwen integration: Smooth LLM API integration with fallback handling

✅ Deployed: Frontend on Vercel, backend ready for cloud deployment

What's Next

Improve context summarization – Better handling of massive codebases
Add caching layer – Reduce LLM calls for repeated patterns
Deploy to Alibaba Cloud – Scale the backend for concurrent pipelines
Contributor onboarding – Use agents to generate learning roadmaps for new contributors
Multi-repo learning – Train on patterns across multiple open-source projects

Key Takeaway

Building an AI engineering team isn't about replacing developers—it's about amplifying maintainers.

AutoMaintainer shows that by combining specialized agents, human oversight, and smart integrations, we can tackle the real bottleneck in open-source: turning ideas into tested, reviewed, production-ready code.

The hackathon forced me to ship something real in a short time. That constraint was valuable. It pushed me to focus on the core workflow (issue → plan → code → test → review → approve) instead of getting lost in feature creep.

If you're an open-source maintainer drowning in issues, or an AI engineer curious about multi-agent systems, check out the repo: https://github.com/okuhlecharlieman/AutoMaintainer

Thank You

Huge thanks to:

Qwen & Alibaba Cloud for the hackathon and excellent LLM API
GitHub for the robust API
FastAPI & Next.js teams for excellent frameworks
Open-source maintainers everywhere for the inspiration

Let me know what you build next. 🚀

Want to discuss multi-agent systems, LLM integration, or open-source automation? Drop a comment below!

Tags: #ai #hackathon #agents #opensource #qwen #fastapi #nextjs

🚀 From Idea to v13: Building a Positive Youth "Hub" in 48 Hours with AI

okuhlecharlieman — Tue, 05 May 2026 11:22:27 +0000

What happens when you combine the energy of a digital community center with the power of generative AI? You get Iyk Hub—a safe space for youth to play, create, and find real-world opportunities.

I recently entered the Build with MeDo Hackathon, and it completely changed my perspective on rapid prototyping. Here is how I took a complex community vision and turned it into a full-stack reality using MeDo.

🎯 The Vision: A "Kasi" Community Center
In many communities, young creators (artists, coders, musicians) lack a safe space to showcase their work without the toxicity and pressure of traditional social media. I wanted to build a platform that focused on three "vibes":

Stress Relief: Simple, competitive mini-games.

Empowerment: A bridge to gigs and sponsored challenges.

Showcase: A "Creativity Wall" where the only interaction is positive emoji reactions. No chat = No negativity.

🛠️ The Tech Stack Evolution
I started with a traditional Next.js and Firebase plan, but for this hackathon, I pivoted to MeDo.

Frontend: React + Tailwind CSS (Mobile-First)

Backend/DB: Supabase with Row Level Security (RLS)

Auth: Secure Email-based authentication

🏗️ The Build: Iteration is the Key to Quality
The most interesting part of this experience was moving through 13 versions of the app. AI isn't a "one-click and done" magic wand; it’s a collaborator.

Phase 1: The Core Foundation
I started by defining the database schema via a Master Prompt. Within minutes, MeDo had generated tables for profiles, posts, and leaderboards.

Phase 2: Solving the "Play Zone" Logic
Building three different games (Tic-Tac-Toe, Memory Match, and Rock-Paper-Scissors) that all report to a single cumulative leaderboard was the first big challenge. I had to prompt the AI to ensure that regardless of the game played, the user's total_score was updated in the profiles table.

Phase 3: The v13 Refactor
This was my "Aha!" moment. I ran into API 400 errors because my initial schema was referencing a deprecated users table instead of the new profiles table. I used the AI to:

Refactor every single query across the Dashboard, Admin Panel, and Profile pages.

Switch the entire auth flow from username-based to a secure email system.

Implement a real-time notification bell for reactions and rank milestones.

💎 Features I'm Proud Of
The Sponsor Portal: Institutions can post "Sponsored Challenges" with prize pools. I even implemented a mock payment confirmation flow to simulate a real business environment.

The Creativity Wall: It supports full media uploads to Supabase Storage, allowing users to share real art from their devices.

Admin Dashboard: A high-level view of platform analytics—total engagement, post moderation, and bulk approval for job opportunities.

💡 Lessons Learned
If you are building with generative AI tools like MeDo, my biggest tip is: Don't just prompt for UI.
Use the AI to handle the "boring" but critical parts—like database RLS policies, error handling, and data normalization. That is where the real power lies.

🚀 Check it out!
I'm proud to have submitted Iyk Hub to the #BuildWithMeDo Hackathon.

Live Demo: https://app-bf30s4clnoch.appmedo.com/

BuiltWithMeDo #AI #WebDev #ShowDev #Hackathon

DEV Community: okuhlecharlieman