| name | loop-detection |
| description | Use when identifying and preventing infinite loops, detecting loop patterns, implementing loop exit strategies, and creating loop safety mechanisms. Includes loop analysis, timeout patterns, and loop monitoring. Based on programming best practices and loop safety patterns. |
| license | MIT |
Loop Detection Skill — Monitor & Loop Guardian
Overview
This skill provides comprehensive guidance for detecting and preventing infinite loops. It covers loop pattern identification, exit strategy implementation, timeout patterns, and loop monitoring following programming best practices and loop safety patterns.
When to Use
Use this skill when:
- Identifying potential infinite loops in code
- Detecting loop patterns in algorithms
- Implementing loop exit strategies
- Adding timeout mechanisms to loops
- Creating loop safety guards
- Analyzing loop termination conditions
- Implementing loop counters
- Creating loop monitoring
- Detecting loop stagnation
- Implementing loop backoff strategies
- Creating loop retry mechanisms
- Adding loop progress tracking
- Implementing loop cancellation
- Creating loop documentation
- Analyzing loop performance
- Detecting loop resource leaks
- Implementing loop limits
- Creating loop validation
- Detecting loop edge cases
- Implementing loop error handling
- Creating loop optimization strategies
- Adding loop logging
- Implementing loop health checks
Do NOT use this skill when:
- Writing application business logic (use domain-driven skill)
- Designing database schemas (use database-design skill)
- Writing API endpoint specifications (use api-design skill)
- Performing security audits (use security-auditor skill)
- Writing SQL queries (use sql-best-practices skill)
- Designing multi-page website layouts (use design-system skill)
- Analyzing deployment configurations (use deployment skill)
- Writing documentation (use documentation-best-practices skill)
Loop Patterns
Common Loop Patterns
┌─────────────────────────────────────────────────────────────┐
│ Loop Patterns │
├─────────────────────────────────────────────────────────────┤
│ While Loop: │
│ while condition: │
│ # Loop body │
│ # Must modify condition │
│ │
│ For Loop: │
│ for i in range(n): │
│ # Loop body │
│ # Uses counter or iterator │
│ │
│ Do-While Loop: │
│ do { │
│ # Loop body │
│ } while (condition); │
│ │
│ Nested Loop: │
│ for i in range(n): │
│ for j in range(m): │
│ # Nested loop body │
│ │
│ Infinite Loop: │
│ while true: │
│ # Must have break condition │
│ if exit_condition: │
│ break │
└─────────────────────────────────────────────────────────────┘
Loop Exit Strategies
┌─────────────────────────────────────────────────────────────┐
│ Loop Exit Strategies │
├─────────────────────────────────────────────────────────────┤
│ 1. Counter-Based: │
│ for i in range(max_iterations): │
│ if condition: │
│ break │
│ │
│ 2. Condition-Based: │
│ while not done: │
│ if success: │
│ done = True │
│ │
│ 3. Timeout-Based: │
│ start_time = time.now() │
│ while time.now() - start_time < timeout: │
│ if condition: │
│ break │
│ │
│ 4. State-Based: │
│ while state != 'completed': │
│ state = update_state(state) │
│ │
│ 5. Resource-Based: │
│ while resources_available(): │
│ process_resource() │
└─────────────────────────────────────────────────────────────┘
Loop Safety Mechanisms
Timeout Pattern
import time
def process_with_timeout(max_duration=30):
start_time = time.time()
while not task_completed():
if time.time() - start_time > max_duration:
raise TimeoutError("Loop timed out")
time.sleep(0.1)
Counter Pattern
def process_with_max_iterations(max_iterations=1000):
count = 0
while not task_completed():
if count >= max_iterations:
raise RuntimeError("Max iterations reached")
count += 1
process_iteration()
Backoff Pattern
import time
def retry_with_backoff(max_retries=5, base_delay=1):
for attempt in range(max_retries):
try:
return perform_task()
except Exception as e:
if attempt == max_retries - 1:
raise
delay = base_delay * (2 ** attempt)
time.sleep(delay)
Loop Detection Techniques
Static Analysis
┌─────────────────────────────────────────────────────────────┐
│ Static Analysis │
├─────────────────────────────────────────────────────────────┤
│ Check for: │
│ - Missing loop termination condition │
│ - Loop variable not updated │
│ - Condition always true │
│ - No break statements │
│ - Infinite recursion in loops │
│ │
│ Tools: │
│ - Linters (ESLint, Pylint) │
│ - Static analysis tools (SonarQube) │
│ - IDE warnings │
└─────────────────────────────────────────────────────────────┘
Dynamic Analysis
┌─────────────────────────────────────────────────────────────┐
│ Dynamic Analysis │
├─────────────────────────────────────────────────────────────┤
│ Monitor at runtime: │
│ - Loop iteration count │
│ - Execution time │
│ - Resource usage │
│ - State changes │
│ │
│ Techniques: │
│ - Add counters to loops │
│ - Log loop progress │
│ - Monitor memory usage │
│ - Track execution time │
└─────────────────────────────────────────────────────────────┘
Loop Health Monitoring
┌─────────────────────────────────────────────────────────────┐
│ Loop Health Monitoring │
├─────────────────────────────────────────────────────────────┤
│ Metrics: │
│ - Iteration count │
│ - Duration per iteration │
│ - Total loop duration │
│ - Memory usage per iteration │
│ - CPU usage per iteration │
│ │
│ Alerts: │
│ - Iteration limit exceeded │
│ - Duration threshold exceeded │
│ - Resource usage spike │
│ - No progress detected │
└─────────────────────────────────────────────────────────────┘
Loop Best Practices
Loop Design Checklist
┌─────────────────────────────────────────────────────────────┐
│ Loop Design Checklist │
├─────────────────────────────────────────────────────────────┤
│ [ ] Loop has clear termination condition │
│ [ ] Loop variable is properly updated │
│ [ ] Loop has timeout mechanism │
│ [ ] Loop has max iteration limit │
│ [ ] Loop handles edge cases │
│ [ ] Loop has error handling │
│ [ ] Loop has progress logging │
│ [ ] Loop has cancellation support │
│ [ ] Loop has resource cleanup │
│ [ ] Loop has documentation │
└─────────────────────────────────────────────────────────────┘
Loop Documentation Template
def process_items(items, max_iterations=1000, timeout=30):
"""
Process items with safety mechanisms.
Args:
items: List of items to process
max_iterations: Maximum number of iterations (default: 1000)
timeout: Maximum duration in seconds (default: 30)
Returns:
Processed items list
Raises:
RuntimeError: If max iterations reached
TimeoutError: If timeout exceeded
"""
start_time = time.time()
count = 0
for item in items:
count += 1
if count >= max_iterations:
raise RuntimeError("Max iterations reached")
if time.time() - start_time > timeout:
raise TimeoutError("Loop timed out")
process(item)
return items
Real-World Impact
Before this skill:
- Infinite loops causing crashes
- Resource exhaustion
- No loop monitoring
- Difficult debugging
- Production outages
After this skill:
- Safe loops with exit strategies
- Proper resource management
- Loop monitoring and alerts
- Easy debugging
- Production stability
Cross-References
debugging - For loop debuggingperformance - For loop optimizationtesting-strategy - For loop testing
References
