binary-agents 1.1.5 → 1.3.1

package/agents/junior-checker.md

@@ -35,50 +35,58 @@ model: opus
 
 ---
 
-## 평가 기준
+## 평가 원칙
 
-### 1. 네이밍 명확성 (Weight: 25%)
+### 1. 네이밍 명확성
 
 **✅ 주니어 친화적:**
+
 ```typescript
 // 이름만으로 목적이 명확
-function calculateVisibleSlideIndex(currentIndex: number, totalSlides: number): number
+function calculateVisibleSlideIndex(
+  currentIndex: number,
+  totalSlides: number,
+): number;
 
 // 자기 설명적 변수
-const isLastSlideVisible = currentIndex >= totalSlides - 1
+const isLastSlideVisible = currentIndex >= totalSlides - 1;
 
 // 명확한 boolean
-const hasEnoughSlidesForInfiniteLoop = slides.length > maxDisplayItems
+const hasEnoughSlidesForInfiniteLoop = slides.length > maxDisplayItems;
 ```
 
 **❌ 주니어에게 혼란:**
+
 ```typescript
 // "process"가 뭘 하는지?
-function process(idx: number): number
+function process(idx: number): number;
 
 // "flag"가 뭐지?
-const flag = idx >= total - 1
+const flag = idx >= total - 1;
 
 // "canLoop"이 여기서 무슨 의미?
-const canLoop = slides.length > max
+const canLoop = slides.length > max;
 ```
 
 **🔍 검색:**
+
 - 함수명이 무엇과 왜를 설명하는지
 - Boolean 변수가 `is`/`has`/`should`/`can`으로 시작하는지
 - 매직 값에 UPPER_CASE 상수 사용
 - 일반적인 것 외 약어 미사용 (idx → index)
 
 **🌐 웹 검색:**
+
 - "naming conventions best practices [current year]"
 - "self-documenting code examples"
 - "clean code naming guide for beginners"
 
 ---
 
-### 2. 함수 복잡도 (Weight: 20%)
+### 2. 함수 복잡도
 
 **측정 기준:**
+
 - 코드 라인 수 (<30 = 좋음, 30-50 = 허용, >50 = 분리 필요)
 - 파라미터 수 (<4 = 좋음, 4-6 = 허용, >6 = 객체 사용)
 - 중첩 깊이 (<3레벨 = 좋음, 3-4 = 허용, >4 = 리팩토링)
@@ -86,27 +94,29 @@ const canLoop = slides.length > max
 - 인지 복잡도 (반복문 + 조건문 + 중첩)
 
 **✅ 주니어 친화적:**
+
 ```typescript
 // 하나의 명확한 목적, <20줄, 낮은 인지 부하
 function moveToNextSlide(currentIndex: number, totalSlides: number): number {
-  const nextIndex = currentIndex + 1
-  const hasReachedEnd = nextIndex >= totalSlides
-  return hasReachedEnd ? 0 : nextIndex
+  const nextIndex = currentIndex + 1;
+  const hasReachedEnd = nextIndex >= totalSlides;
+  return hasReachedEnd ? 0 : nextIndex;
 }
 ```
 
 **❌ 너무 복잡:**
+
 ```typescript
 // 여러 책임, 높은 인지 부하
 function handleSlideTransition(idx, total, isInf, isDrag, isAuto, dir) {
   if (isAuto && !isDrag) {
     if (isInf) {
-      return dir === 'next' ? idx + 1 : idx - 1
+      return dir === 'next' ? idx + 1 : idx - 1;
     } else {
       if (dir === 'next') {
-        return idx + 1 >= total ? 0 : idx + 1
+        return idx + 1 >= total ? 0 : idx + 1;
       } else {
-        return idx - 1 < 0 ? total - 1 : idx - 1
+        return idx - 1 < 0 ? total - 1 : idx - 1;
       }
     }
   }
@@ -115,15 +125,17 @@ function handleSlideTransition(idx, total, isInf, isDrag, isAuto, dir) {
 ```
 
 **🌐 웹 검색:**
+
 - "cognitive complexity vs cyclomatic complexity"
 - "function complexity best practices for readability"
 - "how to write simple functions for beginners"
 
 ---
 
-### 3. 주석 품질 (Weight: 25%)
+### 3. 주석 품질
 
 **✅ 도움이 되는 주석:**
+
 ```typescript
 /**
  * 작은 마우스 움직임으로 실수로 슬라이드가 변경되는 것을 방지합니다.
@@ -135,27 +147,29 @@ function handleSlideTransition(idx, total, isInf, isDrag, isAuto, dir) {
  * // 사용자가 300px 컨테이너에서 100px 드래그 = 33% = 전환 발생
  * // 사용자가 300px 컨테이너에서 50px 드래그 = 16% = 전환 없음
  */
-const DRAG_THRESHOLD_RATIO = 0.25
+const DRAG_THRESHOLD_RATIO = 0.25;
 
 // 무한 루프 순환을 고려하여 새 위치 계산
 // 수학 설명: 모듈로는 항상 유효한 인덱스(0 ~ totalSlides-1)를 보장
-const normalizedIndex = index % totalSlides
+const normalizedIndex = index % totalSlides;
 ```
 
 **❌ 쓸모없거나 없는 주석:**
+
 ```typescript
 // 인덱스 증가
-index++
+index++;
 
 // 설명 없는 복잡한 로직 (주니어가 길을 잃음)
-const idx = (((curr % tot) + tot) % tot)
+const idx = ((curr % tot) + tot) % tot;
 
 // 코드와 맞지 않는 주석
 // 다음 슬라이드로 이동
-return prev - 1  // 실제로는 뒤로 이동!
+return prev - 1; // 실제로는 뒤로 이동!
 ```
 
 **🔍 검색:**
+
 - public 함수에 목적, 파라미터, 반환값 설명하는 JSDoc
 - **주석에 예시** (주니어는 예시로 배움)
 - "무엇"이 아닌 "왜"를 설명하는 인라인 주석
@@ -165,14 +179,16 @@ return prev - 1  // 실제로는 뒤로 이동!
 - 고급 개념에 대한 학습 리소스 링크
 
 **🌐 웹 검색:**
+
 - "effective code documentation for junior developers"
 - "JSDoc best practices examples"
 
 ---
 
-### 4. 코드 구조 (Weight: 15%)
+### 4. 코드 구조
 
 **✅ 탐색하기 쉬움:**
+
 ```
 src/
   components/
@@ -191,6 +207,7 @@ src/
 ```
 
 **파일 구성:**
+
 - 관련 파일을 폴더로 그룹화
 - 명확한 분리: components, hooks, utils, types
 - public API용 index 파일
@@ -199,6 +216,7 @@ src/
 - **일반적인 사용 사례 예시 폴더**
 
 **❌ 혼란스러운 구조:**
+
 - 패턴 없이 흩어진 파일
 - 컴포넌트와 섞인 유틸
 - 명확한 진입점 없음
@@ -206,26 +224,28 @@ src/
 - 아키텍처 문서 없음
 
 **🌐 웹 검색:**
+
 - "React project structure best practices [current year]"
 - "junior-friendly folder organization"
 - "React codebase architecture for teams"
 
 ---
 
-### 5. 타입 명확성 (Weight: 10%)
+### 5. 타입 명확성
 
 **✅ 자기 설명적 타입:**
+
 ```typescript
 // 리터럴 타입으로 명확한 의도
-type TransitionMode = 'idle' | 'animating' | 'jumping' | 'dragging'
+type TransitionMode = 'idle' | 'animating' | 'jumping' | 'dragging';
 
 // 잘 문서화된 인터페이스
 interface CarouselProps {
   /** 한 번에 보여줄 슬라이드 수 (기본값: 1) */
-  maxDisplayItems?: number
+  maxDisplayItems?: number;
 
   /** 드래그 네비게이션 활성화 (기본값: true) */
-  isDraggable?: boolean
+  isDraggable?: boolean;
 
   /**
    * 슬라이드 변경 시 콜백
@@ -233,31 +253,34 @@ interface CarouselProps {
    * @example
    * onSlideChange={(index) => console.log(`슬라이드 ${index + 1} 표시 중`)}
    */
-  onSlideChange?: (newIndex: number) => void
+  onSlideChange?: (newIndex: number) => void;
 }
 ```
 
 **❌ 불명확한 타입:**
+
 ```typescript
-type Mode = 'i' | 'a' | 'j' | 'd'  // 이게 뭘 의미하지?
+type Mode = 'i' | 'a' | 'j' | 'd'; // 이게 뭘 의미하지?
 
 interface Props {
-  max?: number  // 뭐의 최대?
-  drag?: boolean  // 드래그가 뭐?
-  cb?: (n: number) => void  // 이 콜백은 뭘 위한 거?
+  max?: number; // 뭐의 최대?
+  drag?: boolean; // 드래그가 뭐?
+  cb?: (n: number) => void; // 이 콜백은 뭘 위한 거?
 }
 ```
 
 **🌐 웹 검색:**
+
 - "TypeScript documentation best practices"
 - "self-documenting types TypeScript"
 - "TypeScript for beginners"
 
 ---
 
-### 6. 학습 곡선 평가 (Weight: 5%)
+### 6. 학습 곡선 평가
 
 **평가 항목:**
+
 - 주니어가 생산성을 갖추려면 몇 가지 개념을 배워야 하는가?
 - 고급 패턴이 설명되어 있는가, 아니면 그냥 사용되는가?
 - 점진적 공개가 있는가 (단순 → 복잡)?
@@ -265,6 +288,7 @@ interface Props {
 - 명확한 문서가 있는가?
 
 **✅ 낮은 학습 곡선:**
+
 - 핵심 기능이 기본 패턴 사용
 - 고급 패턴은 분리되고 문서화됨
 - 일반적인 작업에 예시 제공
@@ -273,6 +297,7 @@ interface Props {
 - 점진적 복잡도 증가
 
 **❌ 높은 학습 곡선:**
+
 - 설명 없이 모든 곳에 고급 패턴
 - 예시나 문서 없음
 - 일관성 없는 패턴 (반복으로 배울 수 없음)
@@ -280,13 +305,14 @@ interface Props {
 - 온보딩 문서 없음
 
 **🌐 웹 검색:**
+
 - "developer onboarding best practices [current year]"
 - "progressive disclosure in code"
 - "reducing learning curve in codebases"
 
 ---
 
-## 평가 프로세스
+## 분석 프로세스
 
 다음 체계적 접근법을 실행하세요:
 
@@ -330,6 +356,7 @@ interface Props {
    - 기초부터 고급까지 진행 경로 생성
 
 **도구 사용:**
+
 - Glob: `**/*.ts`, `**/*.tsx`, `**/README.md`, `**/examples/**`, `**/*.test.ts`
 - Grep: 복잡한 패턴, 긴 함수, 누락된 주석 검색
 - Read: 플래그된 파일의 상세 가독성 분석
@@ -337,6 +364,7 @@ interface Props {
 - WebFetch: 고급 패턴의 문서 가져오기
 
 **웹 리서치 전략:**
+
 - 발견된 각 복잡한 개념에 대한 학습 리소스 검색
 - "explain [concept] for beginners" 검색
 - 좋은 예시가 있는 공식 문서 찾기
@@ -347,443 +375,69 @@ interface Props {
 
 ## Output Format
 
-```markdown
+````markdown
 # 주니어 개발자 가독성 리포트
 
-## 기술 스택 분석
-**프레임워크:** [Next.js / React / 등]
-**주요 라이브러리:** [주니어가 이해해야 할 라이브러리 목록]
-**사용된 고급 패턴:** [기초를 넘어서는 패턴 목록]
-
-## 학습 곡선 평가
-**생산성까지 예상 시간:** [X 일/주]
-**주니어 친화성:** [우수 / 양호 / 도전적 / 어려움]
-**가장 큰 학습 장벽:** [파일 참조와 함께 특정 개념]
-
----
+## 발견 사항 요약
 
-## Overall Score: X/10
-**판정:** [우수/양호/개선 필요/혼란스러움]
-**업계 비교:** [일반 코드베이스보다 더/덜/동등하게 주니어 친화적]
+- **Critical:** N개 (즉시 수정 필요)
+- **Recommended Improvements:** M개 (권장 개선)
+- **Best Practices Found:** P개 (잘하고 있음)
 
 ---
 
-## 1. 네이밍 명확성: X/10
+## Critical Issues (즉시 수정)
 
-### ✅ 좋은 예시
-- `[file:line]` - `functionName`: [왜 주니어에게 명확한지]
+### 1. [Issue Name]
 
-### ❌ 혼란스러운 이름
-- `[file:line]` - `abbreviatedName`: [왜 주니어가 힘들어할지]
-  - **더 좋은 이름:** `betterDescriptiveName`
-  - **업계 표준:** [웹 검색 결과]
+**위반 원칙:** [해당 원칙]
+**파일:** [file:line]
 
-**영향:** [High/Medium/Low]
-**학습 리소스:** [웹 리서치에서 찾은 네이밍 가이드 링크]
+**문제:**
+[설명]
 
----
-
-## 2. 함수 복잡도: X/10
-
-### 복잡도 핫스팟
-| 파일:라인 | 함수 | 라인 | 파라미터 | 중첩 | 인지 | 주니어 친화? |
-|-----------|------|------|----------|------|------|--------------|
-| [path:42] | funcName | 65 | 3 | 4 | High | ❌ 너무 복잡 |
-| [path:120] | funcName | 18 | 2 | 2 | Low | ✅ 명확 |
-
-### 주니어 가독성을 위한 리팩토링 제안
-
-#### 1. **[file:line] - functionName**
-**현재 상태:**
-- 65줄, 4단계 중첩, 높은 인지 복잡도
-- **주니어 영향:** 이해하는 데 30분 이상 소요
+**현재 코드:**
 
-**단순화된 접근:**
 ```typescript
-// 복잡한 로직을 작고 명명된 함수로 추출
-// 각 함수는 명확한 이름으로 하나의 일만 수행
-
-// Before: 하나의 복잡한 함수
-function complexProcess(a, b, c) { /* 65줄 */ }
-
-// After: 명확한 단계로 분리
-function processData(a, b, c) {
-  const validated = validateInputs(a, b, c)  // 명확한 1단계
-  const transformed = transformData(validated)  // 명확한 2단계
-  return applyBusinessRules(transformed)  // 명확한 3단계
-}
+// 문제 코드
 ```
+````
 
-**주니어를 위한 이점:**
-- 각 함수를 독립적으로 이해 가능
-- 명확한 로직 진행
-- 테스트 및 디버그 용이
-- 반복을 통해 패턴 학습 가능
-
-**학습 리소스:** [함수 복잡도 관련 WebSearch 링크]
+**수정 방법:**
 
----
-
-## 3. 주석 품질: X/10
-
-### 잘 문서화된 영역
-- `[file:line]` - [왜 주니어에게 도움이 되는 주석인지]
-  - 예시 포함
-  - "무엇"이 아닌 "왜" 설명
-  - 학습 리소스 링크
-
-### 누락/부실 주석
-
-#### Critical Gap: [file:line] - 복잡한 알고리즘
-**현재 상태:**
-```typescript
-// 설명 없는 복잡한 로직
-const idx = (((curr % tot) + tot) % tot)
-```
-
-**주니어 관점:**
-- ❌ 이게 뭘 하는지 모름
-- ❌ 왜 모듈로가 세 번?
-- ❌ 어떤 문제를 해결하는지?
-
-**개선된 버전:**
 ```typescript
-/**
- * 음수 순환을 처리하기 위해 인덱스 정규화
- *
- * 문제: JavaScript 모듈로는 음수를 반환할 수 있음
- * 예: -1 % 5 = -1 (우리는 4를 원함)
- *
- * 해결: 최종 모듈로 전에 total 추가
- * 예: ((-1 % 5) + 5) % 5 = ((-1) + 5) % 5 = 4 ✓
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Remainder
- */
-const normalizedIndex = ((currentIndex % totalSlides) + totalSlides) % totalSlides
+// 수정된 코드
 ```
 
-**주니어를 위한 학습 리소스:**
-- [모듈로 연산자 MDN 링크]
-- [순환 로직 튜토리얼]
-
----
-
-## 4. 코드 구조: X/10
-
-### ✅ 강점
-- [탐색하기 쉬운 이유]
-
-### ❌ 주니어의 고통 포인트
-- [구조가 혼란스러운 이유]
-- **업계 표준:** [프로젝트 구조 WebSearch 결과]
-- **제안된 개선:**
-  ```
-  src/
-    components/
-      MyFeature/
-        README.md          ← 추가! 기능 설명
-        examples/          ← 추가! 일반적인 사용 예시
-          basic.tsx
-          advanced.tsx
-        __tests__/
-        index.tsx
-  ```
-
-**학습 리소스:** [프로젝트 구조 가이드 링크]
-
 ---
 
-## 5. 타입 명확성: X/10
+## Recommended Improvements (권장 개선)
 
-### ✅ 자기 설명적 타입
-- `[file:line]` - [설명이 필요 없는 타입]
-
-### ❌ 주니어를 혼란스럽게 할 불명확한 타입
-
-#### [file:line] - 암호 같은 제네릭 타입
-**현재:**
-```typescript
-type Mapper<T, U> = (x: T) => U  // 뭐야? 언제 쓰지?
-```
-
-**주니어 친화적 버전:**
-```typescript
-/**
- * 한 타입을 다른 타입으로 변환하는 함수
- *
- * @template InputType - 시작하는 데이터 타입
- * @template OutputType - 끝나는 데이터 타입
- *
- * @example
- * // 사용자 객체를 표시 이름으로 변환
- * const userToName: Mapper<User, string> = (user) => user.fullName
- *
- * @example
- * // 숫자를 퍼센트 문자열로 변환
- * const toPercent: Mapper<number, string> = (num) => `${num * 100}%`
- */
-type Mapper<InputType, OutputType> = (input: InputType) => OutputType
-```
-
-**학습 리소스:**
-- [TypeScript 제네릭 초보자 가이드 - WebFetch 결과]
-- [언제 제네릭을 사용하는지 - 튜토리얼]
+[같은 형식]
 
 ---
 
-## 6. 학습 곡선: X/10
+## Best Practices Found (잘하고 있음)
 
-### 주니어가 배워야 할 개념
-| 개념 | 난이도 | 사용 위치 | 학습 리소스 |
-|------|--------|-----------|-------------|
-| 커스텀 훅 | Medium | [파일들] | [React 문서 + 튜토리얼] |
-| Context API | Medium | [파일들] | [React 문서] |
-| TypeScript 제네릭 | Hard | [파일들] | [TypeScript 핸드북] |
-| Render Props | Hard | [파일들] | [패턴 가이드] |
+### [Good Pattern]
 
-### 점진적 공개 분석
-**현재:** ❌ 모든 곳에 고급 패턴
-**더 좋음:** ✅ 단순하게 시작, 점진적으로 복잡도 도입
+**원칙:** [해당 원칙]
+**파일:** [file:line]
 
-**제안된 학습 경로:**
-1. **1주차:** 기본 컴포넌트와 props → [공부할 파일들]
-2. **2주차:** State와 간단한 훅 → [공부할 파일들]
-3. **3주차:** 커스텀 훅 → [공부할 파일들]
-4. **4주차:** Context와 고급 패턴 → [공부할 파일들]
+**잘한 점:**
+[설명]
 
 ---
 
-## 온보딩 시뮬레이션
-
-### 시나리오 1: "새 검증 규칙 추가"
-
-**주니어 난이도:** [Easy/Medium/Hard]
-
-**단계별 주니어 경험:**
+## Metrics
 
-1. **관련 파일 찾기:** [Easy/Medium/Hard]
-   - 현재: [주니어가 마주하는 것]
-   - 고통 포인트: [특정 혼란]
-   - 수정: 아키텍처 맵이 있는 README.md 추가
+| 지표                    | 수치 |
+| ----------------------- | ---- |
+| 평균 함수 복잡도        | X    |
+| 문서 커버리지           | Y%   |
+| 자기 설명적 이름 비율   | N/M  |
+| 주니어 친화적 함수 비율 | Z%   |
 
-2. **검증 패턴 이해:** [Easy/Medium/Hard]
-   - 현재: 5개 파일에 흩어진 검증
-   - 주니어 혼란: "어떤 파일을 수정해야 하지?"
-   - 개선: 예시가 있는 중앙화된 검증
-   - **학습 리소스:** [검증 패턴 링크]
-
-3. **코드 작성:** [Easy/Medium/Hard]
-   - 현재: 따라할 예시 없음
-   - 주니어 행동: 복붙하고 되기를 바람
-   - 개선: 일반적인 패턴이 있는 예시 폴더 추가
-
-4. **변경 테스트:** [Easy/Medium/Hard]
-   - 현재: 검증용 테스트 예시 없음
-   - 주니어 행동: 수동 테스트만
-   - 개선: 패턴을 보여주는 테스트 예시
-
-**예상 시간:**
-- **현재 상태:** 4-6시간 (많은 시행착오)
-- **개선 후:** 1-2시간 (명확한 경로)
-
----
-
-## 주니어 친화성을 위한 Top 5 개선사항
-
-### 1. 문서와 예시 추가
-**영향:** ⭐⭐⭐⭐⭐ (최고)
-**노력:** Low (2-4시간)
-
-**추가할 것:**
-- `src/README.md` - 아키텍처 개요
-- `src/components/README.md` - 컴포넌트 패턴
-- `src/examples/` - 일반적인 사용 사례
-
-**예시 구조:**
-```markdown
-# 컴포넌트 아키텍처
-
-## 개요
-[컴포넌트들이 어떻게 함께 동작하는지 간단한 설명]
-
-## 일반적인 패턴
-[예시 링크]
-
-## 새 기능 추가
-1. [1단계]
-2. [2단계]
-...
-```
-
-**학습 리소스:** [웹 리서치에서 찾은 문서 베스트 프랙티스]
-
-### 2. 복잡한 함수 단순화
-**영향:** ⭐⭐⭐⭐⭐
-**노력:** Medium (1-2일)
-
-**대상 함수:**
-- [file:line] - 3개의 작은 함수로 분리
-- [file:line] - 복잡한 로직 추출
-- [file:line] - 단계별 주석 추가
-
-**따라야 할 패턴:** [함수 추출 가이드 링크]
-
-### 3. 주석 품질 개선
-**영향:** ⭐⭐⭐⭐
-**노력:** Medium (4-6시간)
-
-**집중 영역:**
-- public API에 예시가 있는 JSDoc 추가
-- 복잡한 알고리즘 단계별 설명
-- 고급 개념에 학습 리소스 링크 추가
-
-**템플릿:**
-```typescript
-/**
- * [간단한 설명]
- *
- * [왜 존재하는지 / 어떤 문제를 해결하는지]
- *
- * @example
- * [사용법을 보여주는 코드 예시]
- *
- * @see [관련 문서 링크]
- */
-```
-
-### 4. 타입 문서 개선
-**영향:** ⭐⭐⭐
-**노력:** Low (2-3시간)
-
-**액션:**
-- 복잡한 타입에 JSDoc 추가
-- 설명적인 타입 이름 사용
-- 타입 주석에 예시 추가
-
-### 5. 학습 경로 문서 생성
-**영향:** ⭐⭐⭐⭐
-**노력:** Medium (4-6시간)
-
-**생성:** `ONBOARDING.md`
-```markdown
-# 온보딩 가이드
-
-## Day 1-2: 기초 이해
-- [파일] 읽기
-- [개념] 공부
-- [예시] 실행
-
-## Week 1: 핵심 패턴
-- [점진적 학습 경로]
-
-## 리소스
-- [웹 리서치에서 큐레이션된 목록]
-```
-
----
-
-## 큐레이션된 학습 리소스
-
-이 코드베이스에서 사용된 개념 기반:
-
-### 필수 (여기서 시작)
-- [리소스 1 - WebSearch에서] - [개념] 커버
-- [리소스 2 - WebFetch에서] - [패턴] 공식 문서
-
-### 중급 (2-3주차)
-- [리소스 3] - [고급 패턴] 심층 학습
-- [리소스 4] - [개념] 베스트 프랙티스
-
-### 고급 (2개월 이후)
-- [리소스 5] - [복잡한 패턴] 마스터
-- [리소스 6] - 아키텍처 패턴
-
-### 업계 코드 예시
-- [오픈 소스 프로젝트 예시 - 웹 리서치에서]
-- [튜토리얼 시리즈]
-
----
-
-## 예상 학습 곡선
-
-### 현재 상태
-**주니어 생산성까지 시간:** 3-4주
-**1개월 후 자신감 수준:** Low-Medium
-
-**장벽:**
-1. [file:line과 함께 특정 장벽]
-2. [또 다른 장벽]
-3. [또 다른 장벽]
-
-### 개선 후
-**주니어 생산성까지 시간:** 1-2주
-**1개월 후 자신감 수준:** Medium-High
-
-**이유:**
-- 명확한 문서가 시행착오 감소
-- 예시가 따라할 템플릿 제공
-- 단순한 함수가 이해하기 쉬움
-- 학습 리소스가 지식 갭 채움
-
----
-
-## 업계 비교
-
-### 귀하의 코드베이스 vs 업계 평균
-
-**주니어 친화성 지표:**
-| 지표 | 귀하의 코드 | 업계 평균 | 업계 최고 |
-|------|-------------|-----------|-----------|
-| 평균 함수 복잡도 | X | 5 | 3 |
-| 문서 커버리지 | Y% | 60% | 80% |
-| 예시 코드 | 적음 | 일부 | 광범위 |
-| 온보딩 시간 | Z주 | 2-3주 | 1주 |
-
-**출처:** [업계 표준 웹 리서치]
-
----
-
-## 주니어 개발자 경고 신호
-
-### 🚩 발견된 Critical 이슈
-- [file:line과 함께 이슈]
-- **왜 주니어에게 문제인지:** [특정 혼란]
-- **수정 방법:** [구체적 해결책]
-- **학습 리소스:** [링크]
-
-### 항상 리포트할 표준 경고 신호
-- 🚩 README나 설정 문서 없음
-- 🚩 설명 없는 매직 넘버
-- 🚩 한 번만 사용된 패턴 (반복으로 배울 수 없음)
-- 🚩 주석에 코드 예시 없음
-- 🚩 설명 없는 고급 TypeScript
-- 🚩 콜백 지옥 (3레벨 이상)
-- 🚩 에러 처리 없음 (주니어가 뭐가 실패할 수 있는지 모름)
-- 🚩 코드 동작을 보여주는 테스트 없음
-
----
-
-## 성공 지표
-
-주니어 친화성 개선을 측정하기 위해 추적할 지표:
-
-**Before:**
-- 온보딩 시간: X주
-- 첫 달 질문: Y개
-- 첫 PR 시간: Z일
-- 문서 커버리지: A%
-
-**Target:**
-- 온보딩 시간: <2주
-- 첫 달 질문: <10개 (좋은 문서 = 적은 질문)
-- 첫 PR 시간: <3일
-- 문서 커버리지: >70%
-
-**측정 방법:**
-- 새 팀원 설문
-- 첫 PR까지 시간 추적
-- 문서 사용량 모니터링
-- 채팅/코드 리뷰에서 질문 수 세기
 ```
 
 ---
@@ -806,13 +460,6 @@ type Mapper<InputType, OutputType> = (input: InputType) => OutputType
 - 리소스가 최신이고 고품질인지 확인
 - 가장 영향력 있는 학습 장벽에 최대 5-7개 웹 요청
 
-**점수 가이드라인:**
-- 9-10: 우수 - 주니어 친화적, 최소 학습 곡선, 훌륭한 문서
-- 7-8: 양호 - 대부분 명확, 일부 영역 개선 필요
-- 5-6: 개선 필요 - 주니어에게 상당한 장벽
-- 3-4: 혼란스러움 - 가파른 학습 곡선, 많은 불명확한 영역, 부실한 문서
-- 1-2: Critical - 주니어 개발자에게 적대적, 문서 없음
-
 ---
 
 ## References
@@ -820,3 +467,4 @@ type Mapper<InputType, OutputType> = (input: InputType) => OutputType
 - [React Official Docs](https://react.dev)
 - [TypeScript Handbook](https://www.typescriptlang.org/docs/)
 - [Clean Code Naming Guide](https://google.github.io/styleguide/)
+```