# Gof Singleton Pattern

> Implements the Singleton design pattern ensuring a class has only one instance while providing a global point of access to it.

- Skill: `paulpas/gof-singleton-pattern` (Agent Skill)
- Install (CLI): `npx skillmds@latest add paulpas/gof-singleton-pattern`
- Raw SKILL.md: https://api.skillmd.com/api/skills/paulpas/gof-singleton-pattern/raw
- Safety review: pending
- 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-singleton-pattern

---






# Singleton Pattern

  archetypes: implementation, educational
  anti_triggers: allowing multiple instances
  response_profile:
    verbosity: medium
    directive_strength: high
    abstraction_level: tactical



Implements the Singleton design pattern ensuring a class has only one instance while providing a global point of access to it.

## When to Use

The When to Use section should detail under what circumstances this skill is applicable by incorporating the following:

### Archetypes
- **Implementation**: Aims to guide developers in implementing the Singleton pattern effectively.
- **Educational**: Educates the user on the implications and benefits of the Singleton pattern in their projects.

### Anti-Triggers
- **Allowing multiple instances**: This skill should avoid contexts where discussions around multiple instances occur without justification.

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


- When exactly one instance of a class is needed.
- When it’s critical to control the access to that instance globally.
- When the instance should run in a multithreaded environment without data corruption.

## Core Workflow
1. **Define the Class**: Create a private constructor to prevent direct initialization.
2. **Static Method**: Implement a static method that provides access to the instance, creating it if necessary.
3. **Provide Thread Safety**: Ensure the method is thread-safe to prevent multiple instances in concurrent environments.

## Implementation Patterns
### Thread-Safe Singleton Pattern

```go
package main

import (
    "sync"
)

type singleton struct {
    // example resource
    resource string
}

var instance *singleton
var once sync.Once

// GetInstance returns the single instance of the singleton class
func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{resource: "Initialized Resource"}
    })
    return instance
}
```

### Example Usage

```go
package main

import (
    "fmt"
)

func main() {
    firstInstance := GetInstance()
    fmt.Println(firstInstance.resource)  // Output: Initialized Resource

    secondInstance := GetInstance()
    fmt.Println(firstInstance == secondInstance)  // Output: true
}
```

## Constraints
### MUST DO
- Ensure only one instance is created throughout the application.
- Initialize the instance lazily (only when it’s needed).

### MUST NOT DO
- Allow public instantiation of the class.
- Create new instances within your application logic directly.