Project E12 : qage.dev

The simplest AI bug reporter for your website.

Many website bugs go unreported or reach developers without the context needed to reproduce them quickly.

qage.dev (yes, no caps) is a user-facing bug reporting tool for web apps that captures real issues with repro steps, console logs, network logs, screenshots or recordings, and environment context, so teams can reproduce and fix bugs faster.

Built as part of the SUTD Entrepreneurship Capstone and featured at UNICON 2026 and AI Demo Night at Carousell.

Check it out here.

Introducing Project E12 : qage.dev

Bug reporting is often broken: many website issues go unreported, and those that are reported often lack the context developers need to reproduce and fix them efficiently. This creates unnecessary back-and-forth, wastes engineering time, and slows resolution. Introducing Project E12: qage.dev, an AI-powered bug reporting platform that simplifies issue submission through one-click reporting. It automatically captures technical context such as logs, screen recordings, and environment data, then turns that information into clear summaries, reproducible steps, and actionable debugging insights. Developed under the SUTD Entrepreneurship Capstone, qage.dev explores how a user-centered, AI-assisted workflow can improve bug reporting quality, reduce developer triage effort, and support faster debugging for lean web teams.

Team members

Tan Hun Chong (DAI), Gavin Ong (ISTD), Valencia Arlin Halim (DAI), Cephas Yeo Zhi Hao (ISTD), Tan Yong Lin (ISTD)

Instructors:

  • Rakesh Nagi

  • Lee Young

Writing Instructors:

  • Susan Wong

Project Roadmap

Empathize

The team began by understanding the broader challenges surrounding bug reporting in web applications. Through literature review, secondary research, and observations from prior experience with software teams, they identified a recurring pattern: many bugs go unreported, many reported bugs lack sufficient context, and the resulting inefficiencies create both technical and business costs. These findings helped the team recognize that bug reporting was not only a usability issue, but also a workflow and communication problem affecting both developers and end users.

This early understanding was further reinforced through informal conversations with software practitioners in the startup and engineering ecosystem. Engagements at events such as Google DevFest, AIMX Singapore, D:NEXA, and Figma Maker Collective helped validate that these frustrations were experienced across real teams and products. Together, these research inputs gave the team a grounded understanding of the pain points that would shape the project’s next stages.

Define

The team synthesized findings from the previous phase into a clearer and more focused understanding of the problem space. Drawing from the literature review, informal practitioner conversations, user personas, and journey mapping, they identified that the issue was not simply that bugs occur, but that many bugs are either left unreported or reported without the technical context needed for efficient diagnosis and resolution. This allowed the team to move from broad observations into a more precise articulation of the design challenge.

To support this process, the team evaluated and prioritized recurring concerns based on both their frequency and intensity of pain, as shown in the concern-mapping exercise. This helped highlight the most critical issues affecting current workflows, such as irreproducibility, missing environment and log data, messy or overwhelming logs, and the time lost in repeated clarification loops. From this synthesis, the team defined a focused problem statement and design objective: to create a bug reporting process that reduces friction for users while ensuring developers receive complete, clear, and actionable reports.

Solution

In response to the defined problem, the team developed qage.dev, an AI-assisted bug reporting platform designed to make issue reporting more effortless for users and more actionable for developers. The solution combined a lightweight embeddable widget for one-click reporting with a developer dashboard that consolidates screenshots, session replay, reproduction steps, environment data, console logs, and network logs into a single workflow. By pairing low-friction reporting with rich contextual capture, the team aimed to reduce the ambiguity and back-and-forth that typically slow down debugging.

The solution was refined through iterative prototyping, MVP development, onboarding sessions, and walkthroughs with prospective users. These activities allowed the team to observe how the product was understood and used in realistic settings, while also surfacing areas for improvement in usability, workflow clarity, and feature prioritisation. As the report notes, later iterations incorporated enhancements such as client-side redaction, cybersecurity improvements, and MCP integration, reflecting how the solution evolved in response to user feedback and real-world validation efforts.

Public Showcases and Early Validation

Although the project is still at an early stage, it has shown encouraging validation signals. The team’s outreach generated early waitlist signups, inbound conversations with founders and developers, and repeated confirmation of the same core pain points: bugs often go unreported, reported issues often lack sufficient context, and teams spend substantial time on reproduction and follow-up. The project was also presented through public showcases and community events such as UNICON 2026, AI Demo Night at Carousell 2026, and SUTD Hult Prize Qualifier 2026, which helped strengthen visibility and market feedback.

What are we trying to solve?

In an ideal bug resolution workflow, issues are reported quickly and with enough detail for developers to reproduce and fix them efficiently. In practice, this process is often much slower. Many users do not report bugs at all, and when they do, reports are frequently incomplete or lack the technical context needed for effective debugging. As a result, developers spend significant time chasing clarification rather than resolving the issue itself. qage.dev addresses this gap by making bug reporting easier for users while capturing the contextual data developers need to act more quickly.

Testimonials

Through outreach, product demos, and conversations at startup events and hackathons, the team received encouraging feedback from founders, builders, and practitioners. These testimonials reflect the support, advice, and validation that helped shape qage.dev’s development and the team’s broader capstone journey.
/

Key Features

qage.dev supports three main stages in the bug reporting and resolution workflow.

First,

Users need an effortless way to report issues, increasing the likelihood of meaningful submissions.

Second,

Teams can review and manage reports through the qage.dev dashboard, where issues are organised, interpreted, and prioritised.

Third,

Reports can be passed into a preferred IDE through qage.dev’s MCP integration, allowing AI coding tools to analyse the ticket and assist with implementation.

Widget
Dashboard
MCP Integration

To get started with qage.dev, the team designed a lightweight widget that can be embedded into a website through a simple one-script installation. The widget supports three capture modes: screenshot, screen recording, and logging the previous 30 seconds of activity. Users can also include a short description of the issue and optionally provide their email for follow-up.

The widget is also customisable. Its position, colour, logo, and available capture modes can be adjusted to better suit the branding and needs of the host website.

 

The dashboard serves as the central space where all submitted qages are stored and managed. It includes several AI-powered features that improve the clarity, organisation, and efficiency of bug triage:

  1. Automatic triaging
    Bug tickets are automatically classified into High, Medium, or Low priority based on the likely impact and urgency of the issue.
  2. Duplicate merging
    Duplicate tickets may arise, especially for common user flows. The dashboard identifies similar tickets and suggests merges into a parent ticket to improve visibility and reduce clutter.
  3. Automatic ticket titles
    Titles are generated automatically, helping teams maintain a cleaner and more consistent dashboard without unclear or poorly written ticket names.
  4. AI summaries
    Each ticket includes an AI summary outlining what the issue is, where it occurred, possible causes, and suggested directions for investigation. This gives developers a concise starting point for debugging.
  5. Clear reproducible steps
    Step-by-step reproduction flows are generated in a clear and digestible format, helping developers better understand the sequence of user actions that led to the issue.

In addition, each ticket includes other important contextual information such as console and network logs, environment details, and the screenshot or recording submitted by the user.

qage.dev extends beyond reporting and triage through MCP (Model Context Protocol) integration. Each ticket contains rich debugging context, including screenshots or recordings, user events, console logs, network logs, and environment metadata, which can be passed directly into supported AI coding tools and developer environments.

By bringing the bug report into the coding workflow itself, teams can move more efficiently from understanding the issue to investigating and implementing a fix. This reduces the need for manual copy-pasting, repeated context switching, and re-explaining the problem across tools. As a result, MCP integration strengthens qage.dev’s role not only as a bug reporting platform, but also as a bridge between issue capture and resolution.

Landing Page

The team also developed a landing page as the project’s primary point of contact during outreach. It introduced qage.dev to potential users, featured an interactive click-through demo of the reporting workflow, and included a documentation page with setup guidance and frequently asked questions.

 

After many outreach events and public showcases,

qage.dev was proudly showcased at SUTD InspireCon 2026.

The project, at a glance.

The poster captures the big picture, while the video brings the journey to life.

Supported by :

Acknowledgements

The qage.dev team would like to express their sincere gratitude to their Capstone mentors, Dr Rakesh Nagi, Dr Young Lee, and Dr Susan Wong, for their invaluable guidance and feedback throughout the project. Their support in shaping ideas, sharpening communication, and strengthening deliverables was instrumental to qage.dev’s development.

The team also extends their thanks to Mr Jason Lee from the SUTD Entrepreneurship Centre for his advice on entrepreneurial execution and business strategy, which meaningfully shaped the project’s progress.

Special thanks are also given to the team’s industry mentor, Ms Ivy Young, for her guidance on market considerations, product development, user journey insights, and ideation, all of which played a significant role in shaping the project’s direction.

Menu

ornament-menu