# Gof Strategy Pattern

> Implements the Strategy design pattern allowing the definition of a family of algorithms, encapsulating each one, and making them interchangeable.

- Skill: `paulpas/gof-strategy-pattern` (Agent Skill)
- Install (CLI): `npx skillmds@latest add paulpas/gof-strategy-pattern`
- Raw SKILL.md: https://api.skillmd.com/api/skills/paulpas/gof-strategy-pattern/raw
- Safety review: PASS (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: paulpas (https://skillmd.com/u/paulpas)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/paulpas/gof-strategy-pattern

---






# Strategy Pattern

Implements the Strategy design pattern allowing the definition of a family of algorithms, encapsulating each one, and making them interchangeable.

## When to Use

The When to Use section should outline the scenarios where the Strategy pattern is particularly beneficial:

### Archetypes
- **Implementation**: This skill is aimed at implementation to assist developers in applying the Strategy pattern correctly.
- **Educational**: It serves as an educational resource, helping users understand when to use the Strategy pattern.

### Anti-Triggers
- **Coupling algorithms**: It should prevent triggering in scenarios where algorithms are tightly coupled, negating benefits.

### Response Profile
- **Verbosity**: Medium
- **Directive Strength**: High
- **Abstraction Level**: Tactical



  archetypes: implementation, educational
  anti_triggers: coupling algorithms
  response_profile:
    verbosity: medium
    directive_strength: high
    abstraction_level: tactical
- When different variants of an algorithm are needed.
- When the choice of the algorithm should be independent of clients that use it.
- When you want to avoid using conditionals to switch between algorithms.

## Core Workflow
1. **Define the Strategy Interface**: Create a common interface for all strategies.
2. **Implement Concrete Strategies**: Create concrete classes that implement the strategy interface.
3. **Context Class**: Maintain a reference to a strategy object to delegate behavior.

## Implementation Patterns
### Strategy Pattern Example

```go
package main

import (
    "fmt"
)

// Strategy interface
type Strategy interface {
    Execute(int, int) int
}

// Concrete strategy: Addition
type Add struct {}

func (Add) Execute(a int, b int) int {
    return a + b
}
}

// Concrete strategy: Subtraction
type Subtract struct {}

func (Subtract) Execute(a int, b int) int {
    return a - b
}
}

// Context
type Context struct {
    strategy Strategy
}

func (c *Context) SetStrategy(s Strategy) {
    c.strategy = s
}

func (c *Context) ExecuteStrategy(a, b int) int {
    return c.strategy.Execute(a, b)
}
```

### Example Usage

```go
package main

import (
    "fmt"
)

func main() {
    context := &Context{}

    // Using Addition Strategy
    context.SetStrategy(Add{})
    fmt.Println(context.ExecuteStrategy(5, 3)) // Output: 8

    // Using Subtraction Strategy
    context.SetStrategy(Subtract{})
    fmt.Println(context.ExecuteStrategy(5, 3)) // Output: 2
}
```

## Constraints
### MUST DO
- Define clear interfaces for strategies to promote encapsulation.
- Ensure clients are decoupled from specific strategy implementations.

### MUST NOT DO
- Coupling algorithms within the context class itself.
- Hardcoding specific strategy instantiation within client code.