💡 SuperClaude 프레임워크에 오신 것을 환영합니다!

이 매뉴얼은 25개 명령어, 15개 전문 에이전트 + 비즈니스 전문가 패널, 7가지 동작 모드, 8개 MCP 서버를 모두 다루며, 자세한 사용 방법과 풍부한 실전 사례를 포함합니다. 각 기능은 개발 작업을 더욱 효율적이고 지능적으로 만들기 위해 신중하게 설계되었습니다.

🎯 빠른 시작

SuperClaude 설치

# 권장 방법 (pipx)
pipx install SuperClaude && pipx upgrade SuperClaude && SuperClaude install

# 또는 npm 사용
npm install -g @bifrost_inc/superclaude && superclaude install

# 또는 pip 사용
pip install SuperClaude && pip upgrade SuperClaude && SuperClaude install

첫 사용

설치 후 Claude Code에서 다음을 입력하세요:

/sc:help

사용 가능한 모든 명령어 목록이 표시됩니다. 탐색을 시작해 봅시다!

💻 개발 워크플로

요구사항부터 배포까지 전체 주기 개발을 지원하는 일반적인 개발 워크플로 명령어:

/sc:brainstorm - 대화형 요구사항 탐색
소크라테스식 대화를 통해 모호한 아이디어를 명확한 기술 사양으로 전환

구문

/sc:brainstorm [--strategy systematic|agile|enterprise] [--depth shallow|normal|deep] [--parallel] [주제/아이디어]
예제 1: 체계적 제품 탐색
/sc:brainstorm --strategy systematic --depth deep "AI-driven project management tool"
✨ 효과:
  • 다중 전문가 분석(아키텍트, 애널리스트, 프로젝트 매니저)
  • Sequential MCP를 사용한 구조화된 탐색 프레임워크
  • 완전한 요구사항 문서 생성

💡 실용적인 시나리오

SaaS 제품 콘셉트 탐색
/sc:brainstorm --strategy systematic --depth shallow --parallel "Team collaboration project management tool with AI assistant"
배경:
제품 콘셉트 시나리오:

  • AI 어시스턴트 통합을 포함한 팀 협업 프로젝트 관리 도구에 대한 모호한 아이디어가 있음
  • 핵심 가치 제안 및 대상 사용자 그룹에 대해 불확실함
  • 구체적인 AI 통합 시나리오가 불명확함
  • 제품 포지셔닝 및 기능 범위를 명확히 하기 위한 체계적인 탐색이 필요함
결과:
사용자 스토리, 핵심 기능 및 기술 스택이 식별되어 요구사항 탐색이 완료되었습니다. 설계 단계 준비 완료.
팀 협업 도구 개발
/sc:brainstorm --strategy agile --depth normal "Team collaboration project management tool with AI assistant"
배경:
개발 계획 시나리오:

  • 팀 협업 도구를 개발하고 싶음
  • 실제 가치를 제공할 핵심 기능에 대해 불확실함
  • 경쟁 시장에서 차별화 우위를 식별해야 함
결과:
체계적인 대화를 통해 핵심 기능과 가치 제안이 명확해졌습니다. PRD 작성 준비 완료.
기능 우선순위 평가
/sc:brainstorm --strategy enterprise --depth deep "Feature prioritization: User feedback system vs Advanced analytics vs Third-party integrations"
배경:
우선순위 과제:

  • 제품 백로그에 다양한 이해관계자로부터 20개 이상의 기능 요청이 누적됨
  • 제한된 개발 리소스(소규모 팀)
  • 영향을 최대화하기 위한 데이터 기반 우선순위 지정 필요
  • 빠른 성과와 장기 전략 기능 간의 균형을 맞춰야 함
결과:
데이터 기반 권장사항 및 구현 로드맵과 함께 기능 우선순위가 완료되었습니다.
💡 모범 사례:
  • 아이디어가 모호할수록 이 명령어 사용에 더 적합합니다
  • Claude가 대화를 주도하도록 하고 제시된 질문에 답변하세요
  • 생성된 요구사항 문서를 이후 개발에 활용하세요
/sc:implement - 기능 구현
지능형 전문가 조율 및 MCP 통합을 사용한 기능 및 코드 구현

구문

/sc:implement [--type component|api|service|feature] [--framework react|vue|express] [--safe] [--with-tests] [기능 설명]
예제 1.1: 빠른 컴포넌트
/sc:implement --type component --framework react "user login form"
✨ 효과:
  • React 컴포넌트 생성
  • Hooks 및 상태 관리 포함
  • 자동 폼 검증
예제 1.2: API 엔드포인트
/sc:implement --type api --framework express --safe "payment processing interface"
✨ 효과:
  • Express REST API
  • 오류 처리 및 입력 검증 포함
  • 보안 모드로 일반적인 취약점 방지
예제 1.3: 완전한 기능 모듈
/sc:implement --type feature --framework react --with-tests --magic --c7 "real-time chat system"
✨ 효과:
  • 완전한 프론트엔드 및 백엔드 구현
  • 단위 테스트 및 통합 테스트 포함
  • Magic이 아름다운 UI 생성
  • Context7이 모범 사례 제공
  • WebSocket 연결 자동 설정
예제 1.4: 마이크로서비스 구현
/sc:implement --type service --framework express --with-tests --seq --think-hard "order processing microservice"
✨ 효과:
  • 독립적인 마이크로서비스 아키텍처
  • 메시지 큐 통합 포함
  • Sequential의 비즈니스 로직 심층 분석
  • Docker 구성 자동 생성

💡 실용적인 시나리오

파일 업로드 기능
/sc:implement --type feature --framework react --safe --with-tests "Large file upload with chunking and resume"
배경:
구현 요구사항:

  • 청킹 메커니즘을 사용한 대용량 파일 업로드 지원 구현 필요
  • 최대 2GB 크기의 파일 지원해야 함
  • 실시간 업데이트를 통한 진행 상황 추적 필요
  • 네트워크 중단을 처리하기 위한 재개 기능 필요
  • 사용자에게 정확한 업로드 진행률을 표시해야 함
결과:
검증 및 진행 상황 추적과 함께 파일 업로드 기능이 구현되었습니다.
사용자 인증 시스템
/sc:implement --type api --framework express --safe --with-tests "User authentication system (registration, login, JWT)"
배경:
시스템 요구사항:

  • 완전한 사용자 인증 시스템 구현 필요
  • 이메일 검증을 포함한 사용자 등록 포함해야 함
  • JWT 토큰 관리를 통한 안전한 로그인 필요
  • 기술 스택: Express.js + JWT + bcrypt(비밀번호 해싱용)
  • 암호화된 비밀번호로 사용자 모델을 설계해야 함
  • 적절한 검증을 통한 등록 및 로그인 API 엔드포인트 필요
  • 보호된 경로를 위한 인증 미들웨어 필요
결과:
안전한 토큰 처리 및 세션 관리와 함께 인증 시스템이 구현되었습니다.
💡 모범 사례:
  • 설명은 명확하고 구체적으로, 핵심 요구사항 포함
  • 프로덕션 코드는 항상 --safe 사용
  • --with-tests로 테스트 커버리지 확보
/sc:design - 시스템 설계
시스템 아키텍처, API 인터페이스 및 컴포넌트 구조 설계, 확장 가능한 기술 솔루션 제공

구문

/sc:design [--type architecture|api|component|database] [--format diagram|spec|code] "<시스템/컴포넌트>"

매개변수

  • --type: : 설계 유형
    • architecture
    • api
    • component
    • database
  • --format: : 출력 형식
    • diagram
    • spec
    • code
예제 9.1: API 설계
/sc:design --type api --format spec "User Authentication API"
✨ 효과:
  • OpenAPI 사양
  • 엔드포인트 정의
  • 보안 체계
예제 9.2: 데이터베이스 설계
/sc:design --type database --format code "E-commerce Order System"
✨ 효과:
  • 데이터베이스 스키마
  • ER 다이어그램
  • SQL 스크립트
예제 9.3: 마이크로서비스 아키텍처 설계
/sc:design --type architecture --format diagram --ultrathink --c7 ""
✨ 효과:
  • 완전한 아키텍처 다이어그램
  • 서비스 통신 설계
  • 데이터 흐름 다이어그램
  • 기술 스택 선택
  • 확장성 계획

💡 실용적인 시나리오

실시간 협업 API 설계
/sc:design --type api --format spec "Real-time Document Collaboration API"
배경:
설계 요구사항:

  • 실시간 협업 문서 편집 기능을 설계해야 함
  • 다중 사용자 편집을 위한 적절한 API 구조 필요
  • 데이터 동기화 및 충돌 해결을 처리해야 함
  • 연결된 모든 클라이언트에 실시간 업데이트 필요
결과:
사양 및 문서가 구현 준비 완료되어 API 설계가 완료되었습니다.
결제 시스템 아키텍처 리팩토링
/sc:design --type architecture --format diagram "Payment System Refactoring"
배경:
리팩토링 과제:

  • 전자상거래 시스템 결제 코드가 구성요소 간 높은 결합도로 인해 혼란스러움
  • 새로운 결제 제공자를 추가하거나 기존 흐름을 수정하기 어려움
  • 리팩토링 전에 아키텍처를 재설계해야 함
  • 명확한 관심사 분리 및 테스트 가능성 확보 필요
결과:
컴포넌트 상호작용 및 배포 전략이 문서화되어 시스템 아키텍처가 정의되었습니다.
💡 모범 사례:
  • 코딩 전 설계, 재작업 방지
  • 시스템의 확장성과 유지보수성 고려
  • --format diagram으로 시각화 문서 생성
  • 설계 리뷰 후 구현 단계 진입

💾 세션 관리

개발 세션을 저장하고 로드하여 세션 간 컨텍스트 영속성을 구현합니다:

/sc:save - 세션 저장
Serena MCP를 사용하여 세션 컨텍스트 및 발견 사항 저장

구문

/sc:save [--type session|learnings|context|all] [--summarize] [--checkpoint]

매개변수

  • --type: : 저장 유형
    • session
    • learnings
    • context
    • all
  • --summarize: : 요약 생성
  • --checkpoint: : 복구 가능한 체크포인트 생성
예제: 종합 체크포인트
/sc:save --type session
✨ 효과:
  • 전체 세션 저장 및 복원 체크포인트
  • 모든 학습 내용, 컨텍스트 및 진행 상황 포함
  • 세션 복원에 사용 가능
예제: 학습 요점 저장
/sc:save --type all --checkpoint --summarize
✨ 효과:
  • 현재 세션의 학습 요점 및 기술 발견 사항 저장
  • 태그를 사용하여 분류하고 나중에 쉽게 검색
  • 프로젝트 지식 베이스 및 모범 사례 구축

💡 실용적인 시나리오

디버깅 세션 진행 상황 저장
/sc:save "payment-bug-analysis"
배경:
세션 시나리오:

  • 복잡한 결제 통합 버그 작업 중
  • 근무일 종료 시간이 다가옴
  • 보존해야 할 중요한 디버깅 진행 상황을 만들었음
  • 내일 조사를 계속하고 싶으며 컨텍스트를 잃지 않고 싶음
결과:
향후 계속을 위해 진행 상황 및 발견사항이 문서화되어 디버깅 세션이 저장되었습니다.
프로젝트 아키텍처 학습 문서화
/sc:save "project-architecture-overview"
배경:
지식 캡처 시나리오:

  • 팀과 심층 아키텍처 논의 완료
  • 중요한 기술 스택 결정을 내렸음
  • 향후 참조를 위해 아키텍처 근거를 보존해야 함
  • 팀 온보딩을 위해 지식에 액세스할 수 있게 하고 싶음
결과:
지식 보존을 위해 프로젝트 학습이 영구 저장소에 저장되었습니다.
성능 최적화 인사이트 저장
/sc:save "react-performance-optimization"
배경:
최적화 완료:

  • React 컴포넌트 렌더링 성능 최적화를 막 완료함
  • 불필요한 재렌더링에 대한 주요 인사이트 발견
  • React.memo 및 useCallback 최적화 적용
  • 상당한 성능 개선 달성
  • 유사한 시나리오를 위해 솔루션을 문서화하고 싶음
결과:
컴포넌트 상호작용이 문서화되어 시스템 아키텍처가 정의되었습니다.
💡 모범 사례:
  • 중요한 돌파구 이후 즉시 저장
  • 긴 세션의 경우 30분마다 체크포인트 생성
  • 세션 종료 전 --summarize 사용
/sc:load - 세션 로드
Serena MCP를 사용하여 프로젝트 컨텍스트 및 이전 세션 로드

구문

/sc:load [--type session|learnings|context|all] [--checkpoint id]

매개변수

  • --type: : 로드 유형
    • session
    • learnings
    • context
    • all
  • --checkpoint: : 로드할 체크포인트 ID 지정
  • --analyze: : 로드 시 프로젝트 구조 자동 분석
  • --refresh: : 컨텍스트 새로 고침
예제: 체크포인트에서 복원
/sc:load --type project --analyze ""
✨ 효과:
  • 특정 체크포인트의 세션 상태 복원
  • 진행 상황 및 컨텍스트 재로드
  • 중단된 작업 계속 진행
예제: 최근 세션 로드
/sc:load --type checkpoint --refresh "session_20250118_1430"
✨ 효과:
  • 최근 작업 세션을 빠르게 로드
  • 이전 코드 컨텍스트 및 사고 흐름 복원
  • 이전 개발 작업을 원활하게 계속

💡 실용적인 시나리오

어제 디버깅 세션 계속
/sc:load "payment-bug-analysis"
배경:
작업 재개 시나리오:

  • 새로운 작업일 시작
  • 어제 인증 문제를 디버깅하고 있었음
  • 컨텍스트를 신속하게 복원하고 중단한 곳부터 계속해야 함
  • 문제를 다시 분석하지 않고 원활한 워크플로 계속 필요
결과:
전체 프로젝트 상태가 사용 가능하도록 세션 컨텍스트가 성공적으로 복원되었습니다.
프로젝트 메모리 로드
/sc:load "ecommerce-platform"
배경:
프로젝트 활성화 시나리오:

  • 다른 코드베이스 작업 후 다른 프로젝트로 전환
  • 프로젝트별 컨텍스트, 아키텍처 및 규칙을 기억해야 함
  • 문서를 수동으로 검토하지 않고 빠른 재활성화 필요
결과:
아키텍처 및 개발 패턴이 로드되어 프로젝트 컨텍스트가 활성화되었습니다.
학습 컨텍스트 복원
/sc:load "nextjs-learning"
배경:
학습 재개:

  • 지난주에 Next.js App Router 아키텍처 학습
  • 메모를 작성하고 예제로 연습함
  • 중단한 곳에서 학습을 계속해야 함
  • 주요 개념과 다음 학습 단계를 기억하고 싶음
결과:
컴포넌트 상호작용이 문서화되어 시스템 아키텍처가 정의되었습니다.
💡 모범 사례:
  • 새 세션을 시작할 때 프로젝트 컨텍스트를 즉시 로드
  • 프로젝트를 전환하기 전에 현재 세션을 저장한 후 새 프로젝트를 로드
  • 정기적으로 --refresh를 사용하여 오래된 컨텍스트를 새로 고침
  • --analyze를 사용하여 프로젝트 구조를 자동으로 분석

🎯 고급 기능

복잡한 개발 시나리오를 해결하기 위한 강력한 고급 명령어:

/sc:task - 복잡한 작업 실행
지능형 워크플로 관리 및 위임을 통한 복잡한 작업 실행

구문

/sc:task [--parallel] [--validate] [작업 설명] [--delegate auto|files|folders]
예제: 대규모 리팩토링
/sc:task --delegate auto --validate "refactor authentication system"
✨ 효과:
  • 자동 작업 분해 및 위임
  • 병렬 전문가 협업
  • 실행 전 위험 평가

💡 실용적인 시나리오

엔드투엔드 기능 구현
/sc:task --parallel --validate "Integrate Stripe payment (requirements → design → implementation → testing → deployment)"
배경:
요구사항부터 배포까지 결제 통합 기능을 완료해야 합니다.
결과:
모든 단계가 성공적으로 완료되어 전체 워크플로를 통한 기능 구현이 오케스트레이션되었습니다.
문제 진단 및 수정
/sc:task --parallel --validate "Production environment memory leak"
배경:
프로덕션 환경에서 메모리 누수가 발생하고 있으며, 완전한 진단 및 수정 워크플로가 필요합니다.
결과:
체계적인 문제 해결 워크플로를 통해 문제가 진단되고 해결되었습니다.
프로젝트 초기화
/sc:task --parallel --validate "Next.js + TypeScript + Tailwind project"
배경:
새로운 Next.js 프로젝트를 시작하며, 완전한 프로젝트 설정이 필요합니다.
결과:
컴포넌트 상호작용이 문서화되어 시스템 아키텍처가 정의되었습니다.
/sc:workflow - 워크플로 생성
PRD 및 기능 요구사항에서 구조화된 구현 워크플로 생성

구문

/sc:workflow [--strategy systematic|agile|enterprise] [--depth shallow|normal|deep] [--parallel] [--delegate auto] ""
예제 7.1: 애자일 워크플로
/sc:workflow --strategy agile "User Management System"
✨ 효과:
  • 애자일 방법론
  • 사용자 스토리 분해
  • 반복 계획
예제 7.2: 체계적 워크플로
/sc:workflow --strategy systematic --depth deep "@requirements.prd"
✨ 효과:
  • 체계적 방법론
  • 상세한 작업 분해
  • 종속성 그래프
예제 7.3: 기업 병렬 워크플로
/sc:workflow --strategy enterprise --depth deep --parallel --delegate auto "@product-spec.md"
✨ 효과:
  • 기업 수준 프로세스
  • 병렬 작업 실행
  • 자동 작업 할당
  • 간트 차트 생성
  • 팀 협업 계획

💡 실용적인 시나리오

기능 개발 표준 프로세스
/sc:workflow --strategy systematic --depth normal "New Feature Development Standard Process"
배경:
팀에 새로운 구성원이 많아 기능 개발 프로세스를 표준화해야 합니다.
결과:
명확한 단계 및 팀 협업 가이드라인이 정의되어 개발 워크플로가 구조화되었습니다.
버그 수정 프로세스
/sc:workflow --strategy agile --depth shallow "Bug Fix Standard Process"
배경:
버그 수정 프로세스가 불규칙하여, 종종 단계를 놓쳐 재작업이 발생합니다.
결과:
조사, 해결 및 검증 단계가 문서화되어 버그 수정 워크플로가 표준화되었습니다.
기업 병렬 워크플로
/sc:workflow --strategy enterprise --depth deep --parallel --delegate auto "@product-spec.md"
배경:
대규모 프로젝트는 다중 팀 협업이 필요하며, 기업 워크플로 계획이 필요합니다.
결과:
측정 가능한 성능 향상이 달성되어 개선사항이 적용되었습니다.
💡 모범 사례:
  • PRD에 명확한 요구사항 정의 포함
  • --estimate를 사용하여 리소스 계획
  • 정기적으로 워크플로 업데이트하여 진행 상황 추적
  • 팀 규모를 고려하여 시간 추정 조정
/sc:spawn - 작업 오케스트레이션
메타 시스템 작업 오케스트레이션, 대규모 복잡한 작업의 지능형 분해 및 위임

구문

/sc:spawn "작업 설명" [--strategy sequential|parallel|adaptive] [--breakdown auto] [--delegate agents]
예제: 대규모 프로젝트 오케스트레이션
/sc:spawn --strategy adaptive --breakdown auto --delegate agents "Build complete e-commerce admin system"
✨ 효과:
  • 작업 분해: 사용자 관리, 상품 관리, 주문 시스템, 결제 통합, 데이터 분석
  • 에이전트 할당: backend-architect(아키텍처), security-engineer(결제 보안), frontend-architect(관리 인터페이스)
  • 실행 전략: 아키텍처 설계→병렬 개발→통합 테스트
  • 지능형 스케줄링 및 진행 상황 추적

💡 실용적인 시나리오

여러 기능의 병렬 개발
/sc:spawn --strategy adaptive --breakdown auto "user avatar upload, comment system, search optimization"
배경:
스프린트에서 동시에 3개의 독립적인 기능을 개발해야 하며, 병렬 처리를 통해 개발을 가속화하고자 합니다.
결과:
모든 병렬 개발 스트림이 성공적으로 실행되어 작업 오케스트레이션이 완료되었습니다.
다중 환경 배포
/sc:spawn --strategy parallel --breakdown auto "Deploy to test, staging, and production environments"
배경:
테스트, 스테이징 및 프로덕션 환경에 동시에 배포해야 합니다.
결과:
모든 대상 환경에서 병렬 배포가 성공적으로 완료되었습니다.
복잡한 문제 분할 정복
/sc:spawn --strategy adaptive --breakdown auto "Analyze slow API, frontend lag, and database query performance"
배경:
시스템 성능 문제가 복잡하여, 여러 하위 문제로 분해하고 병렬로 분석해야 합니다.
결과:
컴포넌트 상호작용이 문서화되어 시스템 아키텍처가 정의되었습니다.
💡 모범 사례:
  • 대규모, 다중 모듈 프로젝트에 적합
  • 시스템이 에이전트 및 전략을 지능적으로 할당하도록 허용
  • 정기적으로 하위 작업 진행 상황 확인
  • 복잡한 종속성에는 sequential 전략 사용
/sc:reflect - 작업 성찰
Serena MCP 분석 기능을 사용한 작업 성찰 및 검증, 품질 평가

구문

/sc:reflect [--analyze outcomes|process|quality] [--improve] [--task TasksID]
예제: 구현 작업 성찰
/sc:reflect --task --analyze quality --improve "implement user authentication"
✨ 효과:
  • 구현 품질 분석(코드 커버리지, 보안)
  • 잠재적 문제 식별(오류 처리 부족, 성능 위험)
  • 개선 제안 생성
  • 안전하게 개선 가능한 부분 자동 적용
  • 수동 검토가 필요한 문제 표시

💡 실용적인 시나리오

작업 완료 검증
/sc:reflect --analyze outcomes --improve
배경:
사용자 인증 기능 개발을 완료하고, 모든 요구사항이 충족되었는지 확인해야 합니다.
결과:
요구사항 커버리지가 확인되어 작업 완료가 검증되었습니다.
코드 품질 성찰
/sc:reflect --analyze process
배경:
리팩토링이 완료되었으며, 코드 품질이 표준을 충족하는지 평가해야 합니다.
결과:
개선 영역이 식별되어 코드 품질 검증이 완료되었습니다.
프로젝트 마일스톤 검토
/sc:reflect --analyze quality --improve
배경:
스프린트가 종료되었으며, 이번 반복의 성과와 문제를 검토해야 합니다.
결과:
성과가 문서화되고 개선 기회가 식별되어 스프린트 리뷰가 완료되었습니다.
💡 모범 사례:
  • 중요한 작업 완료 후 적시에 성찰
  • 성찰 결과를 사용하여 향후 작업 최적화
  • 정기적인 성찰로 개발 품질 향상
  • 성찰에서 발견된 문제 즉시 수정
/sc:select-tool - 도구 선택
복잡도 점수 및 작업 분석을 기반으로 MCP 도구 지능적 선택

구문

/sc:select-tool "작업 설명" [--suggest] [--compare] [--explain]
예제: 도구 선택 제안
/sc:select-tool --suggest --explain "Need to rename function names in 100 files"
✨ 효과:
  • 작업 복잡도 분석: 중간 수준(일괄 편집)
  • 추천 도구: Morphllm MCP(일괄 패턴 편집)
  • 대안: Serena MCP(심볼 이름 변경)
  • 설명: Morphllm이 패턴화된 일괄 교체에 더 적합
  • 예상 효율성 향상: 80%

💡 실용적인 시나리오

복잡한 작업 도구 선택
/sc:select-tool --suggest --explain "Implement user behavior data analysis and visualization reports"
배경:
복잡한 데이터 분석 기능을 구현해야 하며, 가장 적합한 MCP 도구가 무엇인지 확실하지 않습니다.
결과:
작업 복잡도 분석을 기반으로 최적의 도구 조합이 권장되었습니다.
성능 최적화 도구 선택
/sc:select-tool --suggest --explain "API performance optimization"
배경:
API 응답이 느리며, 성능 분석 및 최적화를 위한 적절한 도구를 선택해야 합니다.
결과:
체계적인 최적화를 위한 적절한 MCP 서버와 함께 도구 워크플로가 설계되었습니다.
새로운 프레임워크 학습 도구 선택
/sc:select-tool --suggest --explain "Learn Next.js 14 new features"
배경:
팀이 Next.js 14를 학습해야 하며, 최상의 학습 경로와 도구를 선택해야 합니다.
결과:
최적화된 프로덕션 아티팩트가 생성되어 빌드가 성공적으로 완료되었습니다.
💡 모범 사례:
  • 어떤 도구를 사용할지 불확실할 때 이 명령 사용
  • --compare를 사용하여 다양한 방안의 장단점 이해
  • 프로젝트 규모에 따라 적절한 도구 선택
  • 도구 선택 논리를 학습하여 효율성 향상

기타 핵심 명령어

더 강력한 기능 명령어

/sc:help - 모든 명령어 보기
사용 가능한 모든 SuperClaude 명령어와 기능 설명을 빠르게 확인

구문

/sc:help
/sc:analyze - 코드 품질 분석
코드 품질, 보안, 성능 및 아키텍처에 대한 포괄적인 분석

구문

/sc:analyze [--focus quality|security|performance|architecture] [--depth quick|deep] [--format text|json|report] [--all-mcp] [--validate] [대상]

매개변수

  • --focus: : 분석 초점
    • quality
    • security
    • performance
    • architecture
  • --depth: : 분석 깊이
    • quick
    • deep
  • --format: : 출력 형식
    • text
    • json
    • report
  • --all-mcp: : 모든 MCP 서버를 활성화하여 전방위 분석 수행
  • --validate: : 분석 결과를 검증하고 개선 계획 생성
예제 2.1: 빠른 보안 스캔
/sc:analyze --focus security --depth quick "src/auth"
✨ 효과:
  • 빠른 보안 취약점 식별
  • 5-10초 내에 스캔 완료
  • 인증 로직에 집중
예제 2.2: 성능 분석
/sc:analyze --focus performance --depth normal "api/"
✨ 효과:
  • 표준 성능 분석
  • 성능 병목 현상 식별
  • 최적화 권장사항 제공
예제 2.3: 심층 아키텍처 평가
/sc:analyze --focus architecture --depth deep --format report --think-hard --seq "."
✨ 효과:
  • 포괄적인 아키텍처 분석
  • 상세한 보고서 생성
  • 디자인 패턴 사용 평가
  • 아키텍처 부채 식별
  • Sequential이 리팩토링 제안 제공
예제 2.4: 포괄적인 품질 검토
/sc:analyze --focus quality --depth deep --format json --all-mcp --validate "src/"
✨ 효과:
  • 포괄적인 코드 품질 검토
  • CI/CD 통합을 위한 JSON 형식
  • 커버리지 및 복잡도 분석
  • 개선 계획 자동 생성

💡 실용적인 시나리오

신규 기능 성능 분석
/sc:analyze --focus performance --depth deep --format report "src/search"
배경:
성능 조사:

  • 새로 개발한 검색 기능이 응답 시간이 느림
  • 사용자가 검색당 2-3초의 지연을 경험
  • 성능 병목 현상을 분석해야 함
  • 최적화 기회를 신속하게 식별해야 함
결과:
병목 현상이 식별되고 최적화 권장사항이 제공되어 성능 분석이 완료되었습니다.
레거시 코드 품질 평가
/sc:analyze --focus quality --depth deep --format json "src/legacy"
배경:
기술 부채 평가:

  • 레거시 코드베이스에 대한 포괄적인 품질 분석 수행 필요
  • 이전 팀에서 인수받은 코드베이스로 품질 상태가 불명확함
  • 리팩토링 작업을 계획하기 전에 기술 부채를 평가해야 함
  • 영향도를 기반으로 개선 작업의 우선순위를 정해야 함
결과:
실행 가능한 개선 권장사항과 함께 코드 품질 평가가 완료되었습니다.
💡 모범 사례:
  • 첫 분석 시 --depth quick을 사용하여 문제 영역을 빠르게 파악
  • 중요 모듈에 대해 --depth deep을 사용하여 심층 분석 수행
  • 핵심 모듈에 대해 정기적으로 --focus security 보안 감사 실행
  • --format report를 사용하여 팀과 공유 가능한 분석 보고서 생성
  • --all-mcp와 결합하여 여러 MCP 서버를 사용한 전방위 분석 수행
/sc:research - 심층 웹 리서치
적응형 계획 수립과 지능형 검색을 사용한 심층 웹 리서치

구문

/sc:research [--depth quick|standard|deep|exhaustive] [--strategy planning_only|intent_planning|unified] [--domains "domain1,domain2"] "[queries]"
예제 8.1: 빠른 조사
/sc:research --depth quick "latest frontend framework comparison"
✨ 효과:
  • 빠른 개요
  • 핵심 포인트 요약
  • 5-10분 내 완료
예제 8.2: 표준 리서치
/sc:research --depth standard --strategy planning "microservices architecture best practices"
✨ 효과:
  • 표준 깊이 리서치
  • 다중 소스 정보 집계
  • 실용적 권장사항
예제 8.3: 철저한 기술 리서치
/sc:research --depth exhaustive --strategy unified --serena "zero trust security architecture implementation guide"
✨ 효과:
  • 가장 철저한 리서치
  • 포괄적인 정보 수집
  • 비교 분석 표
  • Serena가 리서치 결과 저장
  • 트렌드 및 예측 분석

💡 실용적인 시나리오

기술 스택 연구
/sc:research --strategy unified "React state management comparison 2024"
배경:
기술적 결정:

  • 새로운 React 프로젝트를 위한 상태 관리 솔루션 선택 필요
  • Redux vs Zustand vs Jotai vs React Context 평가
  • 팀의 경험 수준이 혼합되어 있음
  • 장단점이 있는 데이터 기반 결정 필요
결과:
프로젝트 요구사항을 기반으로 한 권장사항과 함께 기술 옵션이 분석되었습니다.
보안 모범 사례 연구
/sc:research --strategy unified "OAuth 2.0 security best practices and common vulnerabilities"
배경:
보안 감사 준비:

  • 인증 시스템의 보안 감사 준비 중
  • 현재 모범 사례 및 표준 이해 필요
  • 현재 구현의 격차 식별하고 싶음
  • 개선을 위한 권장사항 제공해야 함
결과:
보안 모범 사례 및 구현 권장사항이 문서화되어 연구가 완료되었습니다.
/sc:improve - 코드 개선
체계적인 리팩토링과 품질 향상을 통해 기존 코드의 유지보수성, 성능 및 보안 개선

구문

/sc:improve [--type quality|performance|maintainability] [--safe] [--preview] [--interactive] [--iterations N] "<대상 경로>"

매개변수

  • --type: : 개선 유형
    • quality
    • performance
    • maintainability
  • --safe: : 안전 모드, 모든 변경 사항은 테스트 검증 필요
  • --preview: : 미리보기 모드, 실제 파일 수정 없음
  • --interactive: : 각 개선사항을 대화식으로 확인
  • --iterations: : 반복 개선 횟수
예제 10.1: 성능 최적화
/sc:improve --type performance --safe "src/api/"
✨ 효과:
  • 성능 최적화
  • 안전 모드
  • 벤치마크 테스트
예제 10.2: 코드 품질
/sc:improve --type quality --preview "src/"
✨ 효과:
  • 품질 개선 미리보기
  • 실제 수정 없음
  • 개선 체크리스트
예제 10.3: 포괄적인 리팩토링
/sc:improve --type maintainability --interactive --iterations 3 --morph ""
✨ 효과:
  • 점진적 리팩토링
  • 3회 반복 라운드
  • 대화형 확인
  • Morphllm 일괄 리팩토링
  • 유지보수성 점수 향상

💡 실용적인 시나리오

코드 품질 개선
/sc:improve --type quality --safe "src/auth/legacy"
배경:
코드 품질 향상:

  • 레거시 인증 모듈이 기술 부채를 축적했음
  • 코드는 기능적이지만 유지보수 및 테스트가 어려움
  • 기존 기능을 깨뜨리지 않고 개선해야 함
  • 현대적인 모범 사례를 따르고 싶음
결과:
향상된 유지보수성 및 테스트 커버리지와 함께 코드 품질 개선이 완료되었습니다.
성능 최적화
/sc:improve --type performance --safe "src/api/products"
배경:
성능 개선:

  • API 응답 시간이 평균 800ms, 목표는 <200ms
  • 데이터베이스 쿼리가 비효율적임
  • 캐싱 계층이 구현되지 않음
  • React 컴포넌트가 불필요하게 재렌더링됨
결과:
측정 가능한 개선이 달성되어 성능 최적화가 적용되었습니다.
💡 모범 사례:
  • 개선 전 테스트 실행, 테스트 커버리지 확보
  • 대규모 개선은 단계별로 진행, --iterations로 반복 개선
  • 프로덕션 코드는 반드시 --safe 모드 사용
  • --preview를 사용하여 개선 효과를 미리 본 후 적용
  • 개선 후 성능 지표 비교, 긍정적 향상 확인
/sc:test - 테스트 실행
테스트 실행 및 커버리지 분석과 품질 보고서 생성

구문

/sc:test [--type unit|integration|e2e|all] [--coverage] [--watch] [--fix] [--parallel] [--concurrency N] [--validate] [대상]
예제 3.1: 단위 테스트
/sc:test --type unit --coverage "src/utils"
✨ 효과:
  • 단위 테스트 실행
  • 커버리지 보고서 생성
  • 빠른 실행
예제 3.2: 감시 모드
/sc:test --type unit --watch "src/"
✨ 효과:
  • 파일 변경 시 테스트 자동 재실행
  • 즉각적인 피드백
  • TDD 개발에 적합
예제 3.3: E2E 테스트 스위트
/sc:test --type e2e --fix --play --verbose ""
✨ 효과:
  • 엔드투엔드 테스트
  • 실패한 테스트 케이스 자동 수정
  • Playwright 브라우저 자동화
  • 상세한 로그 출력
예제 3.4: 완전한 테스트 파이프라인
/sc:test --type all --coverage --parallel --concurrency 4 --validate "."
✨ 효과:
  • 모든 테스트를 병렬로 실행
  • 4배 속도 향상
  • 완전한 커버리지 분석
  • 결과 검증 및 보고

💡 실용적인 시나리오

포괄적인 기능 테스트
/sc:test --type all --coverage --validate "src/auth"
배경:
기능 검증:

  • 사용자 인증 기능 구현을 막 완료함
  • 지정된 대로 모든 기능이 작동하는지 확인해야 함
  • 엣지 케이스 및 오류 시나리오를 테스트해야 함
  • 병합 전에 포괄적인 테스트 커버리지 필요
결과:
진행하기 전에 수정이 필요한 실패가 식별되었습니다.
리팩토링 후 회귀 테스트
/sc:test --type all --coverage --validate "src/payments"
배경:
리팩토링 검증:

  • 결제 처리 모듈의 주요 리팩토링을 막 완료함
  • 내부 구현을 변경했지만 API는 변경되지 않아야 함
  • 기존 기능이 손상되지 않았는지 확인해야 함
  • 하위 호환성을 확인해야 함
결과:
포괄적인 커버리지 보고서가 생성되어 모든 테스트가 통과했습니다. 코드 리뷰 준비 완료.
/sc:build - 프로젝트 빌드
프로젝트를 컴파일, 패키징하여 배포 준비, 다중 환경 설정 및 최적화 지원

구문

/sc:build [--type dev|prod] [--clean] [--optimize] [--validate] [--parallel]
예제 5.1: 개발 빌드
/sc:build --type dev --verbose "frontend/"
✨ 효과:
  • 개발 환경 빌드
  • 상세한 로그 출력
  • 빠른 핫 리로드
예제 5.2: 프로덕션 빌드
/sc:build --type prod --clean "."
✨ 효과:
  • 프로덕션 환경 최적화
  • 이전 빌드 정리
  • 압축 및 축소
예제 5.3: 최적화된 빌드 파이프라인
/sc:build --type prod --clean --optimize --validate --parallel "."
✨ 효과:
  • 완전 최적화 프로덕션 빌드
  • 병렬 빌드 작업
  • 빌드 결과 검증
  • 성능 분석 보고서
  • 트리 셰이킹 및 코드 분할
예제 5.4: 다중 환경 빌드
/sc:build --type all --environments "dev,staging,prod" --dockerize ""
✨ 효과:
  • 여러 환경을 동시에 빌드
  • Docker 이미지 생성
  • 환경별 구성
  • 배포 준비 완료

💡 실용적인 시나리오

최적화를 통한 프로덕션 빌드
/sc:build --type prod --optimize --validate --clean
배경:
프로덕션 배포 준비:

  • v2.0 프로덕션 릴리스 준비 중
  • 압축 및 트리 셰이킹을 통한 최적화된 빌드 필요
  • 모든 자산이 올바르게 번들링되었는지 확인해야 함
  • 프로덕션 문제 디버깅을 위한 소스맵 필요
결과:
최적화된 프로덕션 아티팩트가 생성되어 빌드가 성공적으로 완료되었습니다.
CI/CD 통합 빌드
/sc:build --type prod --optimize --validate --parallel --clean
배경:
지속적 통합 설정:

  • GitHub Actions에서 자동화된 빌드 파이프라인 설정
  • 환경 전체에서 일관되고 재현 가능한 빌드 필요
  • 빌드 전에 테스트 및 품질 검사를 실행해야 함
  • 배포 자동화를 위한 빌드 아티팩트 필요
결과:
최적화된 프로덕션 아티팩트가 생성되어 빌드가 성공적으로 완료되었습니다.
💡 모범 사례:
  • 프로덕션 빌드 전 테스트 실행, 코드 품질 확보
  • --clean으로 기존 파일 잔여물 방지
  • 개발 환경에서 --watch로 개발 효율성 향상
  • 빌드 크기 보고서 확인, 대형 종속성 식별
/sc:git - Git 작업
지능형 커밋 메시지와 워크플로우 최적화를 통한 Git 작업

구문

/sc:git [commit|merge|rebase|pr|flow] [--smart-commit] [--interactive] [--push] [--create-pr] [--squash] [--create] [--title " "] [--auto-description] [parameters]
예제 4.1: 스마트 커밋
/sc:git commit --smart-commit
✨ 효과:
  • 사양에 맞는 커밋 메시지 자동 생성
  • 코드 변경 내용 분석
  • Conventional Commits 따르기
예제 4.2: 대화형 병합
/sc:git merge --interactive ""
✨ 효과:
  • 스마트 충돌 해결
  • 단계별 병합 가이드
  • 모범 사례 제안 제공
예제 4.3: 완전한 Git 워크플로
/sc:git flow --smart-commit --push --create-pr ""
✨ 효과:
  • 브랜치 자동 생성
  • 스마트 커밋 메시지
  • 푸시 및 PR 생성
  • 변경 사항 요약 생성

💡 실용적인 시나리오

기능 개발 Git 워크플로
/sc:git flow --smart-commit --push --create-pr
배경:
기능 브랜치 관리:

  • 새로운 대시보드 분석 기능 작업 중
  • 개발 중 여러 커밋 생성
  • PR 전에 깔끔한 커밋 히스토리 생성 필요
  • 원격에 푸시하고 풀 리퀘스트 생성하고 싶음
결과:
프로젝트 규칙에 따라 변경사항이 커밋되고 코드 리뷰를 위해 제출되었습니다.
핫픽스 배포
/sc:git flow --smart-commit --push --create-pr --title "Hotfix: Payment callback race condition"
배경:
중요한 버그 수정:

  • 프로덕션 결제 처리 버그 발견
  • 프로덕션 브랜치에서 긴급 핫픽스 생성 필요
  • Git 모범 사례를 유지하면서 신속하게 수정 배포해야 함
  • 병합 전에 자동 테스트 필요
결과:
검증 및 롤백 계획이 문서화되어 핫픽스가 프로덕션에 배포되었습니다.
/sc:document - 문서 생성
코드, API 및 컴포넌트에 대한 명확하고 정확한 기술 문서 생성

구문

/sc:document [--type api|code|readme|guide] [--format markdown|html|jsdoc] [대상]
예제 13.1: 인라인 문서
/sc:document --type inline --style brief "utils.js"
✨ 효과:
  • 코드 주석 추가
  • 간결한 스타일
  • 빠른 생성
예제 13.2: API 문서
/sc:document --type api --style detailed "src/api/"
✨ 효과:
  • 완전한 API 문서
  • 매개변수 설명
  • 예제 코드
예제 13.3: 사용자 가이드
/sc:document --type guide --style detailed --format markdown --toc ""
✨ 효과:
  • 완전한 사용자 가이드
  • 목차 구조
  • 다이어그램 일러스트레이션
  • 모범 사례
  • 검색 친화적

💡 실용적인 시나리오

API 문서 생성
/sc:document --type api --format markdown "src/api/"
배경:
문서 필요성:

  • 백엔드 API에 포괄적인 문서가 부족함
  • 프론트엔드 팀이 엔드포인트 계약을 이해하는 데 어려움을 겪고 있음
  • 최신 API 참조 생성 필요
  • 요청/응답 예제 포함하고 싶음
결과:
포괄적인 엔드포인트 참조 및 예제와 함께 API 문서가 생성되었습니다.
컴포넌트 라이브러리 문서
/sc:document --type code --format markdown "src/components/"
배경:
컴포넌트 문서화:

  • 문서 없이 React 컴포넌트 라이브러리가 성장하고 있음
  • 개발자가 기존 컴포넌트를 사용하는 방법을 잘 모름
  • props, 사용 예제 및 모범 사례를 문서화해야 함
  • 대화형 컴포넌트 쇼케이스를 만들고 싶음
결과:
사용 예제 및 프롭 사양과 함께 컴포넌트 문서가 생성되었습니다.
💡 모범 사례:
  • 문서와 코드 동기화 업데이트
  • 풍부한 사용 예제 제공
  • API 문서에 완전한 요청/응답 예제 포함
  • 문서를 간결하고 이해하기 쉽게 유지, 과도한 기술성 피하기
/sc:cleanup - 코드 정리
코드베이스를 체계적으로 정리하고 데드 코드를 제거하며 프로젝트 구조 최적화

구문

/sc:cleanup [--type imports|code|all] [--safe] [--preview] [--aggressive] [--interactive] [--backup]

매개변수

  • --type: : 정리 유형
    • imports
    • code
    • all
  • --safe: : 안전 모드, 보수적 접근
  • --preview: : 미리보기 모드, 실제 수정 없음
  • --aggressive: : 공격적 모드(신중히 사용)
  • --interactive: : 각 정리 항목 개별 확인
  • --backup: : 자동 백업
예제 11.1: 임포트 정리
/sc:cleanup --type imports --safe "src/"
✨ 효과:
  • 사용하지 않는 임포트 정리
  • 보수적 처리
  • 빠른 실행
예제 11.2: 데드 코드 삭제
/sc:cleanup --type code --preview "."
✨ 효과:
  • 데드 코드 식별
  • 미리보기 모드
  • 정리 보고서
예제 11.3: 공격적 정리
/sc:cleanup --type all --aggressive --interactive --backup ""
✨ 효과:
  • 포괄적인 심층 정리
  • 공격적 모드(주의하여 사용)
  • 각 항목 확인
  • 자동 백업
  • 정리 통계 보고서

💡 실용적인 시나리오

레거시 코드 정리
/sc:cleanup --type code --safe --preview "src/"
배경:
코드 정리 요구사항:

  • 프로젝트에 사용되지 않는 코드와 더 이상 사용되지 않는 기능이 누적되어 있음
  • 데드 코드가 코드베이스 유지보수성에 영향을 미치고 있음
  • 더 이상 사용되지 않는 구성요소를 안전하게 제거해야 함
  • 활성 기능에 대한 중단 변경이 없도록 확인해야 함
결과:
기능 손실이 없음을 확인하는 검증 테스트와 함께 레거시 코드가 제거되었습니다.
종속성 정리 및 업데이트
/sc:cleanup --type all --safe --backup
배경:
종속성 관리:

  • Package.json에 오래되고 취약한 종속성이 있음
  • npm audit에서 여러 보안 취약점이 보고됨
  • 중단 변경 없이 패키지를 안전하게 업데이트해야 함
  • 사용되지 않는 종속성을 제거하고 싶음
결과:
사용되지 않는 코드가 제거되고 종속성이 업데이트되어 코드베이스 정리가 완료되었습니다.
💡 모범 사례:
  • 정기적으로 정리하여 기술 부채 축적 방지
  • 정리 전 테스트 실행, 기능 파괴되지 않도록 확인
  • 항상 --safe 모드로 백업 수행
  • 정리 후 애플리케이션이 정상 작동하는지 검증
/sc:troubleshoot - 문제 진단
코드 문제, 빌드 실패 및 런타임 오류를 체계적으로 진단하고 해결

구문

/sc:troubleshoot [--type bug|performance|build] [--trace] [--fix] [--safe-mode] "<문제 설명>"

매개변수

  • --type: : 문제 유형
    • bug
    • performance
    • build
  • --trace: : 심층 스택 추적 분석
  • --fix: : 자동 수정 시도
  • --safe-mode: : 안전 모드, 보수적 수정 전략 사용
예제 6.1: 성능 문제
/sc:troubleshoot --type performance --trace "API response slow"
✨ 효과:
  • 성능 문제 위치 파악
  • 플레임 그래프 생성
  • 병목 현상 식별
예제 6.2: 빌드 실패
/sc:troubleshoot --type build --fix
✨ 효과:
  • 빌드 문제 자동 감지
  • 자동 수정 시도
  • 솔루션 제공
예제 6.3: 프로덕션 환경 디버깅
/sc:troubleshoot --type bug --trace --fix --safe-mode --seq ""
✨ 효과:
  • 안전 모드 디버깅
  • 심층 스택 추적
  • Sequential 근본 원인 분석
  • 보수적 수정 전략
  • 성능 영향 평가

💡 실용적인 시나리오

프로덕션 API 장애 조사
/sc:troubleshoot --type bug --trace --fix --safe-mode "checkout API 500 errors"
배경:
중요한 프로덕션 문제:

  • 사용자가 체크아웃 API에서 500 오류를 보고함
  • 오류율이 정상 0.1%에서 갑자기 15%로 급증
  • 근본 원인을 신속하게 식별해야 함
  • 가능한 한 빨리 서비스를 복원해야 함
결과:
재발 방지를 위한 모니터링과 함께 근본 원인이 식별되고 수정이 구현되었습니다.
성능 저하 근본 원인 분석
/sc:troubleshoot --type performance --trace --fix "dashboard performance"
배경:
성능 문제 조사:

  • 지난 주 동안 대시보드 로딩 시간이 2초에서 8초로 증가
  • 최근 프론트엔드에 대한 코드 변경 없음
  • 사용자가 느린 경험에 대해 불평함
  • 무엇이 변경되었는지 찾아서 수정해야 함
결과:
최적화 권장사항이 적용되어 성능 문제가 진단되고 해결되었습니다.
💡 모범 사례:
  • 완전한 오류 정보 및 컨텍스트 제공
  • --trace를 사용하여 심층 스택 추적 분석 수행
  • 프로덕션 문제에는 --safe-mode를 사용하여 안전 확보
  • 수정 적용 후 문제 해결 확인
  • 진단 과정을 기록하여 문제 재발 방지
/sc:explain - 코드 설명
명확한 언어로 코드, 개념 및 시스템 동작 설명

구문

/sc:explain [--level beginner|intermediate|expert] [--focus logic|architecture|performance|security] [대상]
예제 1: 복잡한 함수 설명
/sc:explain --level intermediate --focus security @utils/encryption.js
✨ 효과:
  • 암호화 알고리즘 단계별 설명
  • 해당 방안을 선택한 이유 설명
  • 보안 핵심 포인트 지적
  • 매개변수 및 반환값 설명
예제 2: 아키텍처 설명
/sc:explain --level beginner --focus architecture "Microservices Architecture"
✨ 효과:
  • 간단한 언어로 마이크로서비스 개념 설명
  • 모놀리식 아키텍처와의 차이점 비교
  • 적용 시나리오 설명
  • 입문 예제 제공

💡 실용적인 시나리오

복잡한 알고리즘 설명
/sc:explain --level beginner "src/cache/lru-cache.ts"
배경:
학습 시나리오:

  • 프로젝트에 합류한 새로운 팀 구성원
  • 맞춤형 캐싱 알고리즘 이해에 어려움을 겪고 있음
  • 코드에 주석 및 문서가 부족함
  • 작동 방식에 대한 명확한 설명 필요
결과:
단계별 분석 및 시각적 예제와 함께 알고리즘 설명이 제공되었습니다.
아키텍처 패턴 설명
/sc:explain --level intermediate --focus architecture "Event sourcing pattern in payment service"
배경:
코드 검토 토론:

  • 팀이 마이크로서비스 이벤트 기반 아키텍처를 논의 중
  • 일부 개발자가 이벤트 소싱 패턴에 익숙하지 않음
  • 패턴과 사용 이유를 설명해야 함
  • 이점과 절충점을 보여주고 싶음
결과:
구현 가이드 및 모범 사례와 함께 아키텍처 패턴이 설명되었습니다.
💡 모범 사례:
  • 대상 청중에 맞는 적절한 --level 선택
  • 설명 요청 시 구체적인 컨텍스트 제공
  • --focus를 사용하여 관심 분야에 집중
  • 설명 후 질문을 통해 심층 이해
/sc:business-panel - 비즈니스 전문가 패널
적응형 상호작용 모드를 갖춘 다중 전문가 비즈니스 분석

구문

/sc:business-panel [--mode discussion|debate|socratic] [--experts "expert1,expert2"] [--focus domain] [document]
예제: 혁신 평가
/sc:business-panel --mode discussion --focus strategy "SaaS pricing model evaluation"
✨ 효과:
  • Christensen의 jobs-to-be-done(과업 이론) 분석
  • Drucker의 고객 가치 관점
  • Godin의 시장 진출 전략

💡 실용적인 시나리오

제품 전략 검토
/sc:business-panel --mode sequential "SaaS project management tool - freemium vs paid subscription strategy"
배경:
전략 계획:

  • 프로젝트 관리를 위한 새로운 SaaS 제품 출시
  • 시장 포지셔닝 및 가격 전략을 검증해야 함
  • 프리미엄 vs 구독 모델 평가
  • 시장 진출 접근 방식에 대한 전문가 지침 필요
결과:
시장 포지셔닝 및 출시 전략 권장사항과 함께 비즈니스 전략 전문가 패널이 완료되었습니다.
비즈니스 모델 피벗 평가
/sc:business-panel --mode debate "Pivot from B2C to B2B enterprise model"
배경:
피벗 결정:

  • 현재 B2C 모델이 성장 목표를 달성하지 못하고 있음
  • B2B 기업 영업으로의 피벗 고려
  • 타당성 및 위험 평가 필요
  • 장단점에 대한 구조화된 토론 필요
결과:
피벗 의사결정 프레임워크 및 위험 평가와 함께 비즈니스 모델 분석이 완료되었습니다.
/sc:estimate - 개발 추정
작업, 기능 또는 프로젝트의 개발 시간 및 리소스 추정 제공

구문

/sc:estimate [--detail brief|standard|comprehensive] [--team-size N] [--complexity auto|low|medium|high] [작업 설명]
예제 14.1: 시간 추정
/sc:estimate --type time --unit hours "Implement login functionality"
✨ 효과:
  • 작업 시간 추정
  • 시간 단위로 정확하게
  • 버퍼 시간 포함
예제 14.2: 복잡도 평가
/sc:estimate --type complexity "Microservice decomposition"
✨ 효과:
  • 기술적 복잡도
  • 위험 평가
  • 난이도 수준
예제 14.3: 상세한 프로젝트 추정
/sc:estimate --type effort --unit days --breakdown --team-size 5 ""
✨ 효과:
  • 완전한 노력 분해
  • 팀 규모 고려
  • 작업 종속성
  • 번다운 차트 예측
  • 비용 추정

💡 실용적인 시나리오

기능 개발 추정
/sc:estimate --type time --unit days --breakdown --team-size 3 "Analytics dashboard with charts, filters, CSV export"
배경:
스프린트 계획:

  • 제품 관리자가 새로운 분석 대시보드에 대한 추정 요청
  • 기능에는 데이터 시각화, 필터링 및 내보내기 기능이 포함됨
  • 스프린트 계획을 위한 현실적인 일정 제공 필요
  • 3명의 개발자가 사용 가능함
결과:
일정 및 리소스 요구사항이 정의되어 개발 노력이 추정되었습니다.
기술 부채 리팩토링 추정
/sc:estimate --type time --unit days --breakdown "Refactor authentication system to modern architecture"
배경:
리팩토링 계획:

  • 레거시 인증 시스템 리팩토링 필요
  • 현재 코드는 유지보수 및 테스트가 어려움
  • 하위 호환성을 유지해야 함
  • 리소스를 투입하기 전에 현실적인 추정 필요
결과:
단계적 접근 방식 및 일정이 정의되어 리팩토링 노력이 추정되었습니다.
💡 모범 사례:
  • 정확성을 높이기 위해 상세한 기능 설명 제공
  • 팀 경험을 고려하여 추정 조정
  • 20-30%의 버퍼 시간 확보
  • 과거 데이터를 사용하여 추정 모델 보정
/sc:spec-panel - 사양 검토
저명한 사양 및 소프트웨어 엔지니어링 전문가를 활용한 다중 전문가 사양 검토 및 개선

구문

/sc:spec-panel @spec-document [--mode review|critique|improve] [--focus clarity|completeness|feasibility]
예제: API 사양 검토
/sc:spec-panel --mode improve --focus completeness @specs/api-design.md
✨ 효과:
  • 전문가 패널 검토(아키텍트, 기술 작가 전문가)
  • 누락된 엔드포인트 및 매개변수 식별
  • 불완전한 오류 처리 지적
  • 개선 제안 및 예제 제공
  • 더 완전한 사양 버전 생성

💡 실용적인 시나리오

API 사양 검토
/sc:spec-panel --mode improve --focus completeness "docs/api-spec.yaml"
배경:
사양 검토:

  • 마이크로서비스를 위한 새로운 REST API 사양 초안 작성
  • 모범 사례 및 잠재적 문제에 대한 전문가 검토 필요
  • 확장성 및 유지보수성 보장하고 싶음
  • 명명 규칙 및 구조에 대한 피드백 필요
결과:
실행 가능한 권장사항 및 구현 우선순위가 설정되어 전문가 패널 리뷰가 완료되었습니다.
데이터베이스 스키마 검토
/sc:spec-panel --mode critique --focus feasibility "schemas/ecommerce.sql"
배경:
스키마 검증:

  • 전자상거래 플랫폼을 위한 데이터베이스 스키마 설계
  • 사용자, 제품, 주문, 결제 테이블 포함
  • 정규화 및 성능에 대한 전문가 검증 필요
  • 잠재적인 확장 문제를 식별하고 싶음
결과:
최적화 제안 및 모범 사례가 문서화되어 전문가가 데이터베이스 스키마를 검토했습니다.
💡 모범 사례:
  • 사양 초안 완성 후 즉시 검토
  • critique 모드를 사용하여 숨겨진 문제 발견
  • 검토 후 제안에 따라 사양 수정
  • 품질 표준에 도달할 때까지 반복 검토
/sc:index - 프로젝트 인덱스
포괄적인 프로젝트 문서 및 지식 베이스 인덱스 생성, 프로젝트 정보 지능적 구성

구문

/sc:index [--type codebase|docs|all] [--depth shallow|deep] [--output markdown|json|html]
예제: 코드베이스 인덱스
/sc:index --type codebase --depth deep --output markdown
✨ 효과:
  • 전체 코드베이스 스캔
  • 디렉토리 구조 트리 생성
  • 모든 모듈 및 종속성 나열
  • 주요 함수 및 클래스 추출
  • PROJECT_INDEX.md 생성

💡 실용적인 시나리오

프로젝트 지식 베이스 인덱싱
/sc:index --type codebase --depth shallow --output markdown
배경:
새로운 직원이 프로젝트를 빠르게 이해해야 하며, 포괄적인 코드 인덱스를 구축합니다.
결과:
빠른 의미론적 검색 및 탐색을 위해 프로젝트 지식 베이스가 색인되었습니다.
증분 인덱스 업데이트
/sc:index --type docs --depth deep --output json
배경:
프로젝트가 자주 업데이트되며, 최신 상태를 유지하기 위해 정기적으로 인덱스를 업데이트해야 합니다.
결과:
향상된 검색 정확도를 위해 최근 변경사항이 통합되어 인덱스가 업데이트되었습니다.
특정 모듈 인덱싱
/sc:index --type all --depth shallow --output html
배경:
결제 리팩토링, 관련 코드만 인덱싱하면 됩니다.
결과:
의존성 그래프 및 문서가 검토 준비되어 모듈 인덱스가 생성되었습니다.
💡 모범 사례:
  • 새 프로젝트 참여 시 먼저 인덱스 실행
  • 정기적으로 인덱스 업데이트하여 동기화 유지
  • 인덱스를 사용하여 대규모 프로젝트 빠르게 탐색
  • 인덱스를 신규 멤버의 온보딩 문서로 활용

🤖 전문 에이전트

전문 에이전트란?

SuperClaude 프레임워크에는 15개의 전문 에이전트가 내장되어 있으며, 각 에이전트는 특정 영역에서 깊은 전문 지식을 보유하고 있습니다. 에이전트는 자동으로 활성화되거나 플래그 매개변수를 통해 수동으로 지정할 수 있습니다.

🎨 프론트엔드 개발 에이전트

frontend-architect
접근 가능하고 고성능인 사용자 인터페이스 생성, 사용자 경험과 최신 프레임워크에 집중

전문 분야:

  • React, Vue, Angular와 같은 최신 프레임워크
  • 반응형 디자인 및 모바일 최적화
  • 웹 접근성 (WCAG 2.1)
  • 성능 최적화 및 코드 분할

⚙️ 백엔드 개발 에이전트

backend-architect
데이터 무결성, 보안 및 내결함성에 집중한 신뢰할 수 있는 백엔드 시스템 설계

전문 분야:

  • RESTful 및 GraphQL API 설계
  • 데이터베이스 아키텍처 및 최적화
  • 인증 및 권한 부여
  • 마이크로서비스 아키텍처

🏗️ 시스템 아키텍처 에이전트

system-architect
유지 관리 가능성과 장기 기술 결정에 집중한 확장 가능한 시스템 아키텍처 설계

전문 분야:

  • 시스템 설계 패턴
  • 확장성 아키텍처
  • 기술 선택
  • 아키텍처 문서

🐍 Python 전문가 에이전트

python-expert
SOLID 원칙을 따르는 프로덕션 준비, 안전, 고성능 Python 코드 제공

전문 분야:

  • Python 모범 사례
  • FastAPI, Django, Flask
  • 데이터 처리 및 분석
  • 비동기 프로그래밍

🚀 DevOps 에이전트

devops-architect
신뢰성과 관찰 가능성에 집중한 인프라 및 배포 프로세스 자동화

전문 분야:

  • CI/CD 파이프라인
  • Docker 및 Kubernetes
  • 모니터링 및 로깅
  • Infrastructure as Code

🔧 리팩토링 전문가 에이전트

refactoring-expert
체계적인 리팩토링과 깔끔한 코드 원칙을 통해 코드 품질 향상 및 기술 부채 감소

전문 분야:

  • 코드 스멜 식별
  • 리팩토링 패턴
  • 코드 품질 메트릭
  • 기술 부채 관리

🎓 기타 전문 에이전트

SuperClaude에는 다음 전문 에이전트도 포함되어 있습니다:

security-engineer
보안 취약점 식별 및 규정 준수
quality-engineer
포괄적인 테스트 전략
performance-engineer
성능 최적화
learning-guide
프로그래밍 교육
root-cause-analyst
근본 원인 분석
requirements-analyst
요구사항 발견
technical-writer
기술 문서
socratic-mentor
소크라테스식 교수법
business-panel-experts
비즈니스 전략 패널 (9명의 전문가)

🚩 플래그 매개변수 참조

플래그 매개변수를 사용하여 명령 동작을 사용자 정의할 수 있습니다. 사용 가능한 모든 플래그는 다음과 같습니다:

⚡ 모드 활성화 플래그

이 플래그는 특정 작업 모드를 활성화하여 AI 기능과 상호 작용 방법을 향상시킵니다

플래그설명토큰 비용적용 명령
--brainstorm소크라테스식 대화를 통해 요구사항을 탐색하는 협력적 발견 사고 모드 활성화+2-3K모든 명령어
--introspect사고 프로세스 투명성 표시, AI가 추론 단계를 보여줌+1-2K모든 명령어
--task-manage다단계 작업 관리 활성화, 복잡한 작업을 자동으로 추적 및 구성+1K모든 명령어
--orchestrate다중 도구 병렬 실행 활성화, 여러 MCP 서버 및 도구 조정+3-5K모든 명령어
--token-efficient토큰 최적화 모드 활성화, 품질 유지하면서 토큰 소비 감소-30-50%모든 명령어
--plan계획 모드 활성화, 실행 전 상세 계획 생성표준implement, design, refactor
--validate검증 모드 활성화, 출력 및 결과 자동 검증표준implement, test, build
--parallel병렬 실행 활성화, 여러 작업 동시 처리표준test, analyze, research
--interactive대화형 모드 활성화, 단계별 확인 및 조정표준brainstorm, design

🔍 분석 깊이 플래그

AI의 분석 깊이를 제어하여 속도와 세부 사항의 균형 조정

플래그토큰 비용설명시나리오
--think~4K표준 분석 깊이, 일반 개발 작업에 적합일상 개발
--think-hard~10K다각적인 사고와 검증을 포함한 심층 분석복잡한 문제
--ultrathink~32K모든 가능성을 고갈시키는 최대 깊이 분석중요한 결정
--depth shallow낮음빠른 개요, 시간이 부족한 상황에 적합빠른 확인
--depth normal표준속도와 세부 사항의 균형 (기본값)일반 분석
--depth deep높음복잡한 시나리오를 위한 포괄적이고 심층적인 분석상세한 평가

🔌 MCP 서버 제어

전문 기능을 위해 MCP 서버를 선택적으로 활성화

플래그별칭서버용도
--c7--context7Context7프레임워크 문서 쿼리, 공식 최신 문서 및 모범 사례 가져오기
--seq--sequentialSequential복잡한 추론 분석, 다단계 체계적 사고
--magic--magicMagic21st.dev 최신 컴포넌트 라이브러리 기반 UI 컴포넌트 생성
--morph--morphllmMorphllm일괄 코드 편집, 패턴 기반 빠른 수정
--serena--serenaSerena프로젝트 메모리 관리, 의미론적 코드 이해 및 세션 지속성
--play--playwrightPlaywright브라우저 자동화 테스트, E2E 테스트 및 UI 검증

⚙️ 실행 제어 플래그

명령 실행 방법 및 동작 제어

플래그설명예제
--dry-run실제 변경 없이 실행 시뮬레이션/sc:implement --dry-run
--force강제 실행, 확인 프롬프트 건너뛰기/sc:cleanup --force
--auto-commit변경 사항을 Git에 자동으로 커밋/sc:implement --auto-commit
--no-test테스트 단계 건너뛰기/sc:build --no-test

💡 조합 사용 예제

플래그를 조합하여 더 강력한 기능을 실현할 수 있습니다:

  • /sc:analyze --think-hard --serena --c7 "src/api"
    심층 사고, 프로젝트 메모리, 공식 문서를 사용하여 API 코드 분석
  • /sc:implement --brainstorm --plan --validate "사용자 인증"
    협력하여 요구사항 탐색, 구현 계획 및 결과 검증
  • /sc:improve --token-efficient --morph --dry-run "src/"
    토큰 최적화 및 일괄 편집 도구를 사용하여 코드 개선 미리보기

💡 실용적인 팁

다음은 실제 개발 시나리오와 권장 명령어 조합입니다:

📦 처음부터 새 기능 개발
/sc:brainstorm "사용자 인증 기능" --depth deep
/sc:design --think
/sc:implement --plan --validate
/sc:test --parallel
/sc:document
/sc:git "feat: 사용자 인증 추가"

워크플로 설명:

  1. 요구사항 탐색: 기능 범위 및 기술 방법 명확화
  2. 시스템 설계: 인증 흐름 및 데이터 모델 설계
  3. 기능 구현: 코드 작성 및 검증
  4. 테스트 검증: 테스트 스위트 병렬 실행
  5. 문서 생성: API 문서 자동 생성
  6. 코드 커밋: 표준 Git 커밋 생성
🐛 긴급 버그 수정 프로세스
/sc:troubleshoot --depth deep
/sc:analyze --focus security
/sc:implement --validate
/sc:test --parallel
/sc:git "fix: 인증 우회 해결"
🔧 코드 리팩토링 및 성능 최적화
/sc:analyze --depth deep
/sc:improve --plan
/sc:test --validate
/sc:cleanup
🎨 React 컴포넌트 개발
/sc:design "사용자 프로필 카드 컴포넌트"
/sc:implement --persona frontend-architect
/sc:test --focus accessibility
/sc:document

🎓 학습 자료

공식 문서

커뮤니티 자료

💡 팁:

문제가 있나요? FAQ 를 확인하거나 GitHub에 Issue를 제출하세요.