Lovable's AI Agent Now Flags Its Own Bugs and Doubles as Incident Detection.

Lovable has detailed how its AI agent is improving reliability by actively reporting its own limitations, a system that now ships around 10 production fixes per day and has become an unexpected early warning signal for outages.

The update centers on two systems: an is_stuck classifier that detects when users are spinning their wheels, and a send_feedback tool that lets the agent report problems it cannot solve on its own. The systems emerged from a core insight: users who get stuck are four times more likely to abandon their projects.

Lovable's is_stuck metric fires in real time when a user repeats the same request three times, expresses frustration, or keeps asking for something without resolution. A lightweight classifier catches these patterns as they happen.

The team categorized stuck scenarios into three buckets:

• Solvable with better context: Other users have prompted their way out of the same problem
• Unsupported but fixable: Easy in theory but not yet built into the platform
• Hard investment required: Structural changes like server-side rendering for SEO

The first two categories became intervention points. For solvable problems, Lovable built what it calls Lovable Overflow, a corpus of real problem and solution pairs scraped from user sessions. When a user heads toward stuck, the system searches the corpus and injects relevant context into the agent's prompt. This is not raw documentation but guidance shaped to the specific situation.

Every piece of knowledge in Lovable Overflow carries a success ratio and gets pruned automatically when it stops working. This matters because models change. A fix for a JavaScript package from six months ago might actively mislead the agent today.

Results from Lovable Overflow alone: stuck rate down 5%, the same order of magnitude as upgrading to a new model generation. Publish rate up 2%.

For the second category, unsupported but fixable issues, Lovable introduced send_feedback. The agent calls this tool when it hits something it genuinely cannot work around: broken tooling, bad schemas, unexpected library behavior, environment failures. Those reports go to the engineering team for review.

Around 50% of reports turn out to be real bugs. The pipeline now ships roughly 10 production fixes per day. One example: a file copy tool that silently failed on filenames with special characters. The agent flagged it instead of looping, and the team fixed it within hours.

The unexpected bonus came from volume. When there is an outage or inference failure, the agent starts calling send_feedback at high frequency, sometimes before traditional monitoring catches the problem. Engineers now treat it as a debug signal when triaging incidents.

In one session, the agent triggered send_feedback 43 times, then filed a pull request suggesting Lovable add a debounce guard to prevent duplicate submissions. It filed a bug about its own venting mechanism.

Lovable previously introduced Skills, which let users save reusable instructions as markdown files, and recently shipped SEO and AI search capabilities to help projects get discovered. The send_feedback system builds on that foundation by treating each project as a training ground for the next.

The approach reflects a broader bet: you cannot anticipate every edge case across a platform where users are building everything from side projects to enterprise tools. Instead, set up systems so each project built improves the next.