EchoCode

The Problem Teams often fix the same class of bug more than once without realizing it. A defect gets patched in one file, the ticket gets closed, and the actual shape of the mistake is never captured anywhere reusable. Weeks later, a different developer writes structurally similar code somewhere else in the system, hits the same failure mode, and the team ends up investigating the same problem from scratch. This gets worse when AI tools are involved in debugging, since many of them will claim a fix works without ever running a real test, so confidence in the finding and confidence in reality quietly drift apart. Our Solution EchoCode uses IBM Bob IDE to treat a resolved incident as institutional memory instead of a closed ticket. In our demo, an earlier bug allowed a retried payment request to create two ledger records instead of one. Rather than just patching that and moving on, we used Bob IDE to investigate the incident and extract the underlying failure pattern: an operation with an identifier, a write with no uniqueness guard, and a request that can be retried. We stored this as a structured signature. Later, an analyzer we built with Bob scanned the current codebase and found that a completely different module, the refund processor, had the same failure shape hiding under a differently named field. That match is only ever surfaced as a candidate finding, never presented as confirmed. To move it from suspicion to fact, we wrote and ran a real regression test. Sending the same refund twice produced two records, which proved the bug actually existed. We then applied a uniqueness constraint and reran the same test, which passed. Every step in this chain, the original bug, the extracted pattern, the new candidate, the failing test, and the verified fix, is shown as one traceable trail on the dashboard. Target Users and Interaction EchoCode is built for developers, tech leads, and reviewers who want AI assisted debugging they can actually check for themselves. A user points EchoCode at an incident, and it surfaces related historical patterns, flags candidate matches elsewhere in the code, and runs behavioral tests to confirm or reject each one. The dashboard lets anyone, including a non technical reviewer, follow the full trail without reading raw logs. Why It's Creative and Unique Most debugging tools stop once a bug is patched. EchoCode treats every fix as training data for catching the next occurrence of the same mistake before it becomes a new incident. It also refuses to blur the line between suspicion and proof. A pattern match stays a candidate until a real, executed test reproduces the failure. Nothing is inferred, and no test output is invented. Why It Solves This Differently Judges have likely seen AI tools that suggest fixes. EchoCode instead builds a verified memory of failure patterns using IBM Bob IDE, applies that memory proactively across a codebase, and backs every claim with an actual reproduced test. That turns "we already knew this could happen" into a preventive check rather than a postmortem.