Golang Error Handling

Expert-level error handling review for Go applications. Ensures proper error wrapping, context propagation, and error checking that preserves error chains and enables proper timeout/cancellation handling.

When to Apply

Use this skill when:

• Reviewing error propagation patterns
• Checking context usage and cancellation
• Auditing error wrapping with %w vs %v
• Investigating timeout or cancellation issues
• Verifying nil checks for interfaces
• Ensuring errors.Is/As usage

Rule Categories by Priority

Priority	Count	Focus
Critical	3	Prevents error chain loss, context leaks
High	3	Correctness and reliability
Medium	1	Code quality

Rules Covered (7 total)

Critical Issues (3)

• critical-error-wrapping - Use %w for error wrapping, not %v
• critical-error-shadow - Don't shadow err variable in nested scopes
• critical-context-leak - Always defer cancel() after context creation

High-Impact Patterns (3)

• high-context-propagation - Propagate context through call chain
• high-error-is-as - Use errors.Is/As instead of ==
• high-interface-nil - Check interface nil correctly

Medium Improvements (1)

• medium-sentinel-error-usage - Use sentinel errors for stable categories

How to Use

For Error Handling Review

1. Scan code for error handling patterns
2. Check against rules in priority order (Critical first)
3. Verify error wrapping preserves error chains
4. Ensure context propagation for timeouts/cancellation
5. Check for proper nil interface handling

Common Patterns

Error chain review:

Check this code for proper error wrapping

Context propagation audit:

Verify context is propagated correctly

Error checking patterns:

Review error handling for wrapped errors

Trigger Phrases

This skill activates when you say:

• "Review error handling"
• "Check error wrapping"
• "Verify context propagation"
• "Check for context leaks"
• "Review error chains"
• "Audit error patterns"

Output Format

## Critical Error Handling Issues: X

### [Rule Name] (Line Y)
**Issue**: Brief description
**Impact**: Lost error chain / Context leak / Wrong error check
**Fix**: Suggested correction
**Example**:
```go
// Corrected code

Related Skills

• golang-concurrency-safety - For goroutine context patterns
• golang-clean-architecture - For error handling across layers

Philosophy

Based on Go best practices:

• Error chains are valuable - Use %w to preserve error context
• Context is essential - Always propagate for cancellation/timeout
• Errors are values - Use errors.Is/As for wrapped error checking
• Nil interfaces are tricky - Check correctly to avoid bugs

Notes

• Focus on error handling correctness
• All examples show proper error wrapping patterns
• Context propagation is critical for production systems
• Related to concurrency but focused on error semantics