## The Problem: Bugs in Production When you are running a production web application, errors happen. Users encounter 404 pages, CSRF validation fails, servers throw 500 errors. Traditionally, developers only discover these bugs when: 1. A user reports it (if they bother) 2. You happen to check the logs 3. Something catastrophic breaks What if bugs could automatically find you instead? ## Introducing Automated Bug Tracking I built a Django app called error_tracking that creates a complete bug lifecycle: Production Error -> Django Middleware -> Database Log -> Celery Task | Creates GitHub Issue Creates B-XXX.md file | Claude Session -> Queries open bugs -> Fixes with TDD -> Human verifies ### How It Works **1. Error Capture Middleware** Every HTTP 4xx/5xx response is intercepted by custom middleware that logs it to the database. **2. Fingerprinting** Similar errors are grouped using a fingerprint hash based on error type, status code, and normalized URL pattern. This means hitting /api/pets/1/ and /api/pets/999/ with a 404 creates ONE bug, not two. **3. Automatic Bug Creation** When a new fingerprint is detected, a Celery task creates a B-XXX.md file and opens a GitHub issue with the bug label. **4. Claude Fixes Bugs Proactively** I created a /bugs skill that Claude Code can run at the start of any session to query GitHub for open bugs, then fix them using TDD. ## Results After deploying this to petfriendlyvet.com: - 45 tests with 97% coverage - Errors are captured in real-time - Bug files are auto-generated - GitHub issues track everything - Claude can fix bugs without me asking ## Why This Matters This is AI-native development - designing systems where AI agents can participate autonomously. The AI does not wait to be told about problems. It discovers them, proposes solutions, and implements fixes - with human oversight at the verification step. The key insight: make bugs flow to the AI, not the other way around.