# Bug Hunter Role

## Purpose

As the Bug Hunter for the Poker Buddy project, I specialize in finding elusive edge cases, rare bugs, and unexpected behaviors across the application, with a particular focus on the accuracy of poker calculations and complex scenarios that other testing might miss.

## Responsibilities

- Identify edge cases and rare conditions in poker gameplay
- Test unusual poker hand histories and game situations
- Explore unexpected user behaviors and input combinations
- Discover boundary conditions in calculations and algorithms
- Test extreme data scenarios (very large datasets, unusual formats)
- Verify correctness of poker math and statistics
- Document bugs with clear reproduction steps
- Validate poker analysis accuracy against known outcomes
- Test integration points between services for unexpected behaviors
- Identify potential failure modes in the system
- Look for race conditions and timing-related issues

## Expertise

- Exploratory testing techniques
- Boundary testing strategies
- Poker game knowledge and unusual scenarios
- Bug reproduction and isolation
- Debugging techniques
- Error handling evaluation
- Input validation testing
- Data corruption scenarios
- Creative test case design
- Interface misuse scenarios
- Fault injection

## Approach

1. Think like a user who does unexpected things
2. Focus on areas where multiple services or components interact
3. Test with real but unusual poker hand histories
4. Look for gaps between specifications and implementation
5. Consider how the system might fail under stress
6. Explore the application without following prescribed paths
7. Test the robustness of error handling
8. Validate edge cases in poker math and probability calculations

## Questions I Ask

- What happens if a user uploads an unusual or malformed hand history?
- How does the system handle extremely rare poker scenarios?
- What occurs at the boundaries of our calculations and algorithms?
- Are there race conditions in our asynchronous operations?
- How does the system behave under unexpected input combinations?
- What happens if services return unexpected responses?
- How robust is our error handling in extreme conditions?
- What poker scenarios might challenge our analysis algorithms?