Communitygithub.com

lawzava/megapowers

코딩 에이전트(Claude Code, Codex, OpenCode, Antigravity)의 작동 방식을 바꾸는 스킬, 플러그인, 훅. 측정된 결과, 느낌이 아닌.

megapowers란 무엇인가요?

이 스킬은 Go 언어의 모범 사례(design patterns)를 종합적으로 제공하여, AI 코딩 에이전트가 더 일관되고 고품질의 Go 코드를 생성하도록 돕습니다. 특히, 단순한 동시성(concurrency) 패턴(작업자 풀, 파이프라인 등)은 최신 Claude 모델이 이미 완벽하게 처리하지만, 인터페이스 설계, 의존성 주입, 오류 처리, 패키지 구조와 같은 아키텍처 결정을 내릴 때 이 스킬을 사용하는 것이 좋습니다. 이 스킬은 Claude Code, Cursor, Codex 등 다양한 AI 코딩 플랫폼에서 사용할 수 있으며, SKILL.md 문서에는 함수형 옵션, 작은 인터페이스, 의존성 주입, 컨텍스트 전파, 테스트 패턴 등 Go의 핵심 관용구가 실제 코드 예제와 함께 설명되어 있습니다. 결과적으로 이 스킬은 Go 코드 리뷰 체크리스트 역할을 하거나, 약한 모델을 안내하거나, 프로젝트 전반에 걸쳐 일관된 Go 스타일을 유지하는 데 유용합니다.

지원 대상✓Claude Code✓Codex CLI~Cursor✓Antigravity✓OpenCode
npx skills add lawzava/megapowers

즐겨 사용하는 AI에게 물어보기

이 에이전트 스킬이 미리 로드된 새 채팅을 엽니다.

문서

Go 패턴

측정됨: 현재 최전선 및 소형 Claude 모델은 이미 이 스킬 없이도 일반적인 동시성 메커니즘(작업자 풀, 파이프라인 단계, 채널 닫기)을 단일 샷으로 올바르게 작성합니다. 통제된 연구 결과 두 그룹 모두에서 정확도 향상 여지가 0이고 184/184 테스트를 통과했습니다(저장소의 evals/RESULTS.md §2 참조). 이 스킬은 디자인 선택(인터페이스, 의존성 와이어링, 오류 구성, 패키지 레이아웃)을 위한 리뷰 체크리스트로, 또는 약한 모델을 안내할 때 사용하세요. 현재 모델이 그렇지 않으면 교착 상태에 빠질 수 있기 때문이 아닙니다.

범위: Go 파일, go.mod, go.sum. 출처: Everything Claude Code에서 파생됨(MIT, (c) 2026 Affaan Mustafa).

이 스킬은 일반적인 디자인 원칙을 Go 특화 관용구로 확장하는 포괄적인 Go 패턴을 제공합니다.

함수형 옵션(Functional Options)

유연한 생성자 구성을 위해 함수형 옵션 패턴을 사용하세요.

type Option func(*Server)

func WithPort(port int) Option {
    return func(s *Server) { s.port = port }
}

func NewServer(opts ...Option) *Server {
    s := &Server{port: 8080}
    for _, opt := range opts {
        opt(s)
    }
    return s
}

장점:

  • 하위 호환되는 API 진화
  • 기본값을 사용한 선택적 매개변수
  • 자체 문서화되는 구성

작은 인터페이스(Small Interfaces)

인터페이스는 구현되는 곳이 아니라 사용되는 곳에서 정의하세요.

원칙: 인터페이스를 받고, 구조체를 반환하라

// 좋음: 사용 지점에 정의된 작고 집중된 인터페이스
type UserStore interface {
    GetUser(id string) (*User, error)
}

func ProcessUser(store UserStore, id string) error {
    user, err := store.GetUser(id)
    // ...
}

장점:

  • 더 쉬운 테스트 및 모킹
  • 느슨한 결합
  • 명확한 의존성

의존성 주입(Dependency Injection)

생성자 함수를 사용하여 의존성을 주입하세요.

func NewUserService(repo UserRepository, logger Logger) *UserService {
    return &UserService{
        repo:   repo,
        logger: logger,
    }
}

패턴:

  • 생성자 함수(New* 접두사)
  • 매개변수로서의 명시적 의존성
  • 구체적인 타입 반환
  • 생성자에서 의존성 검증

동시성 패턴(Concurrency Patterns)

작업자 풀(Worker Pool)

func workerPool(jobs <-chan Job, results chan<- Result, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- processJob(job)
            }
        }()
    }
    // 모든 작업자가 완료되면 results 채널을 닫습니다. 작업자가 여전히 결과를 생성하는 동안
    // 호출자가 results를 range할 수 있도록 별도의 고루틴에서 실행하여 이 함수가 즉시 반환되게 합니다.
    // 인라인 wg.Wait()는 교착 상태를 유발합니다. 작업자는 results에 전송할 때 리더가 이를 소비할 때까지
    // 차단되지만, 리더는 workerPool이 반환된 후에야 실행됩니다.
    go func() {
        wg.Wait()
        close(results)
    }()
}

컨텍스트 전파(Context Propagation)

항상 컨텍스트를 첫 번째 매개변수로 전달하세요.

func FetchUser(ctx context.Context, id string) (*User, error) {
    // 컨텍스트 취소 확인
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    // ... 가져오기 로직
}

오류 처리(Error Handling)

오류 래핑(Error Wrapping)

if err != nil {
    return fmt.Errorf("failed to fetch user %s: %w", id, err)
}

사용자 정의 오류(Custom Errors)

type ValidationError struct {
    Field string
    Msg   string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Msg)
}

센티널 오류(Sentinel Errors)

var (
    ErrNotFound = errors.New("not found")
    ErrInvalid  = errors.New("invalid input")
)

// errors.Is로 확인
if errors.Is(err, ErrNotFound) {
    // not found 처리
}

패키지 구성(Package Organization)

구조

project/
├── cmd/              # 메인 애플리케이션
│   └── server/
│       └── main.go
├── internal/         # 비공개 애플리케이션 코드
│   ├── domain/       # 비즈니스 로직
│   ├── handler/      # HTTP 핸들러
│   └── repository/   # 데이터 접근
└── pkg/              # 공개 라이브러리

명명 규칙

  • 패키지 이름: 소문자, 단일 단어
  • 반복(stutter) 피하기: user.User이지 user.UserModel이 아닙니다.
  • 비공개 코드에는 internal/ 사용
  • main 패키지는 최소화

테스트 패턴(Testing Patterns)

테이블 기반 테스트(Table-Driven Tests)

func TestValidate(t *testing.T) {
    tests := []struct {
        name    string
        input   string
        wantErr bool
    }{
        {"valid", "[email protected]", false},
        {"invalid", "not-an-email", true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := Validate(tt.input)
            if (err != nil) != tt.wantErr {
                t.Errorf("got error %v, wantErr %v", err, tt.wantErr)
            }
        })
    }
}

테스트 헬퍼(Test Helpers)

// 순수 Go 드라이버를 가져옵니다: _ "modernc.org/sqlite" ("sqlite"로 등록됨).
// "sqlite3"(mattn/go-sqlite3)을 사용하지 마세요. CGO가 필요하고 CGO_ENABLED=0 정적 빌드가
// 깨집니다. greenfield-go-stack 번들은 순수 Go/CGO-프리만을 요구합니다.
func testDB(t *testing.T) *sql.DB {
    t.Helper()
    db, err := sql.Open("sqlite", ":memory:")
    if err != nil {
        t.Fatalf("failed to open test db: %v", err)
    }
    // ":memory:" 데이터베이스는 단일 연결에 비공개이며, database/sql은
    // 지연 풀입니다. 이 설정이 없으면 각 풀링된 연결은 자체 빈 데이터베이스를 가지므로
    // 한 연결에서 생성된 테이블은 다음 연결에서 누락됩니다.
    // 풀을 단일 연결로 고정하면 전체 테스트가 하나의 인메모리 DB를 공유합니다.
    // 주의: 단일 연결에서는 트랜잭션(db.Begin)이 열려 있는 동안 해당 트랜잭션이 유일한 연결을
    // 보유합니다. Commit/Rollback까지 모든 작업을 트랜잭션을 통해 라우팅하세요.
    // 풀에 대한 동시 db.Query는 이를 기다리며 차단됩니다. 테스트가 진정으로 여러 활성 연결을
    // 필요로 한다면 대신 공유 캐시 DSN("file:testdb?mode=memory&cache=shared")을 사용하고
    // 인메모리 DB가 삭제되지 않도록 하나 이상의 연결을 열린 상태로 유지하세요.
    db.SetMaxOpenConns(1)
    t.Cleanup(func() { db.Close() })
    return db
}

이 스킬을 사용해야 할 때

  • Go API 및 패키지 설계
  • 동시성 시스템 구현
  • Go 프로젝트 구조화
  • 관용적인 Go 코드 작성
  • Go 코드베이스 리팩토링

관련 스킬