api := slack.New(
    "xoxb-your-bot-token",
    slack.OptionDebug(true),
)

When to Use Which Approach

Web API (synchronous operations)

Use for direct API calls where you initiate the action:

Sending messages, creating channels
Retrieving user information
Uploading files
Any request-response operation

Socket Mode (WebSocket - behind firewall)

Use when your app runs behind a firewall and can't receive HTTP requests:

Real-time event handling without public URL
Apps running on local machines or private networks
Development and testing environments

Events API (HTTP webhooks - public URL)

Use when you have a publicly accessible endpoint:

Production apps with HTTPS endpoints
Event-driven architectures with webhooks
Apps hosted on cloud platforms

Error Handling Patterns

Always handle errors from API calls:

_, _, err := api.PostMessage(channelID, slack.MsgOptionText(text, false))
if err != nil {
    // Handle specific error types
    if rateLimitedError, ok := err.(*slack.RateLimitedError); ok {
        // Wait and retry
        time.Sleep(rateLimitedError.RetryAfter)
    }
    return fmt.Errorf("failed to post message: %w", err)
}

Use context for cancellation and timeouts:

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

// Pass context to API methods that support it

Project Structure Recommendation

slack-bot/
├── cmd/
│   └── bot/
│       └── main.go           # Entry point
├── internal/
│   ├── handlers/
│   │   ├── messages.go       # Message handlers
│   │   ├── events.go         # Event handlers
│   │   └── commands.go       # Slash command handlers
│   ├── slack/
│   │   ├── client.go         # Slack client wrapper
│   │   └── middleware.go     # Authentication, rate limiting
│   └── config/
│       └── config.go         # Configuration management
├── pkg/
│   └── models/               # Shared data models
├── go.mod
└── go.sum

Testing Strategies

See testing-patterns.md for comprehensive testing guidance including:

Mocking the Slack API client
Integration testing patterns
Test fixtures for events and messages
CI/CD testing recommendations

Configuration Best Practices

For advanced configuration including custom HTTP clients, retry strategies, and rate limiting:

See client-configuration.md

Next Steps

Based on your use case, explore these skills:

Web API operations → Use the slack-web-api skill for messaging, channels, users, files
Real-time events → Use the slack-realtime-events skill for Socket Mode or Events API
OAuth setup → Use the slack-auth-security skill for multi-workspace authentication

Common Pitfalls

Hardcoding tokens in code (use environment variables)
Not handling rate limits (implement exponential backoff)
Forgetting to validate incoming webhook signatures
Using blocking operations in event handlers (use goroutines)
Not implementing proper context cancellation

slack-client-fundamentals

Slack Go SDK Client Fundamentals

Client Initialization