go-interfaces_skill

Overview

This skill distills Go interface design into practical guidance for building flexible, testable, and decoupled code. It covers interface basics, composition, duck typing, common patterns, and pitfalls so you can design clear APIs and abstractions in Go. Use it to make interfaces small, composable, and easy to mock in tests.

How this skill works

The skill explains how Go interfaces are defined and satisfied implicitly, how to compose interfaces by embedding, and how to use type assertions and switches for dynamic behavior. It highlights common standard interfaces (io.Reader/io.Writer, error, fmt.Stringer) and shows patterns like dependency injection, strategy, adapter, and builder. Guidance includes compile-time interface checks and proper handling of nil interfaces.

When to use it

• Designing public APIs or library boundaries
• Decoupling components for easier testing and mocking
• Implementing strategy, adapter, or plugin systems
• Composing behavior from small, focused interfaces
• Accepting interfaces in functions and returning concrete types
• Avoiding over-abstraction and designing maintainable code

Best practices

• Keep interfaces small and focused (typically 1–3 methods)
• Accept interfaces in parameters, return concrete types from constructors
• Define interfaces at the call site, not where types are implemented
• Compose interfaces by embedding to build richer contracts
• Prefer standard library interfaces when they fit (io.Reader, error, fmt.Stringer)
• Verify interface implementation at compile time with var _ Interface = (*Type)(nil)

Example use cases

• Expose a minimal Reader interface for file or network consumers
• Swap database implementations with a UserRepository interface for tests
• Implement PaymentStrategy to switch payment providers at runtime
• Adapt a third-party logger to your Logger interface with an adapter
• Build a fluent SQL QueryBuilder interface for reusable query construction