PARA/03_Resources/R001_개발_레퍼런스(참고문서)/개발 환경과 도구/슈퍼 클로드코드 사용자 가이드.md

슈퍼 클로드코드 사용자 가이드

2025년 7월 22일

🎯 단순한 진실

겉보기엔 복잡해 보이지만, 실제로 SuperClaude는 아주 쉽게 쓸 수 있어요.

모든 명령어, 플래그, 페르소나를 다 외울 필요 없습니다. 그냥 쓰기 시작하세요! 🎈

SuperClaude는 당신이 뭘 원하는지 파악하려는 지능형 라우팅 시스템을 갖추고 있습니다:

/analyze some-code/ 입력 → 알아서 맞는 분석 도구 선택
보안 질문 → 보안 전문가 자동 활성화
프론트엔드 작업 → UI specialist가 담당
디버깅 → 조사(Investigation) 모드 발동

쓰면서 배우게 됩니다. 매뉴얼부터 공부할 필요 없이, 자연스럽게 ‘먹히는 방식’을 익히게 될 거예요.

아래의 자세한 가이드는 “방금 무슨 일이 일어난 거지?” 싶을 때나 더 깊이 파고들고 싶을 때 보면 됩니다. 솔직히? 대부분은 그냥 감으로 써도 됩니다. 😊

TL;DR: 설치하고, 코드에 /analyze나 /build 한번 던져보세요. 마법이 펼쳐집니다.

이 문서는 SuperClaude v3.0을 제대로 이해하고 활용하기 위한 종합 가이드입니다. 하지만 기억하세요—원하면 바로 실사용부터 해도 됩니다!

목차 📖

Welcome & Overview
Core Components
The Three Operational Modes
The Orchestrator System
Rules & Principles
Getting Started Workflows
Integration & Coordination
Practical Examples
Tips & Best Practices
Troubleshooting
What's Next

🚀 여기서 시작하세요 (Just Start Here)

읽는 거 건너뛰고 바로 해보고 싶나요? 2분이면 됩니다:

# Claude Code에서 아래 명령들을 시도해보세요:
/sc:help                    # 가능한 것들 보기
/sc:analyze README.md       # 프로젝트를 분석
/sc:workflow feature-prd.md # PRD로부터 구현 워크플로 생성 (NEW!)
/sc:implement user-auth     # 기능/컴포넌트 생성 (v3 신규!)
/sc:build                   # 자동 최적화가 들어간 스마트 빌드
/sc:improve messy-file.js   # 코드 자동 정리

방금 무슨 일이 있었나요? SuperClaude가 자동으로:

작업마다 적절한 도구를 선택하고 🛠️
필요한 전문가(보안, 성능 등)를 활성화하고 🎭
똑똑한 플래그와 최적화를 적용하고 ⚡
근거 있는 제안을 제공합니다 📊

보셨죠? 공부 필요 없습니다. SuperClaude가 복잡한 것들을 대신 처리합니다.

작동 원리가 궁금하면 계속 읽으세요. 그냥 계속 실험하고 싶다면? 마음껏! 🎯

Welcome & Overview 👋

SuperClaude는 진짜 뭐죠? 🤔

SuperClaude는 Claude Code를 개발 작업에 더 똑똑하게 만들어줍니다. 일반적인 답변 대신, 각 분야(보안, 성능, 프론트엔드 등)에 특화된 전문가들의 도움을 받는 셈이죠.

솔직히 말하면: v3.0을 이제 막 베타에서 뺐습니다. 기능은 꽤 잘 돌아가지만, 개선 중이라 거친 부분도 있을 거예요. 실제 개발 워크플로에서 Claude Code가 더 쓸모 있게 하려고 만들었습니다.

멋진 점? 이 모든 복잡함을 직접 관리할 필요가 없습니다. /analyze, /build 같은 평범한 명령만 쓰면 SuperClaude가 어떤 전문가를 부르고, 어떤 도구를 쓸지 알아서 결정합니다. 🪄

SuperClaude가 추가해주는 것들 ✨

🛠️ 17개의 특화 명령어

기획 도구: /workflow(신규!), /estimate, /task
개발 도구: /implement, /build, /design
분석 도구: /analyze, /troubleshoot, /explain
품질 도구: /improve, /cleanup, /test
그 외 문서화, git, 배포 등 유틸리티도 다수
→ 그냥 쓰면 됩니다. 복잡한 건 SuperClaude가 자동 처리.

NEW: /workflow — PRD → 구현 계획 자동화
NEW: /implement — 기능 생성 (v2 기능 복구)

🎭 11개의 스마트 페르소나

도메인에 맞게 행동을 바꾸는 AI 전문가들
요청에 따라 자동 활성화 (보안 작업 → 보안 전문가 등)
수동 제어도 가능하지만, 보통 필요 없음
→ 마치 “알아서 도와주는 개발팀”이 하나 있는 느낌

🔧 MCP 서버 통합 (똑똑한 외부 도구들)

Context7: 공식 라이브러리 문서 조회
Sequential: 복잡한 다단계 분석
Magic: 최신 UI 컴포넌트 생성
Playwright: 브라우저 자동화 & 테스트
→ 필요할 때 자동 연결. 직접 신경 쓸 필요 없습니다.

📋 향상된 작업 관리 (백그라운드에서 동작)

TodoRead/TodoWrite로 진행 상황 추적
/task로 멀티 세션 프로젝트 관리
/spawn으로 복잡한 오케스트레이션
/loop로 반복적 개선
→ 대부분 자동. SuperClaude가 당신의 작업을 추적합니다.

⚡ 토큰 최적화 (스마트한 효율성)

컨텍스트가 꽉 차면 스마트 압축
효율적인 커뮤니케이션을 위한 심볼 시스템
대규모 작업 성능 최적화
→ 큰 프로젝트에서 필요할 때 자동 발동

현재 상태 (v3.0) 📊

✅ 잘 돌아가는 것들:

설치 시스템 (완전 재작성, 훨씬 안정적)
16개 명령어 + 11개 페르소나 기본 프레임워크
MCP 서버 통합(대체로 잘 작동)
기본 작업 관리 & 워크플로 자동화
문서/사용자 가이드

⚠️ 거친 부분:

초기 릴리스라 버그 예상됨
일부 MCP 통합은 더 매끄럽게 할 여지 있음
모든 작업에서 성능 최적화가 된 건 아님
몇몇 고급 기능은 실험적

❌ 제거된 것들:

훅(Hooks) 시스템 (너무 복잡해져서 v4에서 다시 돌아올 예정)

v3은 기초로 꽤 만족스럽지만, 개선할 부분은 많습니다.

어떻게 작동하나요? 🔄

아주 간단히 말하면: /analyze auth.js 같은 걸 입력하면, 나머지는 SuperClaude가 알아서 합니다.

조금 더 자세히 말하면:

스마트 라우팅: 당신이 뭘 원하는지 분석
전문가 자동 선택: 적절한 전문가(보안, 성능 등) 배치
도구 조율: 필요할 때 외부 시스템 연결
품질 보증: 제안의 타당성 확인

이 복잡함을 직접 볼 일은 거의 없습니다. 그냥 “Claude가 개발에 훨씬 똑똑해졌다”는 느낌만 받게 되죠.

좋은 점은, 이 모든 게 대부분 자동으로 일어난다는 것. 요청만 하면 SuperClaude가 적절한 접근을 고민하고, 맞는 도구와 전문성을 붙여 실행합니다. 보통 설정이나 구성 없이 — 그냥 결과가 더 좋아지길 기대하면 됩니다. ✨

Quick Feature Overview 🎯

구성요소	하는 일	더 알아보기 (선택 사항)
Commands	자동으로 활성화되는 15개의 특화 도구	Commands Guide
Flags	대부분 자동으로 적용되는 동작 수정자	Flags Guide
Personas	언제 도와야 할지 아는 11명의 AI 전문가	Personas Guide
MCP Servers	필요할 때 연결되는 외부 통합 도구들	이 가이드
Modes	서로 다른 워크플로를 위한 3가지 운영 모드	이 가이드
Orchestrator	모든 것을 작동하게 하는 스마트 라우팅	이 가이드

기억하세요: 이 가이드를 읽지 않아도 SuperClaude를 충분히 잘 쓸 수 있습니다. 궁금해졌을 때만 보면 돼요! 🎪

Core Components 🧩

SuperClaude는 함께 작동하는 여러 상호연결된 시스템으로 구성됩니다. 각 컴포넌트가 큰 그림에서 어떻게 맞물리는지 살펴볼게요.

Commands: 당신의 툴킷 🛠️

Commands는 특정 개발 작업을 처리하는 전문화된 도구입니다. “이거 좀 도와줘” 같은 범용 요청 대신, 상황에 맞는 목적형 도구를 쓰게 됩니다.

목적별 15개 커맨드:

Development 🔨

/build - 프로젝트 빌드, 컴파일, 번들링
/design - 시스템 아키텍처 및 컴포넌트 설계

Analysis 🔍

/analyze - 코드/시스템 종합 분석
/troubleshoot - 문제 조사 및 디버깅
/explain - 학습용 설명, 개념 정리

Quality ✨

/improve - 코드 개선 및 최적화
/cleanup - 기술 부채 정리
/test - 테스트 및 커버리지 분석

Utilities 🔧

/document - 문서화 생성
/git - 향상된 Git 워크플로우
/load - 프로젝트 컨텍스트 로딩
/estimate - 프로젝트 견적/산정
/task - 장기 프로젝트 관리
/spawn - 복잡한 작업 오케스트레이션
/index - 명령어 탐색 및 도움말

각 커맨드는 고유한 플래그를 갖고, 적합한 페르소나를 자동 활성화하며, 관련 MCP 서버와 통합됩니다. 사용 예시와 패턴은 Commands Guide에서 확인하세요.

Flags: 동작 수정자 🏁

Flags는 SuperClaude가 요청을 처리하는 방식을 바꿉니다. 커맨드라인 옵션처럼 동작을 수정하거나, 기능을 추가하고, 출력 스타일을 변경합니다.

주요 플래그 카테고리:

Planning & Analysis 🧠

--think / --think-hard / --ultrathink - 사고(추론) 깊이 조절
--plan - 실행 전 계획 보여주기

Efficiency & Control ⚡

--uc - 대규모 작업용 초압축 출력
--safe-mode - 보수적 실행 + 검증
--validate - 실행 전 위험도 평가

MCP Server Control 🔧

--c7 - Context7 문서 조회 활성화
--seq - Sequential 다단계 분석 활성화
--magic - Magic UI 컴포넌트 생성 활성화
--play - Playwright 테스트 활성화

Advanced Orchestration 🎭

--delegate - 병렬 처리를 위한 하위 에이전트 위임
--wave-mode - 복합 지능 단계별 실행
--loop - 반복 개선 모드

Focus & Scope 🎯

--focus security - 특정 도메인(예: 보안) 집중
--scope project - 분석 범위 지정
--persona-[name] - 특정 페르소나 강제 활성화

플래그는 맥락에 따라 자동 활성화되는 경우가 많습니다. 예를 들어, 보안 관련 요청은 보통 --persona-security와 --focus security가 자동 붙습니다. 자세한 내용은 Flags Guide를 참고하세요.

Personas: AI 전문가 팀 🎭

Personas는 필요할 때 언제든 호출할 수 있는 전문 인력(전문가) 팀과 같습니다. 각 페르소나는 다른 전문성, 우선순위, 문제 접근 방식을 가집니다.

도메인별 11개 페르소나:

Technical Specialists 🔧

🏗️ architect - 시스템 설계, 장기 아키텍처
🎨 frontend - UI/UX, 접근성, 프론트엔드 성능
⚙️ backend - API, 데이터베이스, 안정성
🛡️ security - 위협 모델링, 취약점
⚡ performance - 최적화, 병목 제거

Process & Quality ✨

🔍 analyzer - 근본 원인 분석, 조사
🧪 qa - 테스트, 품질 보증
🔄 refactorer - 코드 품질, 기술 부채 관리
🚀 devops - 인프라, 배포

Knowledge & Communication 📚

👨‍🏫 mentor - 교육, 지식 전달
✍️ scribe - 문서화, 기술 글쓰기

페르소나는 보통 요청 패턴에 따라 자동 활성화되지만, --persona-[name] 플래그로 직접 지정할 수도 있습니다. 각 페르소나는 다른 우선순위를 가집니다(예: 보안 페르소나는 속도보다 보안을 우선). 자세한 설명과 예시는 Personas Guide에서 확인하세요.

MCP Servers: 외부 기능 확장 🔧

MCP(Model Context Protocol) 서버는 Claude의 기본 능력을 넘어서는 특화 기능을 제공합니다.

통합된 4개 서버:

Context7 📚

목적: 공식 라이브러리 문서 및 베스트 프랙티스 조회
활성 시점: 프레임워크 질문, 외부 라이브러리 사용 시
제공 내용: 최신 문서, 코드 예시, 패턴
예시: /build react-app --c7 → React 베스트 프랙티스 제공

Sequential 🧠

목적: 복잡한 다단계 분석과 체계적 사고
활성 시점: 디버깅, 시스템 설계, --think 플래그 사용 시
제공 내용: 구조화된 문제 해결, 가설 검증
예시: /troubleshoot "auth randomly fails" --seq

Magic ✨

목적: 최신 UI 컴포넌트 생성 및 디자인 시스템
활성 시점: UI 컴포넌트 요청, 프론트엔드 작업
제공 내용: React/Vue/Angular 컴포넌트, 디자인 패턴
예시: /build dashboard --magic → 현대적 UI 컴포넌트 생성

Playwright 🎭

목적: 브라우저 자동화, E2E 테스트, 성능 모니터링
활성 시점: 테스트 워크플로, 성능 분석
제공 내용: 크로스 브라우저 테스트, 비주얼 검증, 메트릭
예시: /test e2e --play → 종합 브라우저 테스트 실행

MCP 서버는 보통 자동으로 조율되지만, --all-mcp, --no-mcp, --c7 같은 개별 플래그로 제어할 수 있습니다.

컴포넌트들이 함께 작동하는 방식 🤝

예시: 보안 분석 요청

/sc:analyze auth-system/ --focus security

일반적으로 일어나는 일:

Command: /analyze가 코드 분석 담당
Flag: --focus security로 보안에 초점
Persona: 🛡️ 보안 전문가 자동 활성화
MCP: Sequential이 체계적 분석 제공
Orchestrator: 최적 실행을 위해 모든 것 라우팅

결과: 위협 모델링 관점의 보안 중심 분석이 체계적 방법론과 종합 커버리지로 제공됩니다.

대부분의 요청에서 이런 식의 협업이 자동으로 일어납니다. SuperClaude가 당신의 요구에 맞는 도구+전문가 조합을 스스로 찾습니다.

세 가지 운영 모드 🎭

SuperClaude는 개발 워크플로의 다른 측면을 최적화하는 3가지 모드로 동작합니다. 이 모드를 이해하면 프레임워크를 더 잘 활용할 수 있어요.

1) Task Management Mode 📋

정의: 진행 추적과 검증이 포함된 구조화된 워크플로 실행
사용 시점: 추적/조율이 필요한 다단계 작업
작동 방식: 작업을 잘게 나누고, 진행을 추적하며, 검증 게이트로 품질을 보장

작업 관리 4계층

Layer 1: Session Tasks (TodoRead/TodoWrite)

범위: 현재 Claude Code 세션
용량: 세션당 3~20개 작업
상태: pending 📋, in_progress 🔄, completed ✅, blocked 🚧
용도: 즉시 진행 중인 작업의 실시간 추적

# SuperClaude가 보통 세션 작업을 생성/관리합니다
/sc:build large-project/
# → 생성: "Analyze project structure", "Run build process", "Validate output"

Layer 2: Project Tasks (/task 커맨드)

범위: 멀티 세션 기능(수일~수주)
구조: 계층형 (Epic → Story → Task)
지속성: 세션 간 상태 유지
용도: 장기 기능 개발

/sc:task create "implement user dashboard" --priority high
/sc:task breakdown "payment integration"
/sc:task status   # 현재 프로젝트 작업 상태 확인

Layer 3: Complex Orchestration (/spawn 커맨드)

범위: 복잡한 다도메인 작업
특징: 병렬/순차 조정, 도구 관리
용도: 여러 도구/시스템이 얽힌 작업

/sc:spawn deploy-pipeline --parallel
/sc:spawn setup-dev-environment --monitor

Layer 4: Iterative Enhancement (/loop 커맨드)

범위: 점진적 개선 워크플로
특징: 검증이 포함된 반복 사이클
용도: 품질 개선/정련

/sc:improve messy-code.js --loop --iterations 3
# → 각 사이클마다 검증 후 단계적 개선

작업 상태 관리

핵심 원칙:

근거 기반 진행(Evidence-Based Progress): “했어요”가 아니라 측정 가능한 결과로 판단
단일 집중 프로토콜(Single Focus Protocol): 한 번에 in_progress는 하나
실시간 업데이트: 진행에 따라 즉각 상태 변경
품질 게이트(Quality Gates): 완료 표시 전 검증 필수

작업 감지 기준:

다단계 작업(3단계 이상) → 자동 작업 분해
키워드: build, implement, create, fix, optimize → 작업 추적 활성화
범위 표시어: system, feature, comprehensive → 진행 모니터링 추가

Introspection Mode 🧠

정의: SuperClaude가 스스로의 추론과 의사결정 과정을 메타 인지적으로 분석하는 모드입니다.

사용 시점:

복잡한 문제 해결
프레임워크 트러블슈팅
학습/회고가 필요한 순간
혹은 --introspect로 명시적으로 요청했을 때

작동 방식:
SuperClaude가 일반 동작에서 한 발 물러나 사고 패턴, 결정 로직, 실행 순서를 분석합니다.

핵심 기능

Reasoning Analysis 🧠

논리 흐름과 결정 근거 검토
사고(Chain of Thought)의 일관성 평가
가정과 잠재적 편향 식별
증거 기반으로 추론 검증

Action Sequence Review 🔄

도구 선택의 효과성 분석
워크플로 패턴 및 효율성 점검
대안적 접근 방식 고려
최적화 기회 탐색

Framework Compliance Check 🔍

SuperClaude 규칙/원칙 준수 여부 확인
표준 패턴에서 이탈한 지점 식별
필요 시 교정 가이드 제공
품질 기준 충족 보장

Learning Recognition 💡

결과로부터 인사이트 추출
성공 패턴 재사용 식별
개선이 필요한 지식 공백 인식
향후 최적화 전략 제안

분석 마커(표식)

Introspection 모드가 활성화되면 다음과 같은 마커가 보입니다:

🧠 Reasoning Analysis - 논리 흐름/결정 검토
🔄 Action Sequence Review - 워크플로 효과 분석
🎯 Self-Assessment - 메타 인지적 자기 평가
📊 Pattern Recognition - 행동 패턴 식별
🔍 Framework Compliance - 규칙 준수 점검
💡 Retrospective Insight - 결과로부터의 학습

활성화 조건

보통 다음 상황에서 활성화됨:

메타 인지적 감독이 필요한 복잡한 다단계 문제
기대와 다른 결과가 나왔을 때의 오류 복구
프레임워크 논의 또는 SuperClaude 자체 트러블슈팅
반복되는 행동의 패턴 인식 필요 시

수동 활성화 예시:

/sc:analyze complex-system/ --introspect
/sc:troubleshoot "framework confusion" --introspection

Token Efficiency Mode ⚡

정의: 품질을 유지하면서 정보 밀도를 극대화하는 지능형 최적화 시스템입니다.

사용 시점:

대규모 작업
컨텍스트가 한계에 가까워질 때
더 빠른 실행이 필요할 때

작동 방식:
상황과 페르소나 인식을 바탕으로 심볼, 약어, 구조 최적화를 활용해 적응형 압축을 수행합니다.

압축 전략

5단계 적응형 압축 레벨:

Minimal (0~40%): 페르소나 최적화된 명료한 전체 상세
Efficient (40~70%): 도메인 인식 기반 균형 잡힌 압축
Compressed (70~85%): 품질 게이트를 둔 공격적 최적화
Critical (85~95%): 핵심 컨텍스트만 유지하는 최대 압축
Emergency (95%+): 정보 검증을 동반한 초압축

심볼 시스템

논리 & 흐름:

→ 이어짐, 암시 (예: auth.js:45 → security risk)
⇒ 변환됨 (input ⇒ validated_output)
& 그리고, 결합 (security & performance)
» 순서, 다음 단계 (build » test » deploy)
∴ 그러므로 (tests fail ∴ code broken)

상태 & 진행:

✅ 완료, 통과
❌ 실패, 오류
⚠️ 경고
🔄 진행 중
🎯 목표, 타겟

기술 도메인:

⚡ Performance
🔍 Analysis
🛡️ Security
📦 Deployment
🎨 Design

활성화 전략

보통 다음 상황에서 활성화됨:

컨텍스트 사용량 > 75% → 압축 모드 가동
대규모 작업 → 토큰 초과 방지
복잡한 오케스트레이션 → 커뮤니케이션 최적화

수동 활성화 예시:

/sc:analyze huge-codebase/ --uc              # 초압축 모드
/sc:improve legacy-system/ --uc --delegate auto  # 대규모 효율 작업

성능 목표 (지속 개선 중)

토큰 절감 목표: 약 30~50%
정보 유지율: 약 95% 목표
속도: 압축 결정 < 100ms 지향
통합: 프레임워크 컴포넌트와 연동

모드 통합 예시

세 가지 모드는 종종 함께 작동합니다:

/sc:improve large-legacy-system/ --wave-mode auto --uc --introspect

일어나는 일:

Task Management: 진행 추적이 가능한 구조화된 개선 계획 생성
Token Efficiency: 대규모 작업에 맞춰 출력 압축
Introspection: 개선 전략 분석 및 접근 방식 검증

오케스트레이터 시스템 🎯

오케스트레이터는 SuperClaude의 지능형 라우팅 시스템으로, 당신의 요청을 분석해 가장 알맞은 도구, 페르소나, 통합 기능(MCP 등)을 조합해줍니다. 덕분에 SuperClaude가 단순히 툴 묶음이 아니라 “똑똑하고 반응 빠른” 도우미처럼 느껴지죠.

오케스트레이터 작동 방식 🔄

스마트한 디스패처(배분기)처럼 생각하세요:

요청의 의도와 복잡도를 분석
가장 적합한 커맨드, 플래그, 페르소나, MCP 서버를 라우팅
최적 결과를 위해 실행을 조율
품질 게이트로 결과 검증
성능과 리소스 사용 최적화

Detection Engine 🧠

모든 요청을 여러 관점에서 분석합니다.

패턴 인식 & 복잡도 감지

복잡도 등급:

Simple: 단일 파일, 기본 작업(3단계 미만) → 직접 실행
Moderate: 다중 파일, 분석 작업(3~10단계) → 표준 라우팅
Complex: 시스템 전반 변경, 아키텍처 결정(10단계 초과) → 고급 오케스트레이션

도메인 식별:

Frontend: “UI”, “component”, “responsive” → 🎨 frontend 페르소나 + Magic MCP
Backend: “API”, “database”, “service” → ⚙️ backend 페르소나 + Context7 MCP
Security: “vulnerability”, “auth”, “compliance” → 🛡️ security 페르소나 + Sequential MCP
Performance: “slow”, “optimize”, “bottleneck” → ⚡ performance 페르소나 + Playwright MCP

작업 유형 분류:

Analysis: “analyze”, “review”, “understand” → Sequential MCP + analyzer 페르소나
Creation: “create”, “build”, “implement” → Magic MCP(UI의 경우) 또는 Context7(패턴)
Modification: “improve”, “refactor”, “optimize” → 적합한 전문 페르소나
Debugging: “troubleshoot”, “fix”, “debug” → Sequential MCP + analyzer 페르소나

Auto-Activation Logic

고신뢰 트리거(90% 이상 확률로 발동):

/sc:analyze auth-system/ --focus security
# → 🛡️ security 페르소나 + Sequential MCP + --validate 플래그

컨텍스트 기반 활성화:

/sc:build react-components/
# → 🎨 frontend 페르소나 + Magic MCP + --c7 플래그(React 문서)

성능 기반 활성화:

# 컨텍스트 사용량 >75%일 때
/sc:analyze large-project/
# → 자동으로 --uc 플래그(압축) 추가

Routing Intelligence 🚦

라우팅 시스템은 동적 의사결정 트리로 감지된 패턴을 최적의 도구 조합에 매핑합니다.

마스터 라우팅 테이블

요청 패턴	보통 자동 활성화	빈도	이유
"analyze architecture"	🏗️ architect + `--ultrathink` + Sequential	대부분	복잡한 시스템 분석
"create UI component"	🎨 frontend + Magic + `--uc`	꽤 자주	프론트엔드 생성 도메인
"security audit"	🛡️ security + `--ultrathink` + Sequential	대부분	보안 전문성 필요
"debug complex issue"	🔍 analyzer + `--think` + Sequential	자주	조사/분석 접근법
"improve performance"	⚡ performance + `--think-hard` + Playwright	꽤 자주	성능 전문 + 테스트

Intelligent Coordination

다중 서버 연계 예시

/sc:design user-dashboard --type api

오케스트레이터는 보통 이렇게 조율합니다:

🏗️ architect 페르소나 (시스템 설계)
🎨 frontend 페르소나 (UI 설계)
Context7 MCP (프레임워크 패턴)
Sequential MCP (설계 방법론)

폴백 전략:

Context7 사용 불가 → WebSearch로 문서 탐색 → 수동 구현
Sequential 타임아웃 → Claude 자체 분석 → 제한점 명시
Magic 실패 → 기본 컴포넌트 생성 → 수동 개선 제안

Quality Gates & Validation Framework ✅

SuperClaude는 작업 시 8단계 검증 사이클을 시도합니다.

8단계 품질 프로세스

Syntax Validation - 언어 파서 + Context7 표준
Type Checking - Sequential 분석 + 호환성 검증
Linting - Context7 규칙 + 품질 분석
Security Review - Sequential 분석 + OWASP 준수
Testing - Playwright E2E + 커버리지 분석(높은 커버리지 목표)
Performance - Sequential 분석 + 벤치마킹
Documentation - Context7 패턴 + 완전성 검증
Integration - Playwright 테스트 + 배포 검증

검증 자동화

지속적 통합(CI/CD): 점진적 검증 + 조기 실패 감지, 근거 자료 생성
지능형 모니터링: 성공률 추적 + ML 기반 예측, 과거 패턴 기반 적응형 검증, 검증 전략 자동 최적화

Performance Optimization ⚡

오케스트레이터는 여러 전략으로 성능을 최적화합니다.

리소스 관리

토큰 할당:

Detection Engine: 패턴 분석에 1~2K 토큰
Decision Trees: 라우팅 로직에 500~1K 토큰
MCP Coordination: 활성화 서버 수에 따라 가변
Reserve: 갑작스런 복잡도 대비 10% 버퍼

작업 배치(Operation Batching):

의존성이 없는 경우 병렬 실행
관련 작업 간 컨텍스트 공유
성공한 라우팅 패턴 캐싱 전략
리소스 고갈 방지를 위한 스마트 큐잉

Advanced Orchestration

서브 에이전트 위임(Sub-Agent Delegation)

# 디렉터리 7개 이상 또는 파일 50개 이상 감지 시 자동 활성화
/sc:analyze monorepo/
# → --delegate auto 플래그 + 병렬 처리

웨이브 오케스트레이션(Wave Orchestration)

# 복잡도 >0.7 + 파일 >20 + 작업 유형 >2 일 때 자동 활성화
/sc:improve legacy-system/
# → --wave-mode auto + 다단계 실행

실제 오케스트레이션 예시 💡

예시 1: 보안 분석 요청

/sc:analyze user-auth/ --focus security

오케스트레이터 분석:

도메인: 보안(고신뢰)
복잡도: 중간(인증 시스템)
작업 유형: 분석 + 스캐닝

보통 조합:

🛡️ security 페르소나 (위협 모델링 시각)
Sequential MCP (체계적 분석)
--validate 플래그 (사전 안전 검증)
--think 플래그 (복잡한 보안 패턴)

품질 게이트: 8단계 전부 수행, 보안 검증에 중점

예시 2: 프론트엔드 성능 최적화

/sc:improve slow-dashboard/ --focus performance

오케스트레이터 분석:

도메인: 프론트엔드 + 성능 (이중 전문 필요)
복잡도: 높음(최적화 작업)
작업 유형: 개선 + 검증

보통 조합:

⚡ performance 페르소나 (주 담당)
🎨 frontend 페르소나 (UI 관련 시 보조)
Playwright MCP (성능 테스트)
--think-hard 플래그 (복잡 최적화)

품질 게이트: 벤치마킹 중심의 성능 검증

예시 3: 대규모 코드베이스 분석

/sc:analyze enterprise-monorepo/

오케스트레이터 분석:

범위: 큼(파일 50개 이상)
복잡도: 높음(엔터프라이즈 규모)
리소스: 높은 토큰 사용 예상

보통 조합:

--delegate auto 플래그 (병렬 처리)
--uc 플래그 (토큰 최적화)
🏗️ architect 페르소나 (시스템 레벨 분석)
Sequential MCP (구조화된 분석)

품질 게이트: 서브 에이전트 간 분산 검증

오케스트레이터 설정 ⚙️

orchestrator_config:
  enable_caching: true
  parallel_operations: true
  max_parallel: 3
  token_reserve: 10%
  emergency_threshold: 90%
 
Intelligence Settings:
  learning_enabled: true
  confidence_threshold: 0.7
  pattern_detection: aggressive
  wave_score_threshold: 0.7

오케스트레이터는 성공적인 패턴을 학습하고, 이후 라우팅 결정을 점점 더 개선하려고 합니다.

규칙 & 원칙 📏

SuperClaude는 일관되고 신뢰할 수 있으며 도움이 되는 행동을 보장하기 위한 핵심 규칙과 원칙에 따라 작동합니다. 이를 이해하면 SuperClaude가 문제를 어떻게 접근하고 왜 그런 결정을 내리는지 예측할 수 있어요.

Core Operational Rules ⚖️

SuperClaude가 따르려는 핵심 규칙입니다.

File Operation Security 🔐

항상 읽고 나서 쓰기/수정: 현재 내용을 이해하지 못한 채 파일을 수정하지 않음
절대 경로만 사용: 경로 도약 공격 방지 및 안정적 파일 작업 보장
자동 커밋 금지: 명시적 요청 없이는 git에 커밋하지 않음
배치 작업 선호: 관련된 변경들은 일괄 처리하여 일관성 유지

왜 중요한가? 데이터 손실, 보안 취약점, 의도치 않은 코드 변경을 방지합니다.

Task Management Rules 📋

근거 기반 진행: 측정 가능한 증거가 있을 때만 완료로 표시
단일 집중 프로토콜: 한 번에 in_progress 상태 작업은 하나만
품질 게이트: 완료 전에 항상 검증 단계 포함
컨텍스트 유지: 작업 간 컨텍스트를 가능하면 잘 보존

왜 중요한가? 신뢰할 수 있는 진행 추적을 보장하고, 작업이 누락되거나 잊히지 않도록 합니다.

Framework Compliance Rules 🎯

의존성 먼저 확인: 라이브러리 사용 전 package.json/requirements.txt 검증
기존 패턴 준수: 프로젝트 컨벤션, import 스타일, 아키텍처 존중
체계적 코드베이스 변경: 전역 수정 전 전체 탐색 수행
완료 검증: 변경 사항이 동작하고 기존 기능을 깨뜨리지 않는지 확인

왜 중요한가? 기존 프로젝트 구조와 품질을 유지합니다.

Development Principles 🛠️

SuperClaude의 개발 문제 접근 방식은 다음 원칙에 기반합니다.

Evidence-Based Decision Making 📊

기본 지침: “Evidence > assumptions | Code > documentation | Efficiency > verbosity”

최적화 전 측정: 실제 메트릭 기반 성능 개선
가설을 체계적으로 테스트: 검증 가능한 데이터로 주장 뒷받침
의사결정 근거 문서화: 아키텍처 선택 이유 명확화
결과에서 학습: 결과에 따른 지속적 개선

예시

/sc:improve slow-api/ --focus performance
# → 현재 성능 측정 → 병목 식별 → 데이터 기반 최적화

SOLID Design Principles 🏗️

Single Responsibility: 컴포넌트는 한 가지 변경 이유만
Open/Closed: 확장에는 열려 있고, 수정에는 닫혀 있게
Liskov Substitution: 자식 클래스는 부모 클래스를 대체 가능해야 함
Interface Segregation: 사용하지 않는 인터페이스에 의존 강요 금지
Dependency Inversion: 구체 구현이 아닌 추상에 의존

왜 따르는가? 유지보수성, 확장성, 유연성이 높은 코드를 만들기 위해서입니다.

Quality Philosophy ✨

검출보다 예방: 테스트로 잡기보다 처음부터 품질 내재화
복잡함보다 단순함: 동작하는 가장 단순한 해법 선택
영리함보다 유지보수성: 쉽게 이해/수정 가능한 코드
기본값은 보안: 처음부터 안전한 패턴 적용

Senior Developer Mindset 🎓

경험 많은 개발자처럼 접근합니다:

시스템적 사고: 전체 시스템 영향 고려
장기 관점: 여러 시간축에서 결정 평가
리스크 보정: 허용 가능한 리스크 vs. 불가 리스크 구분
이해관계자 인식: 기술적 완벽 vs. 실무 제약 균형

당신에게 미치는 영향 💡

Predictable Behavior (예측 가능성)

일관된 규칙 덕분에 SuperClaude의 접근을 예측할 수 있습니다.

/sc:improve legacy-authentication/

예상할 수 있는 것들:

변경 전 기존 코드 읽기
프로젝트의 기존 패턴 준수
보안 우선 접근(보안 페르소나가 활성화될 확률 높음)
근거와 추론을 포함한 제안
완료 전 품질 게이트 적용

Quality Assurance (품질 보증)

원칙은 높은 품질 결과를 보장합니다:

마법 같은 변경 지양: 보통 추론/근거를 설명
기능 파손 방지 지향: 기존 기능 유지
보안 의식: 보안 원칙 중시
부채 인식: 복잡도 유지/감소 노력

Transparency (투명성)

SuperClaude가 무엇을 왜 하는지 보통 이해할 수 있습니다.

/sc:analyze --introspect complex-system/

보여주는 내용:

의사결정 과정
규칙 적용 방식
원칙 준수 여부
고려된 대안들

Rules & Principles 적용 예시 🎯

예시 1: 체계적 리팩터링

요청: “이 지저분한 코드베이스 정리해줘”

적용된 규칙:

변경 전 전체 탐색 수행
수정 전 모든 파일 읽기
기존 프로젝트 패턴 준수
증거 기반 완료 검증

적용된 원칙:

복잡함보다 단순함
근거 기반 결정(정리 전/후 복잡도 측정)
품질 보증(포괄 테스트)
장기 유지보수성 고려

예시 2: 보안 구현

요청: “API에 인증 추가해줘”

적용된 규칙:

보안 페르소나 자동 활성화
보안 기본 원칙 타협 금지
기존 패턴 우선 확인
보안 검증 포함한 품질 게이트

적용된 원칙:

기본값은 보안(Security by default)
심층 방어(Defense in depth)
근거 기반 접근(검증된 보안 패턴 준수)
시스템적 사고(애플리케이션 전체 영향 고려)

예시 3: 성능 최적화

요청: “이 페이지가 느리게 로드돼”

적용된 규칙:

최적화 전 측정
근거 기반 진행 추적
메트릭으로 개선 검증
기존 기능 유지

적용된 원칙:

측정 기반 최적화
사용자 경험 중점
체계적 방법론
검출보다 예방(근본 원인 식별)

Rule Enforcement & Quality Gates 🚨

SuperClaude는 품질 게이트 시스템으로 규칙을 집행합니다.

집행 방식

사전 검증: 시작 전 리스크 검사
실시간 모니터링: 실행 중 규칙 준수 추적
사후 검증: 종료 후 규칙 준수 확인
근거 수집: 투명성을 위한 증거 기록

규칙이 도전받을 때

때로는 규칙이 즉각적인 필요와 충돌할 수 있습니다.

예시: “일단 빨리 되게만 해줘, 퀄리티는 신경 쓰지 마”

SuperClaude의 대응:

긴급성을 인정
장기적으로 왜 품질 규칙이 중요한지 설명
핵심 규칙을 지키는 타협안 제시
품질 기준을 낮출 경우 리스크 문서화

페르소나 행동을 이끄는 원칙 🎭

모든 페르소나가 공통 원칙을 따르지만, 강조점은 다릅니다:

🛡️ Security 페르소나: Security > compliance > reliability > performance
⚡ Performance 페르소나: Measure first > optimize critical path > user experience
🏗️ Architect 페르소나: Long-term maintainability > scalability > performance
🎨 Frontend 페르소나: User needs > accessibility > performance > technical elegance

왜 중요한가? 각 페르소나가 어떤 트레이드오프를 우선시할지 예측할 수 있습니다.

Living Principles 🌱

이 규칙과 원칙은 고정불변이 아닙니다. 다음에 따라 진화합니다:

커뮤니티 피드백: 실제 사용 패턴 반영
결과 분석: 성공 패턴 강화
기술 변화: 새로운 개발 관행에 맞춰 적응
사용자 니즈: 유연성과 일관성의 균형

목표는 도움이 되면서도 예측 가능한 행동을 유지하되, 소프트웨어 개발 환경 변화에 적응하는 것입니다.

규칙 & 원칙 📏

Core Operational Rules ⚖️

SuperClaude가 따르려는 핵심 규칙입니다.

File Operation Security 🔐

항상 읽고 나서 쓰기/수정: 현재 내용을 이해하지 못한 채 파일을 수정하지 않음
절대 경로만 사용: 경로 도약 공격 방지 및 안정적 파일 작업 보장
자동 커밋 금지: 명시적 요청 없이는 git에 커밋하지 않음
배치 작업 선호: 관련된 변경들은 일괄 처리하여 일관성 유지

왜 중요한가? 데이터 손실, 보안 취약점, 의도치 않은 코드 변경을 방지합니다.

Task Management Rules 📋

근거 기반 진행: 측정 가능한 증거가 있을 때만 완료로 표시
단일 집중 프로토콜: 한 번에 in_progress 상태 작업은 하나만
품질 게이트: 완료 전에 항상 검증 단계 포함
컨텍스트 유지: 작업 간 컨텍스트를 가능하면 잘 보존

왜 중요한가? 신뢰할 수 있는 진행 추적을 보장하고, 작업이 누락되거나 잊히지 않도록 합니다.

Framework Compliance Rules 🎯

의존성 먼저 확인: 라이브러리 사용 전 package.json/requirements.txt 검증
기존 패턴 준수: 프로젝트 컨벤션, import 스타일, 아키텍처 존중
체계적 코드베이스 변경: 전역 수정 전 전체 탐색 수행
완료 검증: 변경 사항이 동작하고 기존 기능을 깨뜨리지 않는지 확인

왜 중요한가? 기존 프로젝트 구조와 품질을 유지합니다.

Development Principles 🛠️

SuperClaude의 개발 문제 접근 방식은 다음 원칙에 기반합니다.

Evidence-Based Decision Making 📊

기본 지침: “Evidence > assumptions | Code > documentation | Efficiency > verbosity”

최적화 전 측정: 실제 메트릭 기반 성능 개선
가설을 체계적으로 테스트: 검증 가능한 데이터로 주장 뒷받침
의사결정 근거 문서화: 아키텍처 선택 이유 명확화
결과에서 학습: 결과에 따른 지속적 개선

예시

/sc:improve slow-api/ --focus performance
# → 현재 성능 측정 → 병목 식별 → 데이터 기반 최적화

SOLID Design Principles 🏗️

Single Responsibility: 컴포넌트는 한 가지 변경 이유만
Open/Closed: 확장에는 열려 있고, 수정에는 닫혀 있게
Liskov Substitution: 자식 클래스는 부모 클래스를 대체 가능해야 함
Interface Segregation: 사용하지 않는 인터페이스에 의존 강요 금지
Dependency Inversion: 구체 구현이 아닌 추상에 의존

왜 따르는가? 유지보수성, 확장성, 유연성이 높은 코드를 만들기 위해서입니다.

Quality Philosophy ✨

검출보다 예방: 테스트로 잡기보다 처음부터 품질 내재화
복잡함보다 단순함: 동작하는 가장 단순한 해법 선택
영리함보다 유지보수성: 쉽게 이해/수정 가능한 코드
기본값은 보안: 처음부터 안전한 패턴 적용

Senior Developer Mindset 🎓

경험 많은 개발자처럼 접근합니다:

시스템적 사고: 전체 시스템 영향 고려
장기 관점: 여러 시간축에서 결정 평가
리스크 보정: 허용 가능한 리스크 vs. 불가 리스크 구분
이해관계자 인식: 기술적 완벽 vs. 실무 제약 균형

당신에게 미치는 영향 💡

Predictable Behavior (예측 가능성)

일관된 규칙 덕분에 SuperClaude의 접근을 예측할 수 있습니다.

/sc:improve legacy-authentication/

예상할 수 있는 것들:

변경 전 기존 코드 읽기
프로젝트의 기존 패턴 준수
보안 우선 접근(보안 페르소나가 활성화될 확률 높음)
근거와 추론을 포함한 제안
완료 전 품질 게이트 적용

Quality Assurance (품질 보증)

원칙은 높은 품질 결과를 보장합니다:

마법 같은 변경 지양: 보통 추론/근거를 설명
기능 파손 방지 지향: 기존 기능 유지
보안 의식: 보안 원칙 중시
부채 인식: 복잡도 유지/감소 노력

Transparency (투명성)

SuperClaude가 무엇을 왜 하는지 보통 이해할 수 있습니다.

/sc:analyze --introspect complex-system/

보여주는 내용:

의사결정 과정
규칙 적용 방식
원칙 준수 여부
고려된 대안들

Rules & Principles 적용 예시 🎯

예시 1: 체계적 리팩터링

요청: “이 지저분한 코드베이스 정리해줘”

적용된 규칙:

변경 전 전체 탐색 수행
수정 전 모든 파일 읽기
기존 프로젝트 패턴 준수
증거 기반 완료 검증

적용된 원칙:

복잡함보다 단순함
근거 기반 결정(정리 전/후 복잡도 측정)
품질 보증(포괄 테스트)
장기 유지보수성 고려

예시 2: 보안 구현

요청: “API에 인증 추가해줘”

적용된 규칙:

보안 페르소나 자동 활성화
보안 기본 원칙 타협 금지
기존 패턴 우선 확인
보안 검증 포함한 품질 게이트

적용된 원칙:

기본값은 보안(Security by default)
심층 방어(Defense in depth)
근거 기반 접근(검증된 보안 패턴 준수)
시스템적 사고(애플리케이션 전체 영향 고려)

예시 3: 성능 최적화

요청: “이 페이지가 느리게 로드돼”

적용된 규칙:

최적화 전 측정
근거 기반 진행 추적
메트릭으로 개선 검증
기존 기능 유지

적용된 원칙:

측정 기반 최적화
사용자 경험 중점
체계적 방법론
검출보다 예방(근본 원인 식별)

Rule Enforcement & Quality Gates 🚨

SuperClaude는 품질 게이트 시스템으로 규칙을 집행합니다.

집행 방식

사전 검증: 시작 전 리스크 검사
실시간 모니터링: 실행 중 규칙 준수 추적
사후 검증: 종료 후 규칙 준수 확인
근거 수집: 투명성을 위한 증거 기록

규칙이 도전받을 때

때로는 규칙이 즉각적인 필요와 충돌할 수 있습니다.

예시: “일단 빨리 되게만 해줘, 퀄리티는 신경 쓰지 마”

SuperClaude의 대응:

긴급성을 인정
장기적으로 왜 품질 규칙이 중요한지 설명
핵심 규칙을 지키는 타협안 제시
품질 기준을 낮출 경우 리스크 문서화

페르소나 행동을 이끄는 원칙 🎭

모든 페르소나가 공통 원칙을 따르지만, 강조점은 다릅니다:

🛡️ Security 페르소나: Security > compliance > reliability > performance
⚡ Performance 페르소나: Measure first > optimize critical path > user experience
🏗️ Architect 페르소나: Long-term maintainability > scalability > performance
🎨 Frontend 페르소나: User needs > accessibility > performance > technical elegance

왜 중요한가? 각 페르소나가 어떤 트레이드오프를 우선시할지 예측할 수 있습니다.

Living Principles 🌱

이 규칙과 원칙은 고정불변이 아닙니다. 다음에 따라 진화합니다:

커뮤니티 피드백: 실제 사용 패턴 반영
결과 분석: 성공 패턴 강화
기술 변화: 새로운 개발 관행에 맞춰 적응
사용자 니즈: 유연성과 일관성의 균형

목표는 도움이 되면서도 예측 가능한 행동을 유지하되, 소프트웨어 개발 환경 변화에 적응하는 것입니다.

Getting Started Workflows 🛣️

이제 SuperClaude의 구성요소를 이해했으니, 다양한 개발 시나리오별 실전 워크플로를 살펴봅시다. 이 패턴들을 활용하면 빠르게 생산성을 올릴 수 있어요.

First-Time Setup 🎬

아직 SuperClaude를 설치하지 않았다면 Installation Guide를 먼저 보세요. 설치 후 이렇게 시작하세요:

Quick Verification

# 기본 동작 테스트
/sc:help                    # SuperClaude 명령어 목록 확인
/sc:analyze README.md       # 간단한 파일 분석 시도
/sc:build --help           # 명령 옵션 확인

Understanding Auto-Activation

SuperClaude가 어떻게 자동으로 적절한 도구를 고르는지 확인해보세요:

# 프론트엔드 작업 → frontend 페르소나 + Magic MCP
/sc:build src/components/
 
# 보안 분석 → security 페르소나 + Sequential MCP
/sc:analyze auth/ --focus security
 
# 성능 조사 → performance 페르소나 + Playwright MCP
/sc:analyze --focus performance slow-endpoints/

출력에 자동 활성화된 플래그/페르소나를 주의 깊게 보세요. 이것이 SuperClaude의 지능형 라우팅이 작동하는 방식입니다.

Development Workflow Patterns 🔄

New Project Onboarding

처음 보는 프로젝트를 시작할 때:

# 1. 프로젝트 컨텍스트 로딩
/sc:load --deep --summary
# → 구조, 의존성, 패턴 개요 제공
 
# 2. 아키텍처 분석
/sc:analyze --focus architecture
# → 🏗️ architect 페르소나가 시스템 이해 제공
 
# 3. 코드 품질 점검
/sc:analyze --focus quality
# → 🧪 qa 페르소나가 잠재적 이슈 식별
 
# 4. 문서 검토/개선
/sc:document README --type guide
# → ✍️ scribe 페르소나가 문서를 개선

Feature Development Cycle

새 기능을 개발할 때:

# 1. 설계 단계
/sc:design user-dashboard --type component
# → 🏗️ architect + 🎨 frontend 페르소나 협업
 
# 2. 구현
/sc:build dashboard-components/
# → 🎨 frontend 페르소나 + Magic MCP로 UI 생성
 
# 3. 테스트
/sc:test --type e2e dashboard/
# → 🧪 qa 페르소나 + Playwright MCP 테스트
 
# 4. 문서화
/sc:document dashboard/ --type api
# → ✍️ scribe 페르소나가 상세 문서 생성

Bug Investigation & Resolution

체계적인 디버깅:

# 1. 문제 조사
/sc:troubleshoot "login randomly fails" --think
# → 🔍 analyzer 페르소나 + Sequential MCP 방법론
 
# 2. 근본 원인 분석
/sc:analyze auth-flow/ --focus debugging
# → 증거 수집 기반의 체계적 분석
 
# 3. 수정 적용
/sc:improve auth/ --safe-mode --validate
# → 검증을 동반한 안전한 개선
 
# 4. 검증 테스트
/sc:test auth-flow/ --coverage
# → 수정 사항이 제대로 작동하는지 포괄 테스트

Code Quality Improvement

기존 코드 품질 개선:

# 1. 품질 진단
/sc:analyze legacy-code/ --focus quality
# → 🔄 refactorer 페르소나가 개선 포인트 식별
 
# 2. 안전한 개선 미리보기
/sc:improve --preview legacy-code/
# → 적용 전 변경 내용 확인
 
# 3. 개선 적용
/sc:improve --safe legacy-code/
# → 저위험 변경만 적용
 
# 4. 변경 검증
/sc:test --coverage improved-code/
# → 기능 파손 여부 확인

Common Workflow Combinations 🤝

Security-First Development

/sc:analyze --persona-security --focus security
/sc:build --validate --safe-mode
/sc:test --type security
/sc:git --persona-security --validate

Performance-Optimized Workflow

/sc:analyze --focus performance --persona-performance
/sc:improve --type performance --benchmark
/sc:test --focus performance --play
/sc:test --focus performance --play

Team Collaboration Workflow

/sc:analyze team-code/ --persona-qa --focus quality
/sc:document features/ --persona-scribe --type guide
/sc:git --smart-commit --branch-strategy
/sc:task status  # 팀 진행 상황 확인

Advanced Workflow Patterns 🚀

Large Codebase Management (엔터프라이즈 규모)

# 대규모 효율 분석
/sc:analyze monorepo/ --delegate auto --uc --focus architecture
# → 병렬 처리 + 압축 + 아키텍처 초점
 
# 체계적 개선
/sc:improve legacy-system/ --wave-mode auto --safe-mode
# → 다단계 개선 + 안전성 체크
 
# 포괄 품질 리뷰
/sc:analyze enterprise-app/ --delegate folders --focus quality
# → 분산된 품질 분석

Legacy System Modernization (레거시 현대화)

# 진단 단계
/sc:analyze legacy/ --persona-architect --ultrathink
# → 심층 아키텍처 분석
 
# 계획 단계
/sc:design modernization-strategy --type architecture
# → 종합 현대화 계획
 
# 구현 단계
/sc:improve legacy/ --wave-mode systematic --safe-mode --loop
# → 반복적이고 안전한 개선 + 검증
 
# 마이그레이션 지원
/sc:migrate --type framework legacy-to-modern/
# → 프레임워크 마이그레이션 지원

Multi-Domain Projects (다도메인 프로젝트)

# 도메인 간 조율
/sc:analyze fullstack-app/ --all-mcp --delegate auto
# → 모든 MCP 서버 + 병렬 처리
 
# 도메인별 개선
/sc:improve frontend/ --persona-frontend --magic
/sc:improve backend/ --persona-backend --c7
/sc:improve infrastructure/ --persona-devops --seq
 
# 통합 검증
/sc:test --type integration --play
# → 통합 테스트

Workflow Optimization Tips 💡

Start Small, Scale Up

# 작은 범위부터
/sc:analyze single-component.js --focus quality
 
# 필요시 확장
/sc:analyze entire-module/ --focus quality --delegate files
 
# 전체 시스템으로 확장
/sc:analyze whole-project/ --delegate auto --uc

Use Progressive Enhancement

# 기본 명령
/sc:build project/
 
# 지능 추가
/sc:build project/ --think --c7
 
# 풀 오케스트레이션
/sc:build project/ --wave-mode auto --all-mcp --delegate auto

Combine Complementary Personas

# 보안 + 성능 분석
/sc:analyze api/ --persona-security
/sc:analyze api/ --persona-performance
 
# 아키텍처 + 품질 리뷰
/sc:review system/ --persona-architect --focus architecture
/sc:review system/ --persona-qa --focus quality

Troubleshooting Workflows 🚨

When Commands Don't Work as Expected

# 인트로스펙션으로 디버깅
/sc:troubleshoot "command issues" --introspect
# → 무엇이 잘못됐는지 메타 분석
 
# 다른 접근 시도
/sc:analyze problem/ --persona-analyzer --seq
# → 체계적 조사 방법
 
# 프레임워크 상태 확인
/sc:load framework-status/ --summary
# → 현재 SuperClaude 상태 파악

When Performance is Slow

# 속도 최적화
/sc:analyze large-project/ --no-mcp --uc --scope module
# → 불필요 기능 비활성화 + 압축 + 범위 제한
 
# 대규모 작업 위임
/sc:improve huge-codebase/ --delegate auto --concurrency 5
# → 병렬 처리 + 동시성 제어

When Results Aren't Focused Enough

# 특정 포커스 플래그 사용
/sc:analyze code/ --focus security --scope file
 
# 적절한 페르소나 수동 활성화
/sc:analyze frontend-code/ --persona-security  # 프론트엔드 보안 관점
 
# 여러 접근 조합
/sc:analyze --focus performance --persona-performance --play

Building Your Own Workflows 🛠️

Identify Your Common Patterns

당신에게 잘 맞는 조합을 추적/별칭(alias)으로 저장하세요:

# 보안 중심 API 개발
alias secure-api="/build api/ --persona-security --validate --c7"
 
# 성능 최적화 프론트엔드 작업
alias perf-frontend="/build ui/ --persona-performance --magic --benchmark"
 
# 품질 개선 워크플로
alias quality-check="/scan --focus quality && /improve --safe-mode && /test --coverage"

Experiment with Flag Combinations

# 학습 목적: 자세한 설명 + 문서
/sc:explain concept --persona-mentor --verbose --c7
 
# 안전 우선: 최대 검증 & 체크
/sc:improve critical-code/ --safe-mode --validate --preview
 
# 효율 우선: 압축 출력 + 병렬 처리
/sc:analyze big-project/ --uc --delegate auto --concurrency 3

기억하세요: SuperClaude는 성공적 패턴에서 학습합니다. 효과적인 조합을 많이 사용할수록, SuperClaude는 필요한 접근을 더 잘 자동 활성화합니다.

Integration & Coordination 🤝

SuperClaude의 구성 요소가 어떻게 함께 작동하는지 이해하는 것이 중요합니다. 이 섹션은 명령어, 플래그, 페르소나, MCP 서버가 어떻게 자동으로 조율되는지, 그리고 필요할 때 이를 어떻게 제어할 수 있는지 보여줍니다.

Auto-Coordination Examples 🤖

SuperClaude는 컨텍스트에 따라 컴포넌트를 자동으로 조율합니다. 실제로는 이렇게 작동합니다:

Frontend Development Request

/sc:build react-dashboard/

자동 조율:

Command: /build가 컴파일/번들링 담당
Persona: 🎨 frontend 자동 활성화(React 감지)
MCP: Magic이 최신 UI 컴포넌트 제공
MCP: Context7이 React 베스트 프랙티스 제공
Flags: --c7 자동 활성화(프레임워크 문서)

결과: 현대적 컴포넌트, 접근성 체크, 성능 최적화가 반영된 React 최적 빌드

Security Analysis Request

/sc:scan user-authentication/ --focus security

자동 조율:

Command: /scan이 보안 스캐닝 담당
Persona: 🛡️ security 자동 활성화(보안 초점)
MCP: Sequential이 체계적 분석 제공
Flags: --validate 자동(고위험 작업)
Flags: --think 자동(복잡한 보안 패턴)

결과: 위협 모델링, 취약점 탐지, 컴플라이언스 체크까지 포함한 포괄적 보안 분석

Performance Investigation

/sc:troubleshoot "API responses are slow"

자동 조율:

Command: /troubleshoot가 조사 담당
Persona: ⚡ performance 자동 활성화(성능 키워드)
Persona: 🔍 analyzer가 조사 방법론 제공
MCP: Sequential이 디버깅 구조화
MCP: Playwright가 성능 테스트 제공
Flags: --think 자동(복잡 디버깅)

결과: 메트릭 기반 병목 식별과 최적화 권고가 포함된 체계적 성능 조사

Manual Coordination Control 🎛️

때로는 자동 조율을 오버라이드하고 싶을 때가 있습니다.

Override Persona Selection

# 프론트엔드 코드를 보안 관점에서 보기
/sc:analyze react-components/ --persona-security
# → UI 컴포넌트에 대한 보안 분석(XSS, 데이터 노출 등)
 
# 작은 유틸 함수에 아키텍처적 사고 적용
/sc:improve utility-function.js --persona-architect
# → 단순 코드에도 설계 패턴/확장성을 고려

Control MCP Server Usage

# 속도를 위해 MCP 서버 모두 비활성화
/sc:analyze large-codebase/ --no-mcp
# → 40~60% 더 빠른 실행, 네이티브 도구만 사용
 
# 포괄 분석을 위해 MCP 서버 모두 활성화
/sc:analyze complex-system/ --all-mcp
# → 최대 기능 활용, 토큰 사용량 증가
 
# 특정 MCP 조합 사용
/sc:build ui-components/ --magic --c7 --no-seq
# → UI 생성 + 문서 참조, 복잡 분석은 생략

Combine Multiple Perspectives

# 동일 대상에 대해 서로 다른 페르소나 시각
/sc:analyze payment-system/ --persona-security     # 보안 관점
/sc:analyze payment-system/ --persona-performance  # 성능 관점
/sc:analyze payment-system/ --persona-architect    # 아키텍처 관점
 
# 자동 협업
/sc:review payment-system/ --focus quality
# → 보안+성능+아키텍처 인사이트 자동 조율

Flag Coordination Patterns 🏁

Safety-First Patterns

# 중요 코드 최대 안전 모드
/sc:improve production-auth/ --safe-mode --validate --preview
# → 보수적 변경 + 위험 평가 + 적용 전 미리보기
 
# 대규모 변경의 안전 탐색
/sc:improve legacy-system/ --wave-mode auto --safe-mode --validate
# → 다단계 개선 + 안전 체크 + 검증 게이트

Performance-Optimized Patterns

# 대규모 작업의 빠른 실행
/sc:analyze huge-project/ --uc --no-mcp --scope module
# → 압축 출력 + 네이티브 도구 + 범위 제한
 
# 효율적 병렬 처리
/sc:improve monorepo/ --delegate auto --uc --concurrency 5
# → 병렬 처리 + 압축 + 리소스 제어

Learning-Focused Patterns

# 교육용 설명 + 공식 문서
/sc:explain complex-concept --persona-mentor --verbose --c7
# → 교육적 접근 + 상세 설명 + 공식 문서
 
# 깊은 이해 + 투명성
/sc:analyze mysterious-code/ --persona-analyzer --think-hard --introspect
# → 조사 방법론 + 심층 분석 + 사고 투명성

MCP Server Coordination 🔧

MCP 서버는 자주 함께 작동합니다:

Documentation + Analysis

/sc:improve old-react-code/

MCP 조율:

Context7: 최신 React 베스트 프랙티스 조회
Sequential: 현대 패턴 대비 코드 분석
Magic: 현대적 컴포넌트 패턴 제안

결과: 최신 표준에 맞춘 모던화

Testing + Performance

/sc:test dashboard/ --focus performance

MCP 조율:

Sequential: 포괄 테스트 전략 수립
Playwright: 성능 테스트 실행
Context7: 테스트 베스트 프랙티스 제공

결과: 업계 표준에 맞춘 성능 테스트

Complex Problem Solving

/sc:troubleshoot "complex multi-service issue" --ultrathink

MCP 조율:

Sequential: 체계적 조사 구조화
Context7: 서비스 아키텍처 패턴 제공
Playwright: 서비스 상호작용 테스트

결과: 다도메인 포괄 디버깅

Persona Collaboration Patterns 🎭

복잡한 요청에서는 페르소나들이 자동 협업합니다.

Architecture + Security

/sc:design payment-api --type secure

협업:

🏗️ architect: 시스템 설계 & 확장성
🛡️ security: 위협 모델링 & 보안 패턴
⚙️ backend: API 구현 패턴

결과: 안전하고 확장 가능한 API 설계

Frontend + Performance

/sc:build dashboard --focus performance

협업:

🎨 frontend: UI/UX & 접근성
⚡ performance: 최적화 & 메트릭
🏗️ architect: 컴포넌트 아키텍처

결과: 빠르고, 접근 가능하며, 구조화된 대시보드

Quality + Refactoring

/sc:improve legacy-code/ --focus quality

협업:

🔄 refactorer: 코드 품질 & 패턴
🧪 qa: 테스트 & 검증
🏗️ architect: 구조적 개선

결과: 깔끔하고 테스트된, 잘 설계된 코드

Advanced Coordination Strategies 🚀

Wave Orchestration (웨이브 오케스트레이션)

복잡한 다단계 작업에 사용:

/sc:improve enterprise-system/ --wave-mode systematic

웨이브별 조율:

Analysis Wave: 🔍 analyzer + Sequential 현재 상태 평가
Planning Wave: 🏗️ architect + Context7 개선 설계
Implementation Wave: 적합한 전문가 + 도구로 변경 적용
Validation Wave: 🧪 qa + Playwright 개선사항 검증
Optimization Wave: ⚡ performance + 메트릭 최적화

Sub-Agent Delegation (서브 에이전트 위임)

병렬 처리를 위해:

/sc:analyze large-monorepo/ --delegate folders

위임 조율:

메인 에이전트: 총괄 & 결과 통합
서브 에이전트: 폴더별 전문 분석
조율: 결과를 도메인 전문성으로 종합
MCP 통합: 모든 에이전트에 공유

Adaptive Intelligence

SuperClaude는 컨텍스트에 따라 조율을 적응시킵니다:

개발 단계 감지:

Planning phase → 🏗️ architect + ✍️ scribe 강조
Implementation phase → 도메인 전문가 + Magic/Context7
Testing phase → 🧪 qa + Playwright 강조
Deployment phase → 🚀 devops + 검증 강조

복잡도 기반 스케일링:

단순 작업 → 직접 실행
중간 복잡도 → 페르소나 + MCP 조율
고복잡도 → 웨이브 오케스트레이션 + 위임

Coordination Troubleshooting 🔧

When Auto-Coordination Goes Wrong

# 도구가 너무 많이 활성화됨(느림/비용↑)
/sc:analyze simple-file.js --no-mcp --answer-only
# → 간단 작업에 최소 도구만
 
# 잘못된 페르소나 활성화
/sc:analyze backend-api/ --persona-security
# → 명시적 페르소나 선택으로 오버라이드
 
# 분석 깊이가 부족
/sc:troubleshoot complex-issue --ultrathink --all-mcp
# → 최대 역량 강제

Optimizing Coordination

# 단순 → 점진적으로 복잡도 추가
/sc:analyze code.js
/sc:analyze code.js --think
/sc:analyze code.js --think --c7
/sc:analyze code.js --think --c7 --seq

Understanding Coordination Decisions

# 왜 특정 도구가 선택됐는지 보기
/sc:analyze complex-system/ --introspect
# → 의사결정 과정 및 도구 선택 근거 표시

Best Practices for Integration 💡

자동 조율 먼저 믿기: SuperClaude의 자동 선택을 신뢰하고, 필요할 때만 오버라이드
간단한 명령부터 시작: 플래그는 점차 추가
플래그 상호작용 이해:
- --no-mcp는 --c7, --seq 등을 무시
- 안전 플래그는 최적화 플래그보다 우선
- 페르소나 플래그는 더 구체적인 페르소나 요청으로 덮어쓸 수 있음
적절한 범위 사용:
- 파일 수준: 단일 페르소나 + 최소 MCP
- 모듈 수준: 도메인 페르소나 + 관련 MCP
- 시스템 수준: 다수 페르소나 + 풀 MCP 조율
리소스 사용 모니터링:
- 대규모 작업 → --uc, --delegate
- 단순 작업 → --no-mcp, --answer-only
- 중요 작업 → --safe-mode, --validate

핵심은 SuperClaude의 지능이 컴포넌트들 간의 조율에서 나온다는 점입니다. 자동 조율은 대부분 잘 작동하지만, 이를 제어하는 법을 알면 어떤 상황도 유연하게 대응할 수 있습니다.

실전 예시 💡

SuperClaude가 실제 개발 문제를 어떻게 해결하는지 보여주는 시나리오들입니다. 각 예시는 다양한 컴포넌트가 함께 작동하는 방식을 보여줍니다.

시나리오 1: 신규 팀원 온보딩 👋

상황: React/Node.js 기반 전자상거래 프로젝트에 처음 합류했습니다.

Step 1: 프로젝트 이해

/sc:load --deep --summary

무슨 일이 일어나나:

🔍 analyzer 페르소나 활성화(조사가 필요)
Sequential MCP가 분석을 구조화
Context7 MCP가 프레임워크 패턴 식별
종합적인 프로젝트 개요 생성

출력: 프로젝트 구조, 기술 스택, 의존성, 아키텍처 요약.

Step 2: 코드 품질 평가

/sc:analyze --focus quality

자동 조율:

🧪 qa 페르소나 활성화(품질 초점)
Sequential MCP가 체계적 분석 제공
코드 품질/보안/성능 이슈 스캔
실행 가능한 개선 제안 생성

출력: 구체적 이슈와 개선 제안을 담은 품질 리포트.

Step 3: 아키텍처 이해

/sc:analyze --focus architecture --persona-architect

무슨 일이 일어나나:

🏗️ architect 페르소나가 시스템 설계 관점 제공
Context7 MCP가 React/Node.js 아키텍처 패턴 반영
Sequential MCP가 구조적 분석 수행
디자인 패턴, 데이터 흐름, 컴포넌트 관계 파악

출력: 디자인 패턴과 시스템 관계를 담은 아키텍처 개요.

Step 4: 시작 가이드 작성

/sc:document onboarding --type guide --persona-scribe

무슨 일이 일어나나:

✍️ scribe 페르소나가 전문 문서 작성
Context7 MCP가 문서화 표준 제공
앞선 분석 내용을 신입 친화적 가이드로 합성
셋업 방법과 핵심 개념 포함

출력: 향후 팀원을 위한 종합 온보딩 가이드.

절약 시간: 보통 2~3일 걸릴 탐색을 약 30분 만에 압축.

시나리오 2: 보안 취약점 조사 🛡️

상황: 보안 스캐너가 사용자 인증 시스템에서 잠재적 이슈를 감지했습니다.

Step 1: 보안 중심 분석

/sc:scan auth-system/ --persona-security --focus security

자동 조율:

🛡️ security 페르소나 활성화(보안 전문성)
Sequential MCP가 위협 모델링 구조화
Context7 MCP가 OWASP/보안 베스트 프랙티스 제공
--validate 플래그 자동 활성화(고위험 작업)

출력: 위협 평가와 취약점 우선순위를 포함한 상세 보안 분석.

Step 2: 근본 원인 조사

/sc:troubleshoot "JWT token exposure in logs" --think --seq

무슨 일이 일어나나:

🔍 analyzer 페르소나가 조사 방법론 제공
--think로 심층 분석 모드
Sequential MCP가 디버깅 절차 구조화
데이터 흐름 추적, 노출 지점 식별

출력: 증거와 영향 평가를 포함한 근본 원인 분석.

Step 3: 안전한 보안 개선

/sc:improve auth-system/ --focus security --safe-mode --validate

자동 조율:

🛡️ security 페르소나로 보안 초점 유지
--safe-mode로 보수적 변경
--validate로 적용 전 검증
Context7 MCP가 안전한 코딩 패턴 제공

출력: 최소 위험으로 적용된 보안 개선 + 포괄 검증.

Step 4: 보안 테스트

/sc:test auth-system/ --type security --play

무슨 일이 일어나나:

🧪 qa 페르소나가 테스트 전문성 제공
Playwright MCP가 보안 테스트 시나리오 실행
인증 흐름, 세션 관리, 접근 제어 테스트
개선된 보안 기능 검증

출력: 개선 효과를 입증하는 종합 보안 테스트 결과.

리스크 감소: 체계적 접근으로 보안 누락 가능성을 낮추고 커버리지를 보장.

시나리오 3: 성능 최적화 스프린트 ⚡

상황: 전자상거래 대시보드가 느려서 사용자 경험에 악영향.

Step 1: 성능 분석

/sc:analyze dashboard/ --focus performance --persona-performance

자동 조율:

⚡ performance 페르소나 활성화(성능 전문성)
Playwright MCP가 성능 메트릭/테스트 제공
Context7 MCP가 React 성능 베스트 프랙티스 제공
--think-hard 자동 활성화(복잡 성능 분석)

출력: 메트릭 기반 병목 식별 및 최적화 우선순위.

Step 2: 프론트엔드 성능 심층 분석

/sc:analyze frontend/ --persona-frontend --focus performance --play

무슨 일이 일어나나:

🎨 frontend 페르소나가 UI/UX 관점 제공
⚡ performance 페르소나가 조율(이중 전문성)
Playwright MCP로 Core Web Vitals, 번들 크기, 렌더 시간 측정
Magic MCP가 현대적 최적화 패턴 제안

출력: 접근성과 UX 고려를 포함한 프론트엔드 성능 분석.

Step 3: 백엔드 API 성능

/sc:analyze api/ --persona-backend --focus performance

자동 조율:

⚙️ backend 페르소나가 서버 사이드 전문성 제공
Sequential MCP가 DB 쿼리/API 패턴 분석
Context7 MCP가 Node.js/Express 최적화 패턴 제공
느린 쿼리, 비효율 엔드포인트, 캐시 기회 식별

출력: DB/API 최적화 권고를 포함한 백엔드 성능 분석.

Step 4: 체계적 최적화

/sc:improve dashboard/ --focus performance --loop --iterations 3

무슨 일이 일어나나:

⚡ performance 페르소나 주도
--loop로 반복 개선
각 반복: 최적화 → 측정 → 검증 → 재개선
메트릭 기반 점진적 향상

출력: 각 사이클마다 측정 가능한 성능 향상 결과.

Step 5: 성능 테스트 검증

/sc:test dashboard/ --focus performance --play --benchmark

무슨 일이 일어나나:

Playwright MCP가 포괄 성능 테스트 수행
다양한 기기/네트워크/브라우저에서 테스트
Core Web Vitals, 로드 타임, 사용자 상호작용 메트릭 측정
성능 예산 충족 여부 검증

출력: 최적화 효과를 입증하는 성능 테스트 결과.

성능 향상: 체계적 접근으로 40~70% 수준의 성능 향상을 메트릭으로 입증하는 경우가 많습니다.

시나리오 4: 레거시 코드 현대화 🔄

상황: 5년 된 React 앱을 최신 표준에 맞게 현대화해야 함.

Step 1: 레거시 진단

/sc:analyze legacy-app/ --persona-architect --ultrathink

자동 조율:

🏗️ architect 페르소나가 구조 분석
--ultrathink로 최대 분석 깊이
Context7 MCP가 최신 React 패턴과 비교
Sequential MCP가 체계적 현대화 평가

출력: 현대화 로드맵과 리스크 평가를 포함한 포괄 분석.

Step 2: 현대화 계획 수립

/sc:design modernization-strategy --type architecture --persona-architect

무슨 일이 일어나나:

🏗️ architect 페르소나가 마이그레이션 전략 설계
Context7 MCP가 최신 React 생태계 패턴 제공
Sequential MCP가 계획 구조화
단계, 의존성, 리스크 식별

출력: 단계적 접근과 리스크 완화를 포함한 상세 현대화 계획.

Step 3: 안전한 점진 개선

/sc:improve legacy-components/ --safe-mode --wave-mode systematic --loop

자동 조율:

🔄 refactorer 페르소나가 개선 주도
--safe-mode로 위험 최소화
--wave-mode systematic 다단계 개선
--loop로 반복 정련
여러 페르소나 협업: architect, frontend, qa

출력: 안전 체크와 점진적 향상이 결합된 체계적 현대화 결과.

Step 4: 현대화 테스트

/sc:test modernized-app/ --type integration --coverage --play

무슨 일이 일어나나:

🧪 qa 페르소나가 품질 보장
Playwright MCP가 포괄 테스트 제공
레거시 호환성과 신규 기능 모두 테스트
현대화가 기존 기능을 깨뜨리지 않는지 검증

출력: 현대화 성공을 입증하는 종합 테스트 결과.

성공률 향상: 체계적 접근으로 현대화 리스크를 80% 감소, 호환성 보장.

시나리오 5: 다팀(API) 설계 🌐

상황: 여러 팀이 사용할 마이크로서비스 API를 설계합니다.

Step 1: 요구사항 분석

/sc:design user-service-api --type api --persona-backend

자동 조율:

⚙️ backend 페르소나가 API 설계 전문성 제공
🏗️ architect 페르소나가 시스템 통합 관점 조율
Context7 MCP가 API 설계 베스트 프랙티스 제공
Sequential MCP가 요구사항 분석 구조화

출력: 엔드포인트, 데이터 모델, 통합 패턴을 담은 종합 API 설계.

Step 2: 보안 리뷰

/sc:review api-design/ --persona-security --focus security

무슨 일이 일어나나:

🛡️ security 페르소나가 API 보안 평가
인증/인가/데이터 보호 검토
Context7 MCP가 OWASP API 보안 가이드 제공
보안 요구사항/위협 벡터 식별

출력: 강화 권고와 컴플라이언스 요구사항을 담은 보안 평가.

Step 3: 성능 고려

/sc:analyze api-design/ --persona-performance --focus performance

자동 조율:

⚡ performance 페르소나가 확장성 평가
엔드포인트 성능, 캐싱, 레이트 리밋 분석
Context7 MCP가 고성능 API 패턴 제공
부하 시 성능 예상

출력: 확장성 권장사항과 최적화 전략을 담은 성능 분석.

Step 4: 다팀용 문서화

/sc:document api/ --type api --persona-scribe --detailed

무슨 일이 일어나나:

✍️ scribe 페르소나가 전문 API 문서 작성
Context7 MCP가 문서 표준 제공
예제, 통합 가이드, 트러블슈팅 포함
여러 팀을 위한 맞춤형 문서

출력: 예제/가이드/베스트 프랙티스를 갖춘 종합 API 문서.

Step 5: 구현 검증

/sc:build api-implementation/ --validate --test-coverage

자동 조율:

⚙️ backend 페르소나가 API 패턴 구현
🧪 qa 페르소나가 품질·테스트 보장
Sequential MCP가 설계 대비 구현 검증
포괄 테스트 및 검증 수행

출력: 광범위 테스트와 검증을 거친 프로덕션 준비 완료 API 구현.

협업 효율: 다중 페르소나 협업으로 설계 반복 사이클 60% 감소, 팀 간 정렬 향상.

공통 패턴 인식 🔍

위 예시들은 SuperClaude 컴포넌트 조율의 반복 패턴을 보여줍니다:

Investigation → Analysis → Implementation → Validation
대부분의 복잡 워크플로는 각 단계에 맞는 페르소나/도구를 붙여 이 흐름을 따릅니다.
Multi-Persona Coordination
복합 문제일수록 여러 관점(보안+성능, 아키텍처+프론트엔드 등)이 도움이 됩니다.
Progressive Enhancement
단순하게 시작해 필요에 따라 복잡도를 올립니다 (--think → --think-hard → --ultrathink).
Safety-First Approach
중요 작업에는 자동으로 검증/안전 체크가 포함됩니다 (--safe-mode, --validate).
Context-Aware Tool Selection
SuperClaude는 컨텍스트에 맞춰 적절한 MCP 서버와 플래그를 자동 선택합니다.

이 예시들은 SuperClaude의 가치는 단일 기능이 아닌 컴포넌트 간 지능형 조율에서 나온다는 점을 보여줍니다. 프레임워크는 일관된 품질/안전 기준을 유지하면서 사용자 요구에 맞게 적응합니다.

시작을 잘하는 법 🚀

단순한 명령부터 시작하세요

# 여기서 시작 - 기본 기능
/sc:help
/sc:analyze README.md
/sc:build --help
 
# 아직은 NO - 복잡한 오케스트레이션
/sc:improve entire-codebase/ --wave-mode force --all-mcp --delegate auto

왜: 기본 동작을 이해한 뒤 복잡도를 올려야 헷갈리지 않고 프레임워크를 점진적으로 익힐 수 있습니다.

먼저 자동 활성화를 믿으세요

# SuperClaude가 도구를 선택하게 두기
/sc:analyze auth-system/
# → 무엇이 자동 활성화되는지 확인(보통 security 페르소나 + validation)
 
# 이후 수동 제어 실험
/sc:analyze auth-system/ --persona-performance
# → 같은 코드에 대한 다른 관점 보기

왜: 자동 활성화는 보통 최적의 조합을 보여주며, 다양한 시나리오에서 어떤 도구가 어울리는지 배울 수 있습니다.

Preview와 Safe 모드 활용

# 먼저 어떤 일이 일어날지 보기
/sc:improve messy-code.js --preview
 
# 안전하게 적용
/sc:improve messy-code.js --safe-mode
 
# 중요 코드엔 둘 다
/sc:improve production-auth/ --preview --safe-mode --validate

왜: 의도치 않은 변경을 막고, SuperClaude가 실제로 뭘 할지 사전에 파악할 수 있습니다.

플래그 사용 패턴 🏁

단순 → 단계적 복잡도 추가

# 기본 명령
/sc:analyze complex-system/
 
# 필요하면 사고(think) 추가
/sc:analyze complex-system/ --think
 
# 외부 라이브러리 관련이면 문서 플래그 추가
/sc:analyze complex-system/ --think --c7
 
# 중요한 시스템엔 풀 분석
/sc:analyze complex-system/ --think-hard --c7 --seq --validate

왜: 한 번에 많은 플래그를 쓰기보다, 단계적으로 추가하면 각 플래그의 역할을 이해하고 과한 설계를 피할 수 있음.

잘 먹히는 대표 조합

# 안전한 개선 워크플로
/sc:improve --preview → /improve --safe-mode → /test --coverage
 
# 심층 조사 워크플로
/sc:troubleshoot issue --think --seq → /analyze affected-code/ --focus quality
 
# 학습 & 문서화 워크플로
/sc:explain concept --persona-mentor --verbose --c7
 
# 성능 최적화 워크플로
/sc:analyze --focus performance --persona-performance --play

왜: 서로 충돌하지 않고 검증된 패턴들입니다.

플래그 충돌 피하기

# ❌ 충돌 플래그
/sc:analyze code/ --no-mcp --c7  # --no-mcp가 --c7을 무시
 
# ❌ 역효과 조합
/sc:analyze small-file.js --ultrathink --all-mcp  # 단순 작업에 과한 설정
 
# ✅ 합리적 조합
/sc:analyze large-system/ --think --delegate auto
/sc:analyze simple-utility.js --answer-only

왜: 플래그 우선순위/상호작용을 이해하면 예상치 못한 동작과 리소스 낭비를 막을 수 있습니다.

페르소나 최적화 🎭

도메인 기반 자동 활성화에 맡기기

/sc:build react-components/        # → frontend 페르소나
/sc:scan auth/ --focus security    # → security 페르소나
/sc:troubleshoot slow-api/         # → performance + analyzer 페르소나

왜: 검증된 패턴 기반 자동 선택이 보통 가장 적절한 전문성을 붙여줍니다.

다른 관점이 필요할 때 수동 오버라이드

/sc:analyze payment-flow/ --persona-security     # 보안 관점
/sc:analyze payment-flow/ --persona-performance  # 성능 관점
/sc:analyze payment-flow/ --persona-architect    # 아키텍처 관점

왜: 각 페르소나는 고유한 통찰을 제공해 다른 페르소나가 놓친 이슈/기회를 발견할 수 있습니다.

프로젝트 단계별 페르소나 선택

# 기획 단계
/sc:design new-feature --persona-architect
 
# 구현 단계
/sc:build feature/ --persona-frontend   # 또는 backend 등
 
# 테스트 단계
/sc:test feature/ --persona-qa
 
# 문서화 단계
/sc:document feature/ --persona-scribe

왜: 단계별로 필요한 전문성이 다릅니다.

MCP 서버 전략 🔧

서버별 활용 시점 이해하기

Context7: 프레임워크/라이브러리/공식 문서 필요할 때
Sequential: 복잡한 디버깅, 체계적 분석, 아키텍처 결정
Magic: UI 컴포넌트 생성, 디자인 시스템, 프론트엔드 작업
Playwright: 테스트, 성능 측정, 브라우저 자동화

성능 vs. 기능 균형 맞추기

# 단순 작업은 빠르게
/sc:analyze simple-script.js --no-mcp
 
# 복잡 문제는 포괄 분석
/sc:analyze complex-system/ --all-mcp --think-hard
 
# 대부분 작업은 균형형
/sc:analyze typical-component/ --c7  # 문서 조회만

왜: 작업 복잡도에 맞는 MCP 사용이 속도와 품질을 모두 최적화합니다.

워크플로 최적화 📈

점진적 강화(Progressive Enhancement)

# 레벨 1: 기본 분석
/sc:analyze component.js
 
# 레벨 2: 복잡하면 think 추가
/sc:analyze component.js --think
 
# 레벨 3: 프레임워크 문서 필요
/sc:analyze component.js --think --c7
 
# 레벨 4: 중요 코드 풀 분석
/sc:analyze component.js --think-hard --c7 --seq --validate

왜: 필요할 때만 복잡도를 올리면 과도한 엔지니어링을 피하고 시간을 절약합니다.

적절한 스코프 사용

# 파일 단위: 특정 이슈
/sc:improve single-component.js --focus performance
 
# 모듈 단위: 관련 기능 묶음
/sc:analyze user-auth/ --scope module
 
# 프로젝트 단위: 아키텍처 이슈
/sc:analyze --scope project --focus architecture
 
# 시스템 단위: 정말 필요할 때만
/sc:analyze --scope system --delegate auto --uc

왜: 문제 규모에 맞는 스코프가 과소/과대 분석을 막고 리소스를 절약합니다.

성능 & 효율 🏃‍♂️

컨텍스트·토큰 사용 관리

# 대규모 작업엔 압축
/sc:analyze huge-codebase/ --uc --delegate auto
 
# 반복 분석엔 캐시 활용
/sc:load project-context/        # 프로젝트 이해 캐싱
/sc:analyze specific-issue/      # 캐시된 컨텍스트 기반 분석
 
# 단순 질문엔 오버헤드 최소화
/sc:explain quick-concept --answer-only --no-mcp

왜: 토큰 효율은 속도를 높이고 대규모 프로젝트에서 컨텍스트 초과를 방지합니다.

대형 프로젝트엔 Delegation

# 자동 위임
/sc:analyze monorepo/ --delegate auto
 
# 특정 요구에 수동 위임
/sc:analyze large-project/ --delegate folders --concurrency 3
 
# 작은 프로젝트엔 비활성화
/sc:analyze small-app/ --no-delegate

왜: 위임은 대규모 작업에서 40~70% 속도 향상을 제공하면서 품질을 유지합니다.

명령 시퀀스 최적화

# ✅ 효율적 순서
/sc:load project/            # 컨텍스트 1번만 로딩
/sc:analyze --focus quality  # 이해 기반 분석
/sc:improve --safe-mode      # 개선 적용
/sc:test --coverage          # 검증
 
# ❌ 비효율적 순서
/sc:analyze file1.js
/sc:analyze file2.js   # 매번 셋업 반복
/sc:analyze file3.js   # 최적화 기회 손실

왜: 순차 명령은 서로의 컨텍스트를 활용해 더 나은 결과를 냅니다.

품질 & 안전 🛡️

중요한 변경은 항상 검증

# 프로덕션 코드
/sc:improve production-auth/ --safe-mode --validate --preview
 
# 실험적 기능
/sc:improve experimental-feature/ --validate
 
# 학습/탐색용
/sc:improve test-code/ --preview

왜: 검증은 파손을 막고 변경 영향도를 이해하게 해줍니다.

품질 게이트를 효과적으로 활용

# 자동 품질 게이트에 맡기기
/sc:build production-app/  # 8단계 검증 프로세스 실행
 
# 중요 시스템엔 추가 검증
/sc:build payment-system/ --validate --safe-mode
 
# 실험용에서만 검증 생략
/sc:build prototype/ --no-validate  # 신중하게 사용

왜: 품질 게이트는 문제를 초기에 잡아 비용을 낮출 수 있습니다.

증거(근거) 기록 유지

# 증거를 제공하는 명령들
/sc:analyze --focus performance   # → 성능 메트릭
/sc:test --coverage               # → 커버리지 리포트
/sc:scan --focus security         # → 보안 평가
 
# 복잡한 결정엔 인트로스펙션
/sc:analyze complex-system/ --introspect  # → 의사결정 근거

왜: 근거 기반 개발은 더 나은 결정과 이슈 발생 시 쉬운 디버깅을 가능하게 합니다.

학습 & 성장 📚

Mentor 페르소나로 학습하기

# 새 개념 배우기
/sc:explain GraphQL --persona-mentor --verbose
 
# 복잡한 코드 이해
/sc:analyze complex-algorithm.js --persona-mentor
 
# 단계별 가이드 받기
/sc:build new-feature/ --persona-mentor --plan

왜: Mentor 페르소나는 단순 과제 해결보다 이해와 지식 전수를 중시합니다.

다양한 접근 실험

# 같은 문제에 다른 페르소나 적용
/sc:analyze api-design/ --persona-architect
/sc:analyze api-design/ --persona-security
/sc:analyze api-design/ --persona-performance
 
# 도구 조합 비교
/sc:build app/ --magic --c7
/sc:build app/ --no-mcp --uc  # 더 빠르지만 단순

왜: 다양한 접근을 이해하면 상황별 최적 도구를 고를 수 있습니다.

나만의 패턴 만들기

# 워크플로에 맞는 조합 정의
# 보안 중심 API 개발
/sc:design api --persona-security --validate
/sc:build api --persona-backend --c7
/sc:test api --type security --play
 
# 개인 “철저 분석” 패턴
/sc:analyze code/ --think --c7 --safe-mode

왜: 자신만의 검증된 패턴은 생산성을 높이고 품질을 일정하게 유지합니다.

흔한 함정 피하기 ⚠️

단순 작업을 과도하게 설계하지 마세요

# ❌ 과한 설정
/sc:analyze simple-utility.js --ultrathink --all-mcp --wave-mode force
 
# ✅ 적절한 설정
/sc:analyze simple-utility.js --focus quality

자동 활성화를 무시하지 마세요

# ❌ 시스템에 역행
/sc:build react-app/ --persona-backend --no-magic  # 잘못된 도구 선택
 
# ✅ 시스템과 협업
/sc:build react-app/  # frontend 페르소나 + Magic 자동 활성화

속도 때문에 안전을 생략하지 마세요

# ❌ 위험
/sc:improve production-auth/ --force --no-validate
 
# ✅ 균형 잡힌 접근
/sc:improve production-auth/ --safe-mode --validate

이해하지 못한 플래그를 쓰지 마세요

# ❌ 카고 컬트식 사용
/sc:command --random-flags-that-look-important
 
# ✅ 목적 있는 사용
/sc:command --think  # 더 깊은 분석 필요
/sc:command --c7     # 외부 라이브러리 다룸

성공 측정 📊

당신의 필요에 맞는 성공 지표를 추적하세요:

Speed: 어떤 플래그 조합이 더 빨리 끝나는가?
Quality: 어떤 접근이 더 좋은 결과를 내는가?
Learning: 어떤 조합이 문제를 더 잘 이해하게 해주는가?
Safety: 어떤 패턴이 당신의 환경에서 문제를 예방하는가?

Remember: SuperClaude는 성공적인 패턴에서 학습합니다. 효과적인 조합을 꾸준히 사용하면, SuperClaude가 당신의 워크플로에 맞춰 자동 활성화를 더 잘 하게 됩니다.

문제 해결 & 흔한 이슈 🚨

SuperClaude가 예상대로 동작하지 않을 때, 다음 방법으로 진단하고 해결하세요.

Command Issues 🛠️

명령이 기대와 다르게 동작할 때

문제: 결과가 엉뚱하거나 요청을 무시한 것처럼 보임.

진단:

# 무엇이 자동 활성화됐는지 확인
/sc:analyze code.js --introspect
# → 의사결정 과정을 보여줌
 
# 명시적으로 제어해보기
/sc:analyze code.js --persona-analyzer --think --seq
# → 자동 활성화를 덮어쓰기

해결책:

# 원하는 것을 더 구체적으로 표현
/sc:improve code.js --focus performance --safe-mode
 
# 미리보기로 먼저 이해
/sc:improve code.js --preview
 
# 단순 → 점진적 복잡도
/sc:analyze code.js                    # 기본
/sc:analyze code.js --think            # 깊이 추가
/sc:analyze code.js --think --c7       # 문서 추가

주요 원인:

자동 활성화가 기대와 다른 도구를 선택
요청이 모호해 의도를 파악하기 어려움
복잡도 불일치(단순 요청에 복잡 플래그, 혹은 그 반대)

명령 실행이 너무 느릴 때

문제: 작업이 예상보다 오래 걸림.

진단:

# 활성화된 요소 확인
/sc:analyze large-project/ --introspect
# → 사용 중인 도구와 서버 표시
 
# 리소스 사용 모니터링
/sc:analyze large-project/ --verbose
# → 상세 실행 단계 출력

해결책:

# 속도 최적화
/sc:analyze large-project/ --uc --no-mcp --scope module
 
# 대규모 작업엔 delegation
/sc:analyze huge-codebase/ --delegate auto --concurrency 3
 
# 범위 축소
/sc:analyze specific-component.js
 
# 비용 큰 기능 비활성화
/sc:analyze code/ --no-mcp --answer-only

성능 최적화 우선순위:

범위 축소 (--scope file vs --scope project)
압축 사용 (--uc)
MCP 서버 비활성화 (--no-mcp)
Delegation 사용 (--delegate auto)
답변만 출력 (--answer-only)

출력이 너무 많을 때

문제: 정보 과다로 핵심을 찾기 어려움.

해결책:

# 압축 사용
/sc:analyze large-system/ --uc
 
# 포커스를 더 구체화
/sc:analyze system/ --focus security
 
# 단순 질문은 answer-only
/sc:explain concept --answer-only
 
# 스코프 제한
/sc:analyze --scope file specific-issue.js

Flag Issues 🏁

플래그 충돌/예상치 못한 동작

문제: 플래그가 안 먹거나 이상하게 동작.

흔한 충돌:

# ❌ 충돌 예
/sc:command --no-mcp --c7        # --no-mcp가 --c7 무시
/sc:command --answer-only --plan # --answer-only는 계획 표시 안 함
/sc:command --uc --verbose       # --uc가 --verbose를 덮어씀
 
# ✅ 잘 맞는 조합
/sc:command --think --c7 --seq
/sc:command --safe-mode --validate --preview

플래그 우선순위:

안전 플래그(--safe-mode) > 최적화 플래그
명시적 플래그 > 자동 활성화
--no-mcp 는 개별 MCP 플래그 전부 무시
마지막으로 지정된 페르소나가 우선
스코프 우선순위: system > project > module > file

진단:

# 실제 활성 플래그 확인
/sc:command args --introspect
# → 우선순위 처리 후 최종 플래그 구성 표시

자동 활성화 문제

문제: 잘못된 플래그/페르소나가 자동 활성화됨.

해결책:

# 명시적으로 오버라이드
/sc:analyze frontend-code/ --persona-security
/sc:build project/ --no-mcp
 
# 더 구체적인 언어 사용
/sc:analyze "security vulnerabilities in auth system"  # 명확한 의도
# vs
/sc:analyze auth system                                # 모호
 
# 키워드 트리거 확인
/sc:help analyze

자동 활성화 디버깅:

# 특정 플래그가 왜 붙었는지 확인
/sc:troubleshoot "why did --think-hard activate?" --introspect

Persona Issues 🎭

잘못된 페르소나가 활성화

문제: 필요한 전문가와 다른 페르소나 사용.

진단:

# 페르소나 선택 이유 확인
/sc:analyze code/ --introspect

해결책:

# 명시적으로 페르소나 지정
/sc:analyze backend-api/ --persona-security
/sc:analyze ui-component/ --persona-performance
 
# 더 정확한 표현 사용
/sc:analyze "security issues in payment processing"
/sc:analyze "slow database queries"
 
# 다른 관점 시도
/sc:analyze payment-system/ --persona-security
/sc:analyze payment-system/ --persona-architect

페르소나가 작동 안 하는 것처럼 보일 때

문제: 페르소나를 기대했지만 일반적인 답변만 옴.

확인:

# 활성 여부 검증
/sc:analyze auth/ --persona-security --introspect
# → 보안 중심 추론이 보여야 함
 
# 도메인 키워드가 명확한지 확인
/sc:scan authentication --focus security

해결책:

# 페르소나와 포커스를 명시
/sc:analyze code/ --persona-security --focus security
 
# 페르소나에 맞는 커맨드 사용
/sc:scan --persona-security
/sc:test --persona-qa
/sc:document --persona-scribe

MCP Server Issues 🔧

MCP 서버가 활성화되지 않을 때

문제: 기대한 MCP 기능이 동작하지 않음.

진단:

# MCP 상태 확인
/sc:troubleshoot "MCP servers not working" --introspect
 
# MCP 설치 확인
/sc:load --summary   # 사용 가능한 MCP 서버 출력
 
# 특정 서버 테스트
/sc:analyze react-app/ --c7     # Context7
/sc:troubleshoot issue --seq    # Sequential
/sc:build ui/ --magic           # Magic
/sc:test app/ --play            # Playwright

일반 해결책:

# 강제 활성화
/sc:analyze code/ --all-mcp
 
# 비활성 여부 확인
/sc:analyze code/ --c7  # 안 되면 Context7이 비가용일 수도
 
# 대체 접근 사용
/sc:analyze react-app/ --no-mcp

MCP 서버가 너무 느릴 때

문제: MCP 통합 때문에 느려짐.

해결책:

# MCP 비활성화
/sc:analyze large-project/ --no-mcp
 
# 선택적 MCP만 사용
/sc:analyze react-code/ --magic --no-seq
 
# MCP 최적화
/sc:analyze code/ --uc --c7

Performance Issues ⚡

토큰 사용량 과다

문제: 컨텍스트 제한에 걸리거나 비용이 증가.

해결책:

# 압축 활성화
/sc:analyze huge-project/ --uc
 
# 범위 축소
/sc:analyze --scope module specific-area/
/sc:analyze --scope file specific-file.js
 
# Delegation 사용
/sc:analyze large-codebase/ --delegate auto --uc
 
# 비용 큰 기능 끄기
/sc:analyze code/ --no-mcp --answer-only

메모리/리소스 이슈

문제: 리소스 부족으로 실패 또는 극심한 지연.

해결책:

# 동시성 줄이기
/sc:analyze large-project/ --delegate auto --concurrency 1
 
# Safe mode 사용
/sc:improve large-system/ --safe-mode
 
# 작업을 작은 단위로 분할
/sc:analyze module1/
/sc:analyze module2/
/sc:analyze module3/

Quality and Safety Issues 🛡️

위험해 보이는 제안

문제: SuperClaude의 변경 제안이 너무 위험함.

항상 안전 기능 사용:

# 적용 전 미리보기
/sc:improve important-code/ --preview
 
# 중요 코드엔 Safe mode
/sc:improve production-auth/ --safe-mode
 
# 검증 추가
/sc:improve system/ --validate --safe-mode
 
# 반복적 접근
/sc:improve complex-system/ --loop --safe-mode

변경으로 기능이 깨질 때

문제: 개선 적용 후 문제가 발생.

예방:

/sc:improve code/ --preview
/sc:improve code/ --safe-mode
/sc:improve code/ --safe-mode && /test code/

복구:

git으로 롤백
--safe-mode로 점진적 적용
적용 전 --validate로 검증

Framework & Integration Issues 🔗

프로젝트 컨텍스트를 이해 못할 때

문제: 추천이 프로젝트 패턴/제약과 맞지 않음.

해결책:

# 먼저 컨텍스트 로딩
/sc:load --deep --summary
 
# 프로젝트 유형을 명시
/sc:analyze react-typescript-app/ --c7
 
# 적절한 페르소나 사용
/sc:analyze node-api/ --persona-backend
/sc:analyze react-ui/ --persona-frontend

결과가 일관되지 않을 때

문제: 같은 명령이 때마다 다른 결과.

진단:

# 무엇이 다르게 자동 활성화됐는지 확인
/sc:command args --introspect

해결책:

# 요구사항을 더 명확히
/sc:improve code/ --focus performance --persona-performance --safe-mode
 
# 일관된 플래그 패턴 사용
/sc:analyze --think --c7
/sc:improve --safe-mode

Getting Help 🆘

막혔을 때

자가 진단 단계:

--introspect로 SuperClaude의 생각 보기
더 단순한 버전으로 시도
명시 플래그로 자동 활성화 확인
--help로 옵션 확인

Escalation Path:

# 프레임워크 자체 도움
/sc:troubleshoot "SuperClaude framework issues" --introspect
 
# 문서 확인
/sc:help
/sc:analyze --help
 
# 기본 기능 테스트
/sc:analyze README.md
/sc:build --help

이슈 보고

보고 시 포함할 것:

사용한 명령: /analyze code/ --think --c7
기대 동작: “보안 분석을 제공해야 함”
실제 동작: “기본 코드 리뷰만 제공”
컨텍스트: “Node.js 인증 시스템 작업 중”
SuperClaude 버전: /help로 확인

유용한 디버그 정보:

# 진단 정보 받기
/sc:troubleshoot "describe your issue" --introspect --verbose
# → 버그 리포트용 상세 컨텍스트 제공

Quick Reference for Common Problems 📋

문제	빠른 해결책	커맨드/플래그
너무 느림	범위 축소 + 압축	`--scope file --uc`
잘못된 페르소나	명시적으로 오버라이드	`--persona-security` 등
출력 과다	압축 사용	`--uc`
위험한 변경	안전 기능 사용	`--safe-mode --preview`
MCP 작동 안 함	강제 활성화 또는 비활성화	`--all-mcp` 또는 `--no-mcp`
결과 불일치	명시 플래그 사용	`--persona-x --think --c7`
컨텍스트 문제	프로젝트 컨텍스트 로드	`/load --deep`
토큰 한계	압축 + Delegation	`--uc --delegate auto`

기억하세요: 헷갈릴 때는 단순하게 시작하고 필요에 따라 복잡도를 올리세요.
--introspect로 SuperClaude의 판단을 들여다보고, 특정 행동이 필요할 땐 자동 활성화를 과감히 오버라이드하세요.

결론 🎉

이제 SuperClaude v3.0의 구성 요소, 역량, 그리고 효과적인 사용 방법까지 모두 이해하셨습니다. 프레임워크를 최대한 활용하도록 도와줄 핵심 포인트를 정리하며 마무리할게요.

Key Takeaways 🎯

SuperClaude의 핵심 가치

SuperClaude는 Claude Code를 범용 AI 어시스턴트에서 전문 개발 파트너로 변모시킵니다:

개발 워크플로를 이해하는 15개의 특화 명령어
도메인 지식을 갖춘 11명의 전문가 페르소나
도구를 자동으로 조율하는 지능형 오케스트레이션
안전성과 신뢰성을 유지하는 품질 우선 접근 방식

힘의 원천은 ‘조율’

SuperClaude의 진짜 힘은 개별 기능이 아니라, 그것들이 함께 작동하는 방식에서 나옵니다:

명령어가 적절한 페르소나와 MCP 서버를 자동 활성화
복합 문제에서는 페르소나들이 협업
오케스트레이터가 도구 선택과 자원 사용을 최적화
품질 게이트가 결과의 일관성과 신뢰성 보장

단순하게 시작하고, 지능적으로 확장하기

SuperClaude에 접근하는 최선의 방법:

기본 명령으로 핵심 동작 이해
자동 활성화를 신뢰하며 최적 조합 학습
특정 관점이 필요할 때 수동 제어 추가
자신감이 생기면 고급 기능도 실험

What Makes SuperClaude Different 🌟

한계에 대해 솔직함

v3.0은 베타를 막 벗어난 상태라 거친 부분이 있음
잘 되는 것 vs. 실험적 기능을 명확히 문서화
화려함보다 신뢰성을 우선
현실적인 일정과 기대치를 제공

근거 기반 개발(Evidence-Based Development)

모든 추천은 검증 가능한 데이터로 뒷받침
품질 게이트로 기존 기능 파손 방지
실제 사용 패턴 기반 성능 최적화
사용자 피드백으로 지속적 개선

당신의 워크플로를 존중

기존 도구를 대체하기보다 보완
표준 개발 관행과의 호환성 유지
모든 자동 결정은 수동으로 오버라이드 가능
단순 작업부터 엔터프라이즈급 복잡 작업까지 확장

Practical Next Steps 🛣️

신규 사용자라면

설치부터 시작: Installation Guide 참조
기본 명령 시도: /help, /analyze README.md, /build --help
도메인 가이드 탐색: Commands, Flags, Personas
점진적으로 자신감 쌓기: 간단 → 복잡 워크플로 → 고급 기능

숙련 사용자라면

워크플로 최적화: 잘 맞는 플래그 조합 파악
조율 실험: 복잡 문제에 다양한 페르소나 조합 적용
피드백 제공: 환경에서 잘 된 점/안 된 점 공유
고급 기능 탐색: Wave orchestration, sub-agent delegation, introspection mode

When to Use SuperClaude 🤔

SuperClaude가 뛰어난 분야

개발 워크플로: 빌드, 테스트, 배포, 문서화
코드 분석: 품질 평가, 보안 스캔, 성능 최적화
학습 & 이해: 복잡 시스템 설명, 신규 프로젝트 온보딩
품질 개선: 체계적 리팩터링, 기술 부채 감소
다도메인 문제: 여러 전문성이 필요한 이슈

일반 Claude Code를 쓸 때

단순 질문: 특화 도구가 필요 없는 빠른 설명
창의적 글쓰기: 비기술적 콘텐츠 생성
일반 리서치: 소프트웨어 개발 외 주제 탐색
브레인스토밍: 구체적 구현 없이 아이디어 발산

The SuperClaude Philosophy 💭

인간-AI 협업

SuperClaude는 인간 전문성을 대체가 아닌 증강하도록 설계되었습니다:

당신은 컨텍스트와 목표를 제공 → SuperClaude는 실행과 전문성 제공
당신이 결정 → SuperClaude는 근거와 추천 제공
당신이 제약을 이해 → SuperClaude는 이를 존중하고 그 안에서 작동
결과는 당신의 것 → SuperClaude는 더 나은 결과를 돕는 조력자

지속적 개선

프레임워크는 다음을 통해 발전합니다:

사용 패턴: 실제로 잘 먹히는 조합 학습
사용자 피드백: 현실 경험이 개발 우선순위에 반영
근거 기반 최적화: 데이터로 도구와 워크플로 개선
커뮤니티 기여: 지식/베스트 프랙티스 공유

Looking Forward 🔮

단기 (향후 6개월)

성능 최적화: 작업 속도 30~50% 향상
MCP 서버 안정성 개선: 실패율 80% 감소
품질 게이트 강화: 더 실용적인 피드백 제공
사용자 질문/피드백 기반 문서 개선

중기 (6~18개월)

재설계된 Hooks 시스템: 더 나은 구조와 성능
사용 패턴 학습 기반 더 똑똑한 자동 활성화
커뮤니티가 기여한 MCP 생태계 확장
진짜 병렬 처리 기반 고급 오케스트레이션

장기 비전

프로젝트/팀 워크플로에 대한 깊은 컨텍스트 이해
코드 분석·프로젝트 패턴 기반 선제적 지원
협업 개발을 위한 팀 인식 기능
IDE, CI/CD, 클라우드 플랫폼과의 풍부한 통합 생태계

Final Thoughts 🎉

SuperClaude v3.0은 향상된 소프트웨어 개발 워크플로를 위한 탄탄한 기반입니다. 완벽하진 않지만, 기존 워크플로를 방해하거나 인간 전문성을 대체하지 않으면서 AI를 사려 깊게 통합할 수 있음을 보여줍니다.

이 프레임워크는 당신을 더 생산적으로 만들고, 새로운 것을 배우게 하며, 놓칠 수 있었던 문제를 잡아낼 때 성공합니다. 당신의 장인을 대체하는 것이 아니라, 든든한 동료가 되는 것이 목표입니다.

Thank You 🙏

SuperClaude를 깊이 이해하려 노력해주셔서 감사합니다. 여러분의 성실한 사용, 솔직한 피드백, 거친 부분에 대한 인내가 이 프레임워크를 개발 커뮤니티에 진정 가치 있는 도구로 만들어줄 것입니다.

가끔 특정 작업에만 쓰든, 일상 워크플로에 깊이 통합하든 여러분의 개발 경험이 조금이라도 더 나아지길 바랍니다. 기대와 다르게 동작할 때는 꼭 알려주세요—그 피드백이 개선의 핵심입니다.

행복한 코딩 되세요! 🚀
SuperClaude와 함께 만들어갈 멋진 결과물을 기대하고 있습니다.

핵심 명령어와 플래그만 빠르게 참조하려면 [[KnowledgeBase/Blog/슈퍼 클로드코드 사용자 가이드 요약본]]을 활용한다.

첫 번째 댓글을 남겨보세요.