A curated collection of 12 Claude Code plugins that form a complete software engineering team. Each plugin is a specialized expert agent — no runtime build system, just shell scripts and SKILL.md prompts.

한국어 버전은 아래에 있습니다 →

User Request
    │
    ▼
sub-team-lead (classify & route)
    ├── Single domain  → Direct delegation to one expert
    ├── Multi domain   → Sequential/parallel multi-expert dispatch
    ├── Existing skill → Pass-through to matching skill
    └── Ambiguous      → Ask user for clarification

You don't need all 12 experts. Install only the ones that match your workflow.

Every expert works independently. There are no required dependencies between plugins.

# Example: Install only code-reviewer and test-engineer
/plugin install sub-code-reviewer@hungrytech-plugins
/plugin install sub-test-engineer@hungrytech-plugins

sub-team-lead is useful when you have 3+ experts installed — it auto-routes your requests. With 1-2 experts, just call them directly.

When multiple experts are installed, they can hand off work to each other. This is automatic — no configuration needed. If a sister skill isn't installed, the expert simply skips the handoff and continues on its own.

sub-api-designer ──design──→ sub-kopring-engineer ──implement──→ sub-test-engineer
       │                                                              │
       └── works fine alone                              works fine alone

sub-api-designer ──spec──→ sub-frontend-engineer ──UI──→ sub-devops-engineer
       │                          │                           │
       └── works fine alone       └── works fine alone        └── works fine alone

Marketplace:

/plugin marketplace add hungrytech/hungrytech-claude-skills
/plugin install <skill-name>@hungrytech-plugins

Manual (single plugin):

git clone https://github.com/hungrytech/hungrytech-claude-skills.git
cp -r plugins/<skill-name>/skills/<skill-name> /path/to/project/.claude/skills/

Manual (multiple plugins):

git clone https://github.com/hungrytech/hungrytech-claude-skills.git
for skill in sub-kopring-engineer sub-test-engineer sub-code-reviewer; do
  cp -r plugins/$skill/skills/$skill /path/to/project/.claude/skills/
done

Every plugin shares the same core pattern:

• SKILL.md — Entry point that Claude Code reads. Core prompt + workflow definition.
• resources/ — On-demand loading per phase. Only injected when that phase starts (token efficiency).

plugins/{expert-name}/
├── .claude-plugin/
│   └── plugin.json              # Hook definitions (PreToolUse/PostToolUse/Stop)
└── skills/{expert-name}/
    ├── SKILL.md                 # Entry point — core prompt & workflow
    ├── resources/               # Phase-specific protocol docs
    ├── references/              # Static reference material
    ├── scripts/                 # Deterministic shell scripts (bash + jq)
    └── templates/               # Code/config generation templates

Hooks in plugin.json automate quality gates:

• Zero external dependencies: bash + jq + git only
• Deterministic: No LLM calls — pattern matching and validation only
• macOS compatible: bash 3.2+ (no declare -A, no bash 4+ features)
• Cache location: ~/.claude/cache/

Team orchestrator that classifies user requests and routes them to the appropriate expert(s).

Workflow: Classify → Route → Coordinate → Synthesize

/sub-team-lead
"Kotlin API 설계하고 테스트 생성해줘"

The classifier script (classify-request.sh) uses keyword matching to identify which expert(s) should handle a request. For multi-domain requests, it dispatches to multiple experts in sequence or parallel.

Routing patterns:

Keywords: "team lead", "팀 리드", "프로젝트 설정", "기술 스택", "어떤 전문가", "who should", "coordinate"

Kotlin/Java Spring Boot implementation agent with convention verification.

Workflow: Brainstorm → Plan → Implement → Verify

/sub-kopring-engineer
Order 취소 기능 구현해줘. loop 3

Convention checks (25 items, 7 categories): Architecture layer deps, style (constructor injection, no @Autowired), naming (*JpaEntity, *RestController), JOOQ, test patterns, JPA, git conventions. All checks run as shell commands — zero LLM tokens.

Pattern learning: learn-patterns.sh extracts base classes, annotations, naming patterns from source code and caches them. capture-task-patterns.sh detects new patterns after each verify loop.

Type-driven test generation for Java/Kotlin/TypeScript/Go backends.

Workflow: Analyze → Strategize → Generate → Validate

/sub-test-engineer
OrderService 테스트 생성. loop 3

Type extraction: 3-stage pipeline — ast-grep (structural) → LLM (semantic) → ClassGraph (bytecode). Derives test cases from sealed classes, enums, validation annotations.

Validation: compile → execute → coverage → mutation test → quality evaluation. With 5+ targets, Agent Teams run tests in parallel (~60% time reduction).

Contract-first API design agent with OpenAPI 3.1 spec generation.

Workflow: Analyze → Design → Validate → Document

/sub-api-designer
주문 API 설계해줘. REST, 페이지네이션 포함

Capabilities: OpenAPI 3.1 spec generation, breaking change detection, REST patterns (pagination, filtering, RFC 7807 error responses), mock server setup, contract test stub generation.

Sister-skill integration: → sub-kopring-engineer (controller implementation) → sub-test-engineer (contract tests) → engineering-workflow SE (API security review)

Language-agnostic code review and refactoring agent.

Workflow: Scan → Analyze → Propose → Verify

/sub-code-reviewer
OrderService 코드 리뷰해줘

Analysis: SOLID violations, code smells (God class, Feature Envy, Long Method, etc.), cyclomatic/cognitive complexity, Martin Fowler refactoring catalog-based diff suggestions.

Tech debt formula: Debt Score = Σ(severity × frequency × fix_cost) — prioritized improvement plan.

Scripts: detect-language.sh (language detection), measure-complexity.sh (basic complexity metrics)

DevOps/CI-CD agent for infrastructure and deployment.

Workflow: Discover → Design → Generate → Validate

/sub-devops-engineer
GitHub Actions CI/CD 파이프라인 만들어줘

Templates: Multi-stage Dockerfile, GitHub Actions CI/CD, K8s Deployment/Service, Terraform modules.

Capabilities: Dockerfile best practices (multi-stage, non-root, layer caching), CI/CD pipelines (GitHub Actions, GitLab CI), Kubernetes patterns, Terraform IaC, deployment strategies (Blue-Green, Canary, Rolling), secret management.

Performance analysis and optimization agent.

Workflow: Baseline → Analyze → Optimize → Validate

/sub-performance-engineer
주문 API 성능 분석해줘. slow query 포함

Capabilities: JVM profiling (JFR, async-profiler, heap/GC/thread), DB query optimization (EXPLAIN, slow query, N+1 detection), load testing (k6, Gatling), connection pool sizing, caching strategies, response time budget allocation.

Scripts: detect-performance-stack.sh (JVM/DB/cache detection), analyze-slow-query.sh (N+1 and query pattern detection)

Routes architecture queries across DB, BE, IF, SE domains using 60+ micro-agents.

Workflow: Classify → Route → Execute → Resolve → Synthesize

/engineering-workflow
"Design a multi-tenant architecture with tenant isolation"

Scripts: classify-query.sh (domain classification), resolve-constraints.sh (conflict detection), audit-analysis.sh (quality checks), format-output.sh (output formatting)

Numerical computing verification and optimization for Python/Dart.

Workflow: Analyze → Verify → Optimize

/numerical
numpy broadcasting 검증. loop 2

Capabilities: IEEE 754 floating-point analysis, broadcasting validation, dtype tracking, SIMD/GPU optimization, numerically stable algorithm suggestions (log-sum-exp, Kahan summation, Welford's algorithm).

Meta-plugin that monitors other plugins and suggests improvements.

/plugin-introspector dashboard
/plugin-introspector quick-scan --target my-plugin

Time-bounded autonomous execution orchestrator.

/claude-autopilot
API 엔드포인트 리팩토링하고 테스트 추가해줘. --until 15:30

Accepts a directive and deadline, then autonomously decomposes tasks, executes them, and manages time budget. Includes safety guardrails (no destructive ops, secret file protection, scope enforcement).

Time levels: NORMAL (>50%) → AWARE (30-50%) → CAUTION (15-30%) → WIND_DOWN (5-15%) → CRITICAL (<5%)

React/Vite/TypeScript frontend development agent.

Workflow: Discover → Design → Implement → Verify

/sub-frontend-engineer
로그인 페이지 만들어줘

Tech stack: React 18+, Vite, TypeScript, Tailwind CSS, React Router, Zustand, TanStack Query.

Testing: Vitest + React Testing Library (unit/integration), Playwright (E2E).

Scripts: detect-frontend-stack.sh (stack detection), measure-bundle-size.sh (bundle analysis)

Sister-skill integration: → sub-api-designer (API client hooks) → sub-test-engineer (test strategy) → sub-code-reviewer (code review) → sub-devops-engineer (build + deploy)

Keywords: "react", "vite", "frontend", "프론트엔드", "component", "컴포넌트", "tailwind", "zustand", "tanstack", "vitest", "프론트", "UI", "페이지", "화면"

All scripts run without a build system — bash + jq only:

# Team Lead: Request classification
plugins/sub-team-lead/skills/sub-team-lead/scripts/classify-request.sh "요청 텍스트"

# Kopring: Convention verification
plugins/sub-kopring-engineer/skills/sub-kopring-engineer/scripts/verify-conventions.sh [path]

# Test Engineer: Doc consistency
plugins/sub-test-engineer/skills/sub-test-engineer/scripts/verify-doc-consistency.sh [path]

# API Designer: Framework detection
plugins/sub-api-designer/skills/sub-api-designer/scripts/detect-api-framework.sh [path]

# Code Reviewer: Complexity measurement
plugins/sub-code-reviewer/skills/sub-code-reviewer/scripts/measure-complexity.sh [path]

# DevOps: Infrastructure detection
plugins/sub-devops-engineer/skills/sub-devops-engineer/scripts/detect-infra.sh [path]

# Performance: Slow query analysis
plugins/sub-performance-engineer/skills/sub-performance-engineer/scripts/analyze-slow-query.sh [path]

# Frontend: Stack detection
plugins/sub-frontend-engineer/skills/sub-frontend-engineer/scripts/detect-frontend-stack.sh [path]

# Engineering Workflow: Query classification
plugins/engineering-workflow/skills/engineering-workflow/scripts/classify-query.sh "query"

# Numerical: Numeric code verification
plugins/numerical/skills/numerical/scripts/verify-numeric.sh [path]

MIT

12개의 Claude Code 플러그인으로 구성된 완전한 소프트웨어 엔지니어링 팀. 각 플러그인은 전문 영역의 에이전트로, 런타임 빌드 시스템 없이 셸 스크립트와 SKILL.md 프롬프트만으로 동작합니다.

사용자 요청
    │
    ▼
sub-team-lead (분류 & 라우팅)
    ├── 단일 도메인  → 해당 전문가 직접 위임
    ├── 멀티 도메인  → 순차/병렬 멀티 전문가 디스패치
    ├── 기존 스킬    → 기존 스킬로 패스스루
    └── 모호한 요청  → 사용자에게 명확화 요청

12명 전부 설치할 필요 없습니다. 자신의 워크플로우에 맞는 전문가만 골라 설치하세요.

모든 전문가는 독립적으로 동작합니다. 플러그인 간 필수 의존성은 없습니다.

# 예시: code-reviewer와 test-engineer만 설치
/plugin install sub-code-reviewer@hungrytech-plugins
/plugin install sub-test-engineer@hungrytech-plugins

sub-team-lead는 전문가 3명 이상 설치 시 유용합니다 — 요청을 자동 라우팅합니다. 1-2명이면 직접 호출하는 게 빠릅니다.

여러 전문가가 설치되면 자동으로 작업을 넘겨줍니다. 별도 설정 불필요. 자매 스킬이 없으면 핸드오프를 건너뛰고 혼자 계속합니다.

sub-api-designer ──설계──→ sub-kopring-engineer ──구현──→ sub-test-engineer
       │                                                        │
       └── 단독으로도 OK                              단독으로도 OK

sub-api-designer ──스펙──→ sub-frontend-engineer ──UI──→ sub-devops-engineer
       │                          │                           │
       └── 단독으로도 OK           └── 단독으로도 OK            └── 단독으로도 OK

마켓플레이스:

/plugin marketplace add hungrytech/hungrytech-claude-skills
/plugin install <skill-name>@hungrytech-plugins

수동 설치 (단일 플러그인):

git clone https://github.com/hungrytech/hungrytech-claude-skills.git
cp -r plugins/<skill-name>/skills/<skill-name> /path/to/project/.claude/skills/

수동 설치 (여러 플러그인):

git clone https://github.com/hungrytech/hungrytech-claude-skills.git
for skill in sub-kopring-engineer sub-test-engineer sub-code-reviewer; do
  cp -r plugins/$skill/skills/$skill /path/to/project/.claude/skills/
done

모든 플러그인이 공유하는 핵심 패턴:

• SKILL.md — Claude Code가 읽는 진입점. 코어 프롬프트와 워크플로우 정의.
• resources/ — 단계별 on-demand 로딩. 토큰 효율을 위해 필요한 단계에서만 주입.

plugins/{expert-name}/
├── .claude-plugin/
│   └── plugin.json              # 훅 정의 (PreToolUse/PostToolUse/Stop)
└── skills/{expert-name}/
    ├── SKILL.md                 # 진입점 — 코어 프롬프트 & 워크플로우
    ├── resources/               # 페이즈별 프로토콜 문서
    ├── references/              # 정적 레퍼런스 자료
    ├── scripts/                 # 결정론적 셸 스크립트 (bash + jq)
    └── templates/               # 코드/설정 생성 템플릿

plugin.json의 훅으로 품질 게이트를 자동화:

• 외부 의존성 제로: bash + jq + git만 사용
• 결정론적: LLM 호출 없음 — 패턴 매칭과 검증만 수행
• macOS 호환: bash 3.2+ (associative array 미사용)
• 캐시 경로: ~/.claude/cache/

사용자 요청을 분류하여 적절한 전문가에게 라우팅하고, 멀티 전문가 협업을 조율합니다.

워크플로우: Classify → Route → Coordinate → Synthesize

/sub-team-lead
"Kotlin API 설계하고 테스트 생성해줘"

분류 스크립트(classify-request.sh)가 키워드 매칭으로 어떤 전문가가 처리할지 판단합니다. 멀티 도메인 요청은 여러 전문가를 순차 또는 병렬로 디스패치합니다.

라우팅 패턴:

활성화 키워드: "team lead", "팀 리드", "프로젝트 설정", "기술 스택", "어떤 전문가", "who should", "coordinate"

Kotlin/Java Spring Boot 코드베이스에서 Brainstorm, Plan, Implement, Verify 파이프라인을 실행합니다.

워크플로우: Brainstorm → Plan → Implement → Verify

/sub-kopring-engineer
Order 취소 기능 구현해줘. loop 3

컨벤션 검사 (25개 항목, 7개 카테고리): 아키텍처 레이어 의존성, 스타일 (생성자 주입, @Autowired 금지), 네이밍 (*JpaEntity, *RestController), JOOQ, 테스트 패턴, JPA, git 컨벤션. 모든 검사는 셸 명령으로 실행 — LLM 토큰 소모 제로.

패턴 학습: learn-patterns.sh가 소스 코드에서 베이스 클래스, 어노테이션, 네이밍 패턴을 추출하여 캐시합니다. capture-task-patterns.sh가 검증 루프마다 새 패턴을 감지합니다.

Java/Kotlin/TypeScript/Go 백엔드의 타입 정보를 읽어 테스트를 생성합니다.

워크플로우: Analyze → Strategize → Generate → Validate

/sub-test-engineer
OrderService 테스트 생성. loop 3

타입 추출: 3단계 파이프라인 — ast-grep (구조) → LLM (시맨틱) → ClassGraph (바이트코드). sealed class, enum, 검증 어노테이션에서 테스트 케이스를 도출합니다.

검증: 컴파일 → 실행 → 커버리지 → 뮤테이션 테스트 → 품질 평가. 5개 이상 대상 시 Agent Teams 병렬 실행 (~60% 시간 절감).

OpenAPI 3.1 표준에 따른 Contract-first API 설계 에이전트.

워크플로우: Analyze → Design → Validate → Document

/sub-api-designer
주문 API 설계해줘. REST, 페이지네이션 포함

기능: OpenAPI 3.1 스펙 생성, Breaking Change 감지, REST 패턴 (페이지네이션, 필터링, RFC 7807 에러 응답), Mock 서버, Contract Test 스텁 생성.

자매 스킬 연동: → sub-kopring-engineer (컨트롤러 구현) → sub-test-engineer (Contract 테스트) → engineering-workflow SE (API 보안 검토)

언어에 구애받지 않는 코드 품질 리뷰 및 리팩토링 에이전트.

워크플로우: Scan → Analyze → Propose → Verify

/sub-code-reviewer
OrderService 코드 리뷰해줘

분석: SOLID 위반, 코드 스멜 (God class, Feature Envy, Long Method 등), 순환/인지 복잡도, Martin Fowler 리팩토링 카탈로그 기반 diff 제안.

기술 부채 공식: Debt Score = Σ(severity × frequency × fix_cost) — 우선순위 기반 개선 계획.

스크립트: detect-language.sh (언어 감지), measure-complexity.sh (복잡도 메트릭)

IaC, CI/CD 파이프라인, 컨테이너화, 배포 전략을 설계하고 생성합니다.

워크플로우: Discover → Design → Generate → Validate

/sub-devops-engineer
GitHub Actions CI/CD 파이프라인 만들어줘

템플릿: 멀티 스테이지 Dockerfile, GitHub Actions CI/CD, K8s Deployment/Service, Terraform 모듈.

기능: Dockerfile 모범 사례 (멀티 스테이지, non-root, 레이어 캐싱), CI/CD 파이프라인 (GitHub Actions, GitLab CI), Kubernetes 패턴, Terraform IaC, 배포 전략 (Blue-Green, Canary, Rolling), 시크릿 관리.

JVM, DB, 시스템 수준의 성능 병목을 분석하고 최적화합니다.

워크플로우: Baseline → Analyze → Optimize → Validate

/sub-performance-engineer
주문 API 성능 분석해줘. slow query 포함

기능: JVM 프로파일링 (JFR, async-profiler, 힙/GC/스레드), DB 쿼리 최적화 (EXPLAIN, 슬로우 쿼리, N+1 감지), 부하 테스트 (k6, Gatling), Connection Pool 사이징, 캐싱 전략, 응답 시간 버짓 할당.

스크립트: detect-performance-stack.sh (JVM/DB/캐시 감지), analyze-slow-query.sh (N+1/쿼리 패턴 감지)

DB, BE, IF, SE 4개 도메인에 걸쳐 60+ 마이크로 에이전트로 아키텍처 질의를 라우팅합니다.

워크플로우: Classify → Route → Execute → Resolve → Synthesize

/engineering-workflow
"멀티 테넌트 아키텍처 설계, 테넌트 격리 포함"

Python/Dart 수치 연산 코드의 정확성 검증 및 성능 최적화.

워크플로우: Analyze → Verify → Optimize

/numerical
numpy broadcasting 검증. loop 2

기능: IEEE 754 부동소수점 분석, 브로드캐스팅 검증, dtype 추적, SIMD/GPU 최적화, 수치적으로 안정한 알고리즘 제안 (log-sum-exp, Kahan summation, Welford's algorithm).

다른 플러그인의 도구 호출, API 요청, 토큰 사용량, 실행 패턴을 수집하여 개선합니다.

/plugin-introspector dashboard
/plugin-introspector quick-scan --target my-plugin

사용자 지시와 마감 시간을 받아 자율적으로 작업을 분해, 실행, 시간 관리합니다.

/claude-autopilot
API 엔드포인트 리팩토링하고 테스트 추가해줘. --until 15:30

시간 레벨: NORMAL (>50%) → AWARE (30-50%) → CAUTION (15-30%) → WIND_DOWN (5-15%) → CRITICAL (<5%)

안전장치: 파괴적 명령 차단, 시크릿 파일 보호, 스코프 강제, force push 금지, 3회 연속 동일 에러 시 자동 중단.

React + Vite + TypeScript 기반 프론트엔드 프로젝트의 컴포넌트 설계, 상태 관리, 스타일링, 빌드 최적화를 수행합니다.

워크플로우: Discover → Design → Implement → Verify

/sub-frontend-engineer
로그인 페이지 만들어줘

기술 스택: React 18+, Vite, TypeScript, Tailwind CSS, React Router, Zustand, TanStack Query.

테스트: Vitest + React Testing Library (단위/통합), Playwright (E2E).

스크립트: detect-frontend-stack.sh (스택 감지), measure-bundle-size.sh (번들 분석)

자매 스킬 연동: → sub-api-designer (API 클라이언트/훅 생성) → sub-test-engineer (테스트 전략 위임) → sub-code-reviewer (코드 리뷰) → sub-devops-engineer (Vite 빌드 + Docker + CI/CD)

활성화 키워드: "react", "vite", "frontend", "프론트엔드", "component", "컴포넌트", "tailwind", "zustand", "tanstack", "vitest", "프론트", "UI", "페이지", "화면"

모든 스크립트는 빌드 시스템 없이 실행 — bash + jq만 필요:

# 팀 리드: 요청 분류
plugins/sub-team-lead/skills/sub-team-lead/scripts/classify-request.sh "요청 텍스트"

# Kopring: 컨벤션 검증
plugins/sub-kopring-engineer/skills/sub-kopring-engineer/scripts/verify-conventions.sh [경로]

# 테스트 엔지니어: 문서 일관성 검증
plugins/sub-test-engineer/skills/sub-test-engineer/scripts/verify-doc-consistency.sh [경로]

# API 디자이너: 프레임워크 감지
plugins/sub-api-designer/skills/sub-api-designer/scripts/detect-api-framework.sh [경로]

# 코드 리뷰어: 복잡도 측정
plugins/sub-code-reviewer/skills/sub-code-reviewer/scripts/measure-complexity.sh [경로]

# DevOps: 인프라 파일 감지
plugins/sub-devops-engineer/skills/sub-devops-engineer/scripts/detect-infra.sh [경로]

# 성능 엔지니어: 슬로우 쿼리 분석
plugins/sub-performance-engineer/skills/sub-performance-engineer/scripts/analyze-slow-query.sh [경로]

# 프론트엔드: 스택 감지
plugins/sub-frontend-engineer/skills/sub-frontend-engineer/scripts/detect-frontend-stack.sh [경로]

# 엔지니어링 워크플로우: 쿼리 분류
plugins/engineering-workflow/skills/engineering-workflow/scripts/classify-query.sh "쿼리"

# 수치 연산: 수치 코드 검증
plugins/numerical/skills/numerical/scripts/verify-numeric.sh [경로]

MIT