This is a submission for the GitHub Copilot CLI Challenge
What I Built
MCP Orchestrator - A CLI tool that orchestrates multiple AI agents to solve real developer problems.
The Problem: New developers waste 1-2 weeks understanding a codebase before becoming productive. They spend days reading scattered docs, finding entry points, and understanding architecture.
My Solution: 4 independent MCP (Model Context Protocol) agents working together in a pipeline to analyze any repository and generate a comprehensive onboarding guide in 30 seconds.
Architecture
┌──────────────────────────────────────────────────────────────────┐
│ MCP ORCHESTRATOR │
│ (Pipeline Coordinator) │
└────────────────────────────┬─────────────────────────────────────┘
│
┌──────────────────┼──────────────────┬──────────────────┐
│ │ │ │
▼ ▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ Agent 1 │ │ Agent 2 │ │ Agent 3 │ │ Agent 4 │
│ Architecture │ │ Entry Point │ │ Documentation │ │ Onboarding │
│ Analyzer │ │ Detector │ │ Finder │ │ Generator │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘ └───────┬───────┘
│ │ │ │
│ Analyzes: │ Locates: │ Finds: │ Combines:
│ • Modules │ • Main files │ • READMEs │ • All data
│ • Classes │ • CLI cmds │ • Docs │ • Into guide
│ • Tests │ • APIs │ • Docstrings │ • Learning
│ │ │ │ path
└──────────────────┴──────────────────┴──────────────────┘
│
▼
┌──────────────────────────┐
│ Onboarding Guide │
│ ✓ Project Overview │
│ ✓ Quick Start │
│ ✓ Architecture Map │
│ ✓ Learning Path │
└──────────────────────────┘
Each agent is an independent MCP server analyzing specific aspects of the codebase. The orchestrator coordinates them and passes data between steps.
Result: A comprehensive guide with project overview, quick start, architecture breakdown with module-level insights, and a "Your First Hour" learning path.
GitHub: github.com/levdalba/MCP-Terminal-Orchestrator
Demo
Watch it analyze Facebook's React repository (233k+ stars):
What it finds:
- Project Type: Node.js with JavaScript/TypeScript
- 109 Entry Points across 20+ packages
- 74 Documentation files
- Module-level insights (e.g., "Defines AppConfig class")
- Complete architecture breakdown
- Personalized learning path
Try it yourself:
# Install
pip install -e .
# Run on any repository
mcp pipeline examples/onboard_repo_pipeline.yml \
--registry ./examples/onboarding_registry.json
My Experience with GitHub Copilot CLI
TL;DR: 80% faster development, 3-4 days instead of 2-3 weeks
I used GitHub Copilot CLI (copilot command) extensively throughout this project. Here's what made the biggest impact:
1. Architecture Design
Command I used:
copilot -p "Propose a minimal Python CLI repo layout for an MCP orchestrator using Typer, including pyproject.toml deps and an entrypoint module name." --model claude-sonnet-4.5 -s
Impact: Copilot designed the entire project structure with proper separation of concerns, recommended the right dependencies (typer[all]), and set up the entrypoint. This saved me ~2 days of architectural decisions.
2. MCP Protocol Implementation
Command I used:
copilot -p "Propose a minimal JSON-RPC framing approach for stdio transport in a Python MCP CLI." --model claude-sonnet-4.5 -s
Impact: Copilot explained how to implement JSON-RPC 2.0 communication with MCP servers, handling line-delimited messages and error responses. I implemented the JsonRpcClient based on this guidance. Without it, I would've spent days reading the MCP spec and debugging protocol issues.
3. Testing Strategy
Command I used:
copilot -p "Draft 3 pytest tests for registry loading and pipeline parsing in this repo." --model claude-sonnet-4.5 -s
Impact: Copilot generated comprehensive test cases covering edge cases I hadn't considered. This accelerated test writing from ~1 day to 3 hours and improved code quality.
What AI Excelled At:
✅ Boilerplate generation - Project structure, config files, setup
✅ API design - Clean CLI patterns and command structure
✅ Error handling - Comprehensive edge case coverage
✅ Documentation - README structure and examples
What Needed Human Oversight:
⚠️ Environment variables - Copilot's initial approach lost PATH, I had to fix subprocess env handling
⚠️ Real-world validation - Testing on actual repos (React, Django) revealed edge cases
⚠️ UX decisions - Demo presentation and visual formatting required human judgment
Time Breakdown:
| Task | Without AI | With Copilot CLI | Savings |
|---|---|---|---|
| Project setup | 2 days | 2 hours | 90% |
| Core implementation | 1 week | 2 days | 70% |
| Testing | 1 day | 3 hours | 80% |
| Documentation | 1 day | 1 hour | 90% |
| Total | 2-3 weeks | 3-4 days | ~80% |
Key Takeaway:
GitHub Copilot CLI isn't just autocomplete - it's an AI pair programmer. I used it for:
- Design decisions ("How should 4 agents work together?")
- Debugging ("Find where we're checking membership on None")
- Learning ("Explain JSON-RPC framing for MCP")
It dramatically accelerated development while teaching me MCP protocol concepts I didn't know. The --model claude-sonnet-4.5 flag was particularly powerful for architectural questions.
Would I use it again? Absolutely. It transformed a 2-3 week project into a 3-4 day sprint while maintaining code quality.
Built with ❤️ and AI assistance
Top comments (0)