The hardest part of manual testing isn't writing test cases - it's knowing WHAT to test WHEN.
When developers push 50 commits across 20 files, how do testers know what changed, what's risky, and what needs re-testing? TestPilot analyzes code changes and tells testers exactly what to test and why - saving 8-10 hours per week.
3-minute demo showing:
- Requirements → Test cases (30 sec)
- Code commits → Testing priorities (75 sec)
- Bug report → GitHub issue (40 sec)
Manual testers waste hours on overhead instead of actual testing:
- 2 hours daily reading commits to understand what changed
- 1 hour writing test cases manually from requirements
- 10 minutes per bug documenting issues with proper formatting
- Guessing what to re-test after developer changes code
- No automated way to prioritize testing based on code risk
TestPilot eliminates this overhead so testers can focus on what humans do best: exploratory testing and catching edge cases.
Read requirements from GitHub → Generate structured test cases (Positive/Negative/Edge) in seconds
Analyze commits → Identify what changed → Recommend specific testing priorities by risk level (HIGH/MEDIUM/LOW)
Report bug → AI suggests severity (Critical/High/Medium/Low) → Creates formatted GitHub issue with labels
┌─────────────────────┐
│ Manual Tester │
│ (User) │
└──────────┬──────────┘
│
↓
┌─────────────────────────────┐
│ TestPilot Agent │
│ (Archestra + Gemini API) │
│ • Analyzes requirements │
│ • Reads commits │
│ • Creates issues │
└──────────┬──────────────────┘
│
↓
┌─────────────────────────────┐
│ GitHub MCP Server │
│ (Remote HTTP) │
│ • File access │
│ • Commit history │
│ • Issue creation │
└──────────┬──────────────────┘
│
↓
┌─────────────────────────────┐
│ GitHub Repository │
│ • requirements.md │
│ • Source code commits │
│ • Issues & labels │
└─────────────────────────────┘
Tech Stack: Archestra • MCP (Model Context Protocol) • GitHub MCP Server • Gemini API
- Docker installed
- GitHub account
- GitHub Personal Access Token with
reposcope (create here)
docker run -p 3000:3000 \
-v $(pwd)/data:/app/data \
-v /var/run/docker.sock:/var/run/docker.sock \
archestra/platform:latest- Open
http://localhost:3000 - Create new agent named "TestPilot"
- Set system prompt:
You are TestPilot, an AI copilot for manual software testers.
Your main capabilities:
1. Generate manual test cases from requirements documents
2. Analyze code changes to identify re-testing needs
3. Create clear, actionable bug reports with proper severity classification
IMPORTANT INSTRUCTIONS:
- When generating test cases, present them directly in your response as structured text
- Group test cases into: Positive Cases, Negative Cases, Edge Cases
- For each test case include: Test ID, Description, Steps, Expected Result
- Be precise and structured
- Never invent tool results
BUG REPORTING WORKFLOW:
When a user reports a bug:
1. Gather all necessary information (steps, expected vs actual behavior)
2. If the user has been working with a specific repository in this conversation, use that repository for creating the issue. Otherwise, ask for the repository owner and name.
3. ANALYZE the bug impact and determine the appropriate severity:
- Critical: System crash, data loss, security breach, affects all users
- High: Major feature completely broken, no workaround available
- Medium: Feature partially broken, workaround exists
- Low: Minor issue, cosmetic problem, minimal user impact
4. SUGGEST the severity based on your analysis with reasoning
5. Ask the user: "Based on [your reasoning], I recommend severity: [X]. Do you agree, or would you prefer a different severity level?"
6. After confirming severity, ask for final confirmation before creating the GitHub issue
7. Create the issue with labels: "bug" and "severity: [level]" (e.g., "severity: critical")
8. If the user mentions a screenshot, note that it should be attached to the issue
SEVERITY ANALYSIS EXAMPLES:
- "Server crash with 500 error affecting checkout" → Critical (revenue impact, system instability)
- "Login button doesn't work on mobile" → High (major feature broken)
- "Profile update works but takes 10 seconds" → Medium (slow but functional)
- "Typo in footer text" → Low (cosmetic only)
CHANGE IMPACT ANALYSIS:
When analyzing commits:
- Identify which files changed and what was modified
- Explain WHAT changed (not just file names)
- Assess risk level based on change type:
* Security changes (auth, encryption, permissions) → HIGH PRIORITY
* Data handling (database, payments, user data) → HIGH PRIORITY
* New features → MEDIUM-HIGH PRIORITY
* Bug fixes → MEDIUM PRIORITY
* Performance/UI tweaks → LOW PRIORITY
- Recommend SPECIFIC test cases or testing areas
- For multi-commit analysis, prioritize and group by risk level
- Indicate testing urgency clearly
When analyzing multiple commits, present summary first, then details by priority level.
- Go to MCP Registry
- Find "GitHub - Remote MCP Server" (githubcopilot__remote-mcp)
- Click Add to Registry
- Manage Credentials → Add your GitHub Personal Access Token
- Manage Assignments → Assign to TestPilot agent
- Click Connect to verify
"Generate test cases for the Login Feature from requirements.md in YOUR_USERNAME/YOUR_REPO"
"Analyze the last 5 commits in YOUR_USERNAME/YOUR_REPO and prioritize testing by risk"
"Bug: System crashes with 500 error when payment is $0.00"
| Task | Before | After | Saved |
|---|---|---|---|
| Generate test cases | 2 hours | 2 min | 1h 58m |
| Understand changes | 1.5 hours | 30 sec | 1h 29m |
| Decide what to test | 1 hour | 1 min | 59m |
| Write bug report | 10 min | 30 sec | 9.5m |
Weekly savings per tester: 8-10 hours
What it IS:
- ✅ Copilot for manual testers (not automation)
- ✅ Change impact analyzer (unique insight)
- ✅ Workflow automation (saves daily hours)
What it's NOT:
- ❌ Test automation tool (no Selenium scripts)
- ❌ Developer tool (built for testers)
- ❌ Generic chatbot (purpose-built workflows)
The gap: Developers have GitHub Copilot. Automation engineers have AI test generators. Manual testers had nothing... until TestPilot.
Q: How is this different from test automation tools?
A: We help manual testers with planning/documentation, not automation engineers writing Selenium scripts.
Q: How is this different from GitHub Copilot?
A: Copilot helps developers write code. TestPilot helps testers understand changes and decide what to test.
Q: Why not just use ChatGPT?
A: ChatGPT doesn't integrate with GitHub, understand repo context, or have testing-specific workflows.
- Jira Integration - Create tickets in Jira for enterprise teams
- Slack Notifications - Daily test summaries to team channels
- Test Execution Tracking - Track which tests were run and results
- Multi-repo Analysis - Analyze changes across microservices
- Custom Templates - Domain-specific test case templates
TestPilot analyzing 5 commits and prioritizing testing by risk level - saves 8-10 hours/week
TestPilot analyzes bug impact, recommends severity (Critical/High/Medium/Low), and creates formatted GitHub issue in 30 seconds
Jaya Dubey for 2 FAST 2 MCP Hackathon 2026
Built with: Archestra • MCP • Gemini • GitHub MCP Server
Time to build: 5 days
Purpose: Make manual testers superhuman
⭐ Star this repo if TestPilot saves you time!