ZeroBug — The Autonomous QA Engineer

Paste any URL. ZeroBug's AI crawls your app like a chaotic user, finds every bug, and drafts the exact GitHub PR to fix it — zero test scripts, zero config, total magic.

Comment

ZeroBug — The Autonomous QA Engineer

Your app's worst nightmare. Your team's best friend.

Inspiration

Every developer I know has the same confession: "I should write more tests, but I never do."

Edge-case tests are the worst part of software development. You have to think like a user who deliberately tries to break your app — submitting empty forms, clicking buttons in the wrong order, hammering your API with bad inputs. Most teams skip this entirely because it is slow, tedious, and unglamorous work.

I kept asking myself one question: what if an AI just did this for you?

Not a test script generator. Not a template filler. A true autonomous agent that becomes the chaotic user — navigating your app in ways no sane person would, finding the exact breaking points that slip past code review — and then hands you the fix on a silver platter.

That question became ZeroBug.

The inspiration also came from a personal frustration: I once pushed a checkout bug to production that only triggered when a user clicked the payment button without entering an email address. A 10-second edge case that cost real customers. A proper QA agent would have caught it in the first scan. ZeroBug would have caught it and written the fix before I even knew the bug existed.

What it does

ZeroBug is an Autonomous QA Engineer — a full-stack AI application that finds bugs in your web app and drafts the exact code fix, automatically.

The core workflow is four steps:

1. Paste a URL No configuration. No test scripts. No SDK installation. Just paste your app's URL into ZeroBug and hit Run. That is the entire setup.

2. AI crawls and simulates Using MeDo's Webpage Content Extract Plugin, ZeroBug reads your entire DOM — every form, button, link, input field, and API endpoint. The LLM Plugin then reasons through "impossible" user flows: empty checkouts, malformed inputs, rapid navigation, slow network conditions, XSS injection attempts. It thinks like a chaotic user who is actively trying to break things.

3. Bugs detected and classified Every issue is logged with:

  • Severity badge: Critical / High / Medium / Low
  • Exact page URL where the bug occurs
  • Step-by-step reproduction instructions
  • Root cause explanation in plain English
  • Relevant error codes and affected lines

No cryptic stack traces. No log files to dig through.

4. Self-Healing PR generated This is the magic. ZeroBug does not just say "line 312 is broken." It drafts the complete GitHub Pull Request — the before/after code diff in GitHub format, PR title, full description with root cause analysis, testing instructions, and a merge checklist. Ready to push.

Additional features powered by MeDo plugins:

  • 🔍 Web Search Plugin — automatically surfaces the top 3 Stack Overflow and GitHub Issues related to each detected bug, shown under "Known Solutions" on every bug detail page
  • 🔎 AI Search Plugin — powers a natural-language search bar: type "show all critical checkout bugs from last week" and get smart filtered results instantly
  • 📸 OCR Plugin — upload a screenshot of your app; ZeroBug visually scans it for UI bugs and accessibility issues without needing a live URL
  • 🔊 Text-to-Speech Plugin — a "Read Aloud" button on every bug report reads the summary and fix suggestion aloud, shown as an audio player for accessibility
  • 🎫 Jira auto-tickets — one click creates a fully structured Jira bug report with severity, priority, and reproduction steps pre-filled
  • 📊 Analytics dashboard — bug trends over 30 days, severity distribution donut chart, most buggy pages bar chart, and an AI-written insight paragraph summarising patterns

How we built it

ZeroBug was built entirely in MeDo with zero manual coding — from database schema to animated UI to plugin integrations, all through conversational prompting.

The MeDo approach:

The entire app was described screen-by-screen in a single detailed MeDo conversation. I structured the prompt with explicit sections: design system, each screen's layout, each plugin's role, the database schema, and sample data to pre-populate. MeDo's multi-turn chat then let me iterate — refining the terminal animation timing, adjusting the diff viewer colours, wiring plugin outputs together.

The six plugin integrations:

Plugin Role in ZeroBug
LLM Plugin Core AI brain — DOM analysis, bug detection, code fix generation, PR writing
Webpage Content Extract Scrapes target URL; extracted DOM feeds directly into the LLM
Web Search Fires after each bug detection; fetches top 3 known solutions
AI Search Powers the natural-language bug search bar across all scan history
OCR Reads uploaded screenshots; identifies visible UI bugs and layout issues
Text-to-Speech Reads bug reports aloud; embedded as an audio player on detail pages

The LLM Plugin was configured with a custom system prompt:

"You are ZeroBug AI, an expert QA engineer. Given a page's DOM structure and user interaction logs, identify bugs, explain root cause in plain English, suggest exact code fixes, and write professional GitHub PR descriptions."

Database (auto-generated by MeDo): Five tables — scans, bugs, pr_drafts, jira_tickets, settings — with all relationships, statuses, and timestamps handled automatically.

UI design: Dark terminal aesthetic throughout — #0D0F10 background, #00FF87 neon green accent, #FF4D4D for critical bugs. The scanning terminal uses a typewriter animation (new log lines every 800ms). The code diff viewer replicates GitHub exactly — red lines with - prefix for removed code, green lines with + prefix for added code, line numbers on the left. All three analytics charts are interactive with hover tooltips.

Challenges we ran into

Making the scan feel alive The biggest UX challenge was creating a compelling live scan experience. Real DOM crawling takes time and the result needs to feel intelligent, not generic. The solution was combining the Webpage Extract plugin output with the LLM to generate a realistic, app-specific scan log — with actual page names, real element counts, and genuine-sounding warnings. The animated terminal with 800ms intervals makes the AI's reasoning process feel viscerally real.

Chaining six plugins into one coherent flow Wiring plugins so their outputs feed each other — Extract feeds LLM, LLM output triggers Web Search, all results feed AI Search — required very explicit, structured prompting in MeDo. Describing data flow precisely (not just listing features) was the key unlock. Vague instructions produced disconnected features; specific pipeline descriptions produced a seamless product.

The GitHub diff viewer Getting the code diff to look exactly like GitHub — red/green lines, line numbers, filename header, the @@ hunk markers — took several visual editor iterations in MeDo. The result is indistinguishable from a real GitHub PR, which is critical because it is the centrepiece feature judges need to immediately understand.

Keeping it truly zero-config The entire value promise is "paste a URL, nothing else." Every design decision had to protect that. Ensuring GitHub tokens, Jira credentials, and Slack webhooks stayed entirely optional in Settings — never blocking the core scan experience — required deliberate, repeated prompting to keep MeDo from adding required fields to the onboarding flow.

Demo data that looks real Pre-populated bug data had to feel authentic, not toy-like. Generic bug names like "Button broken on page 3" would kill credibility instantly with technical judges. Every sample bug — XSS vulnerability in the search input, payment form submitting with an empty card number, CORS error on the profile endpoint — was written to sound like something a senior engineer would actually file.

Accomplishments that we're proud of

The Self-Healing PR — When ZeroBug shows a merge-ready GitHub PR diff for a bug it found autonomously, the reaction is always the same: "wait, it actually wrote the fix?" No other QA tool does this end-to-end without writing a single line of code. This is the feature that makes ZeroBug a product, not a demo.

True zero configuration — Paste a URL. That is it. No YAML. No SDK. No test script setup. We achieved the lowest possible barrier from "I want to find bugs" to "here are your bugs and their fixes." This is genuinely hard to do well.

Six plugins, one product — Each plugin serves a distinct, visible purpose in the UI, yet the app feels like a single seamless professional tool. Users never see "Plugin 3 output." They see "Known Solutions" appear below their bug, they hear their report read aloud, they search their history in plain English. The seams are invisible.

Built entirely in MeDo — A production-grade developer tool with a relational database, real-time animations, GitHub-style diff rendering, multi-service integrations, and interactive analytics — built in one MeDo session with no manual coding. This is what MeDo is capable of at its best.

The terminal animation — This is a small thing that matters enormously. Watching ZeroBug crawl your app with live scrolling log output — seeing it detect your specific pages, your specific forms, your specific errors — is the most satisfying 30 seconds in any developer tool I have ever used. Judges who see it do not forget it.

What we learned

Orchestration is MeDo's superpower. The individual plugins are impressive. The chain is extraordinary. Extracting a webpage, reasoning over its DOM, searching for known fixes, letting users find results in natural language, reading reports aloud — each step alone is useful. Together, described in plain English, they become a full-stack AI product that would take a team months to build conventionally.

Precise UI language produces precise UI. Describing the interface with exact hex codes (#0D0F10, #00FF87), exact references ("looks like GitHub," "feels like Linear," "exactly like Vercel's dashboard"), and exact behaviours ("new log line every 800ms," "red line with - prefix, green line with + prefix") produced dramatically better results than vague directions like "make it professional." MeDo responds to specificity.

The problem you pick matters more than the features you build. ZeroBug's strongest asset is not the Self-Healing PR, the OCR screenshot scanner, or the animated terminal — it is the fact that every developer on the judging panel has personally felt the pain of skipping edge-case tests. When a judge sees ZeroBug, they do not evaluate it abstractly. They think: "I need this." Emotional resonance with the problem is the feature that wins hackathons.

Demo data is a product decision. The difference between a hackathon app that judges dismiss in 10 seconds and one they spend 5 minutes exploring is whether it looks inhabited. Real-sounding bug names, plausible code diffs, 30 days of authentic-looking chart data — these signals tell judges: this is a real product, not a prototype. Pre-populated demo data is not a shortcut. It is a design choice.

What's next for ZeroBug

CI/CD integration ZeroBug as a GitHub Action — runs automatically on every Pull Request, posts a comment with all bugs detected, and blocks merges if Critical issues are found. QA that runs without anyone remembering to run it.

Playwright and Cypress export Convert ZeroBug's scan results into runnable test scripts. Teams get the best of both worlds: AI discovery of edge cases, plus a permanent automated test suite that grows with every scan.

Regression tracking Compare scans over time. If a bug was marked Fixed in sprint 4 and reappears in sprint 7, ZeroBug flags it immediately — before it reaches production again.

Team collaboration Assign bugs to teammates directly from ZeroBug. Track fix status, leave comments on PRs, see who is working on what. A lightweight project management layer built on top of the QA foundation.

Browser extension Install ZeroBug as a Chrome extension. Scan any page you are currently viewing with one click — no URL copy-paste, no tab switching, instant results in a side panel.

SaaS launch Freemium model: 10 scans per month free, unlimited scans on Pro. ZeroBug has genuine product-market fit — every developer team that sees it asks how to use it. A public beta is the natural next step after this hackathon, and MeDo makes scaling the deployment trivial.

The long-term vision: ZeroBug becomes the QA layer that every web app has running continuously — not a tool developers remember to use, but infrastructure that runs silently, catches everything, and files the fix before the developer even knows there was a problem.

Built With

Share this project:

Updates