From b84595920098abf0d87ddd7c78411d0098d5bdd5 Mon Sep 17 00:00:00 2001
From: Antigravity Agent <antigravity@gstack.com>
Date: Thu, 30 Apr 2026 23:01:12 +0900
Subject: [PATCH] Update: 2026-04-30 22:59

---
 .DS_Store                                     | Bin 8196 -> 8196 bytes
 .../Frontend_Mastery/Bulletproof React.md     |  42 +++++++++++
 .../Frontend_Mastery/Error Boundaries.md      |  42 +++++++++++
 .../Frontend_Mastery/Frontend Architecture.md |  41 +++++++++++
 .../Frontend_Mastery/Frontend Scalability.md  |  42 +++++++++++
 .../Frontend System Design.md                 |  42 +++++++++++
 10_Wiki/Topics/Frontend_Mastery/JSX.md        |  41 +++++++++++
 .../Large-scale React Systems.md              |  42 +++++++++++
 .../Frontend_Mastery/React Architecture.md    |  44 ++++++++++++
 .../React Component Design.md                 |  45 ++++++++++++
 .../React Folder Structure.md                 |  45 ++++++++++++
 .../React Frontend Development.md             |  65 ++++++++++--------
 .../Frontend_Mastery/React Refactoring.md     |  42 +++++++++++
 .../React Server Components.md                |  48 +++++++++----
 10_Wiki/Topics/Frontend_Mastery/React.md      |  42 +++++++++++
 .../Scalable Frontend Architecture.md         |  44 ++++++++++++
 .../Git Branching Strategy.md                 |  43 ++++++++++++
 .../Programming & Tools/Debugging Methods.md  |  41 +++++++++++
 .../Programming & Tools/Naming Conventions.md |  46 +++++++++++++
 .../Refactoring Techniques.md                 |  41 +++++++++++
 .../Topics/Programming & Tools/Refactoring.md |  45 ++++++++++++
 .../Agile Development.md                      |  38 ++++++++++
 .../Clean Code & SOLID Principles.md          |  43 ++++++++++++
 .../Legacy System Migration.md                |  43 ++++++++++++
 .../Open-Closed Principle (OCP).md            |  41 +++++++++++
 .../Software Engineering Principles.md        |  44 ++++++++++++
 .../Software Architecture/Startup Projects.md |  40 +++++++++++
 .../system_analysis_and_improvement_plan.md   |  52 ++++++++++++++
 .../Bundle Size Optimization.md               |  44 ++++++++++++
 .../Frontend Observability & Logging.md       |  43 ++++++++++++
 .../Vite Build Optimization.md                |  39 +++++++++++
 31 files changed, 1268 insertions(+), 42 deletions(-)
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/Bulletproof React.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/Error Boundaries.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/Frontend Architecture.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/Frontend Scalability.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/Frontend System Design.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/JSX.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/Large-scale React Systems.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/React Architecture.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/React Component Design.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/React Folder Structure.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/React Refactoring.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/React.md
 create mode 100644 10_Wiki/Topics/Frontend_Mastery/Scalable Frontend Architecture.md
 create mode 100644 10_Wiki/Topics/Infrastructure & Automation/Git Branching Strategy.md
 create mode 100644 10_Wiki/Topics/Programming & Tools/Debugging Methods.md
 create mode 100644 10_Wiki/Topics/Programming & Tools/Naming Conventions.md
 create mode 100644 10_Wiki/Topics/Programming & Tools/Refactoring Techniques.md
 create mode 100644 10_Wiki/Topics/Programming & Tools/Refactoring.md
 create mode 100644 10_Wiki/Topics/Software Architecture/Agile Development.md
 create mode 100644 10_Wiki/Topics/Software Architecture/Clean Code & SOLID Principles.md
 create mode 100644 10_Wiki/Topics/Software Architecture/Legacy System Migration.md
 create mode 100644 10_Wiki/Topics/Software Architecture/Open-Closed Principle (OCP).md
 create mode 100644 10_Wiki/Topics/Software Architecture/Software Engineering Principles.md
 create mode 100644 10_Wiki/Topics/Software Architecture/Startup Projects.md
 create mode 100644 10_Wiki/Topics/System Design & Modeling/system_analysis_and_improvement_plan.md
 create mode 100644 10_Wiki/Topics/Web & Performance/Bundle Size Optimization.md
 create mode 100644 10_Wiki/Topics/Web & Performance/Frontend Observability & Logging.md
 create mode 100644 10_Wiki/Topics/Web & Performance/Vite Build Optimization.md

diff --git a/.DS_Store b/.DS_Store
index 08e190804bfbf19ceaf5390b6a65b6c45d3b3fb8..af78cf1c25c1d1b88f03deab259c5318083ba190 100644
GIT binary patch
delta 35
rcmZp1XmOa}&&azmU^hP_?_?eU?akQ&bJ!;~m~3X3_|CGil8qSv%+Cuy

delta 79
zcmZp1XmOa}&&aniU^hP_-((&EZA~r)J%)6KOokF5PG`tt$Y&^GNcGIgPfp6oPhwzT
f5CCE)AfC5bM_@VoW_F41ER&r?WHvt&dBp?(2ptr1

diff --git a/10_Wiki/Topics/Frontend_Mastery/Bulletproof React.md b/10_Wiki/Topics/Frontend_Mastery/Bulletproof React.md
new file mode 100644
index 00000000..e712e380
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Bulletproof React.md	
@@ -0,0 +1,42 @@
+## 📌 Brief Summary
+'Bulletproof React'는 프로덕션 수준의 React 애플리케이션을 구축하기 위한 확장 가능하고 강력한 아키텍처 가이드라인이다. React의 자유도로 인해 발생하는 일관성 없는 구조 문제를 해결하기 위해 기능(Feature) 기반의 모듈화와 명확한 계층 분리라는 주관적인(Opinionated) 베스트 프랙티스를 제시한다.
+
+## 📖 Core Content
+1. **아키텍처 철학 (Scalability & Predictability)**
+   - React는 프레임워크가 아닌 라이브러리이므로 구조적 선택의 책임이 개발자에게 있다.
+   - Bulletproof React는 팀 규모와 코드베이스가 커져도 유지보수가 가능하도록 명확한 경계(Boundaries)와 일관된 작업 방식을 제공한다.
+2. **기능 기반 구조 (Feature-Based Structure)**
+   - 기술적 역할(Components, Hooks, Styles)이 아닌 비즈니스 기능(Feature) 단위로 코드를 그룹화한다.
+   - 각 기능 폴더 내에 해당 기능에 필요한 컴포넌트, API, 상태, 타입, 유틸리티를 독립적으로 배치하여 응집도를 높인다.
+3. **계층화된 아키텍처 (Layered Architecture)**
+   - 프로젝트 표준, 프로젝트 구조, 컴포넌트/스타일링, API 계층, 상태 관리, 테스트, 보안 등 프론트엔드 전반의 레이어를 규격화한다.
+   - 특정 기술에 얽매이지 않고 원칙(Principles)에 집중하여 라이브러리 교체가 용이한 구조를 지향한다.
+4. **유연한 적용 (Guideline, Not Template)**
+   - 강제적인 보일러플레이트가 아니며, 팀의 요구사항과 프로젝트 규모에 맞게 선택적으로 적용할 수 있는 가이드라인 역할을 수행한다.
+
+## ⚖️ Trade-offs & Caveats
+- **규칙의 파편화 위험**: 프레임워크가 아닌 가이드라인이므로, 팀 내에서 합의된 수준을 넘어서는 자의적인 해석이 발생할 경우 구조적 일관성이 깨질 수 있다.
+- **초기 학습 곡선**: 폴더 구조가 깊어지고 관심사 분리가 엄격해짐에 따라, 기존의 플랫한 구조에 익숙한 개발자들에게는 초기 적응 시간이 필요하다.
+- **오버헤드**: 매우 작은 규모의 프로젝트나 단순한 MVP 단계에서는 이러한 엄격한 분리가 오히려 과도한 보일러플레이트로 느껴질 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Based Structure**: 비즈니스 도메인 단위의 코드 응집도 향상 기법 (관계: 핵심 구현 패턴)
+- **Feature-Sliced Design (FSD)**: 기능 기반 구조를 더 체계화한 고급 아키텍처 방법론 (관계: 확장 발전 형태)
+- **Scalable React Architecture**: 대규모 시스템을 위한 설계 철학 (관계: 상위 목표)
+
+### Deeper Research Questions
+1. 기능 기반 구조에서 여러 기능 간에 공통으로 사용되는 로직(Shared)의 의존성 역전은 어떻게 관리하는가?
+2. API 계층과 상태 관리 레이어의 물리적 분리가 단위 테스트의 고립성 확보에 어떤 영향을 미치는가?
+3. 대규모 리팩토링 시, 기능 단위로 쪼개진 모듈이 파일 유형 기반 구조보다 안전한 이유는 무엇인가?
+4. 아키텍처가 제시하는 '명확한 경계'를 강제하기 위해 ESLint 등의 도구를 어떻게 활용할 수 있는가?
+5. 서버 컴포넌트(RSC) 환경에서 Bulletproof React의 폴더 구조 전략은 어떻게 진화해야 하는가?
+
+### Practical Application Contexts
+- **신규 프로젝트 셋업**: 초기 폴더 구조 및 레이어링 표준안으로 채택.
+- **레거시 리팩토링**: 복잡해진 코드베이스를 기능 단위로 점진적으로 격리 및 구조화.
+
+### Adjacent Topics
+- **Clean Architecture in Frontend**
+- **Domain-Driven Design (DDD)**
+- **Monorepo Management Strategies**
diff --git a/10_Wiki/Topics/Frontend_Mastery/Error Boundaries.md b/10_Wiki/Topics/Frontend_Mastery/Error Boundaries.md
new file mode 100644
index 00000000..08a33f3e
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Error Boundaries.md	
@@ -0,0 +1,42 @@
+## 📌 Brief Summary
+Error Boundaries는 React 컴포넌트 트리 하위에서 발생하는 JavaScript 런타임 에러를 포착하여 전체 애플리케이션의 크래시(White Screen)를 방지하는 선언적 에러 처리 메커니즘이다. 에러가 발생한 지점을 격리하고 대체 UI(Fallback UI)를 렌더링함으로써 시스템의 가용성과 사용자 경험을 보호한다.
+
+## 📖 Core Content
+1. **작동 메커니즘 및 클래스 컴포넌트 의존성**
+   - React 16부터 도입되었으며, 자식 컴포넌트의 렌더링, 수명 주기 메서드, 생성자 내부의 에러를 감지한다.
+   - 반드시 클래스 컴포넌트로 구현해야 하며, `static getDerivedStateFromError()`로 상태를 업데이트하고 `componentDidCatch()`로 에러를 로깅한다.
+2. **선언적 에러 격리 (Isolation)**
+   - 명령형 `try/catch`와 달리 React의 선언적 특성을 유지하며 컴포넌트 트리 수준에서 에러를 관리한다.
+   - 애플리케이션 전체가 아닌, 실패 위험이 높은 특정 위젯(차트, 서드파티 폼 등)을 독립된 Boundary로 감싸 '장애 격리'를 실현한다.
+3. **포착 불가능한 영역 (Limitations)**
+   - 이벤트 핸들러, 비동기 코드(setTimeout, Fetch), 서버 사이드 렌더링(SSR), Error Boundary 자체 내의 에러는 포착하지 못한다.
+   - 이러한 영역은 여전히 `try/catch`나 전역 에러 핸들러를 통한 보완이 필요하다.
+4. **미처리 에러의 결과**
+   - 포착되지 않은 에러는 전체 컴포넌트 트리의 마운트 해제(Unmounting)를 유발하며, 이는 손상된 데이터가 사용자에게 노출되는 것보다 안전한 선택으로 간주된다.
+
+## ⚖️ Trade-offs & Caveats
+- **클래스 컴포넌트 유지 필요성**: 최신 React가 Hooks 중심임에도 불구하고 Error Boundary 구현을 위해 클래스 컴포넌트를 유지해야 하는 아키텍처적 일관성 저하가 발생할 수 있다.
+- **성능 및 렌더링 오버헤드**: 너무 많은 Error Boundary를 중첩할 경우 트리 깊이가 깊어지고 에러 전파 체크 로직에 따른 미세한 성능 영향이 있을 수 있다.
+- **비동기 에러 처리의 공백**: 렌더링 에러만 포착하므로, 비동기 데이터 통신이 빈번한 현대 앱에서는 `react-error-boundary`와 같은 라이브러리를 통한 추가 처리가 필수적이다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Fallback UI**: 에러 발생 시 사용자에게 노출되는 방어적 인터페이스 (관계: 출력 결과물)
+- **Component Stack Traces**: 에러 발생 위치를 추적하는 런타임 정보 (관계: 디버깅 핵심 데이터)
+- **Sentry / LogRocket**: 프로덕션 환경의 에러 수집 및 분석 플랫폼 (관계: 운영 모니터링 연동)
+
+### Deeper Research Questions
+1. React의 내부 Fiber 아키텍처는 Error Boundary를 만났을 때 어떻게 렌더링 작업을 중단하고 커밋 단계로 전이하는가?
+2. 이벤트 핸들러 내의 에러를 Error Boundary로 강제 전파하기 위한 'setState' 트릭의 원리와 한계는?
+3. `react-error-boundary` 라이브러리가 함수형 컴포넌트 환경에서 클래스 컴포넌트의 한계를 극복하는 방식은?
+4. 단일 전역 Error Boundary와 다중 지역 Error Boundary 간의 메모리 사용량 및 리렌더링 범위 트레이드오프는?
+5. 서버 사이드 렌더링(SSR) 환경에서 클라이언트 사이드 Error Boundary가 활성화되기 전의 에러는 어떻게 처리해야 하는가?
+
+### Practical Application Contexts
+- **결제 및 금융 모듈**: 입력 폼의 작은 렌더링 오류가 전체 결제 프로세스 마비로 이어지지 않도록 격리.
+- **서드파티 위젯 통합**: 안정성이 검증되지 않은 외부 라이브러리 기반 컴포넌트를 Boundary로 보호.
+
+### Adjacent Topics
+- **Try/Catch Statement in JS**
+- **Observability in Frontend**
+- **Graceful Degradation Design**
diff --git a/10_Wiki/Topics/Frontend_Mastery/Frontend Architecture.md b/10_Wiki/Topics/Frontend_Mastery/Frontend Architecture.md
new file mode 100644
index 00000000..77184d7d
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Frontend Architecture.md	
@@ -0,0 +1,41 @@
+## 📌 Brief Summary
+프론트엔드 아키텍처는 현대 웹 애플리케이션의 복잡성을 관리하고 지속 가능한 유지보수성과 확장성을 확보하기 위한 구조적 설계 기반이다. 단순한 UI 렌더링을 넘어 비즈니스 로직과 UI의 분리, 엄격한 의존성 관리, 그리고 기능(Feature) 기반의 모듈화를 통해 견고한 소프트웨어 시스템을 구축하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **기능 기반 설계 및 FSD (Feature-Sliced Design)**
+   - 기술적 타입(컴포넌트, 훅 등)이 아닌 비즈니스 기능(도메인) 중심으로 코드를 구성하여 응집도를 높인다.
+   - FSD 아키텍처를 통해 계층(Layer) 간 단방향 의존성을 강제하고, 모듈 간의 순환 참조와 아키텍처 붕괴를 원천적으로 방지한다.
+2. **소프트웨어 공학 원칙의 적용**
+   - **SOLID**: 단일 책임 원칙(SRP)으로 컴포넌트를 세분화하고, 컴포넌트 합성(Composition)으로 개방-폐쇄 원칙(OCP)을 준수한다.
+   - **KISS, DRY, YAGNI**: 코드를 단순하게 유지하고 불필요한 추상화와 오버엔지니어링을 경계하여 실용적인 코드베이스를 유지한다.
+3. **계층화된 상태 관리**
+   - 상태의 성격에 따라 로컬(React State), 글로벌 앱 상태(Zustand), 서버 캐시 상태(TanStack Query)로 레이어를 분리하여 리렌더링 성능과 데이터 동기화 효율을 최적화한다.
+4. **성능 및 회복성 설계**
+   - Vite 기반의 코드 스플리팅과 지연 로딩을 통해 번들 크기를 최적화하고, Error Boundary를 배치하여 특정 모듈의 오류가 시스템 전체로 전파되는 것을 차단한다.
+
+## ⚖️ Trade-offs & Caveats
+- **설계 오버헤드**: 엄격한 아키텍처(FSD 등) 도입 시 초기 폴더 구성과 계층 분리에 따른 인지적 부하 및 파일 수 증가가 발생할 수 있다.
+- **추상화의 양날의 검**: DRY 원칙을 무리하게 적용하여 지나치게 추상화된 공통 로직은 오히려 코드 독해를 방해하고 변경에 취약하게 만들 수 있다(KISS 원칙과의 충돌).
+- **기술 부채의 점진적 해결**: 기존의 모놀리식 구조에서 기능 기반 아키텍처로 전환할 때, 과도한 빅뱅 방식의 리팩토링보다는 점진적 마이그레이션 전략이 권장된다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design**: 프론트엔드 모듈화의 최신 표준 방법론 (관계: 핵심 아키텍처 모델)
+- **State Management**: 데이터 흐름의 중앙 통제 및 최적화 (관계: 데이터 레이어 설계)
+- **SOLID Principles**: 객체 지향 및 컴포넌트 설계의 근간 (관계: 코드 품질 기준)
+
+### Deeper Research Questions
+1. FSD의 'Widgets' 계층과 'Features' 계층 사이의 책임 분배를 결정하는 가장 명확한 기준은 무엇인가?
+2. 마이크로 프론트엔드 전환 시, 중앙 집중식 상태 관리 라이브러리와 서비스별 격리된 상태 관리 중 어떤 것이 유리한가?
+3. 컴포넌트 합성(Composition) 패턴이 개방-폐쇄 원칙(OCP)을 프론트엔드 환경에서 어떻게 물리적으로 구현하는가?
+4. 서버 사이드 데이터(RSC) 비중이 늘어날 때, 클라이언트 아키텍처의 상태 관리 레이어는 어떻게 간소화되어야 하는가?
+5. 아키텍처의 단방향 의존성 규칙을 정적 분석 도구(ESLint plugin-import 등)를 통해 자동화하여 강제하는 방안은?
+
+### Practical Application Contexts
+- **대규모 앱 리팩토링**: 흩어져 있는 비즈니스 로직을 기능별 폴더로 캡슐화하여 유지보수성 확보.
+- **신규 프로젝트 설계**: 초기 아키텍처 수립 단계에서 상태 레이어와 오류 처리 전략 정의.
+
+### Adjacent Topics
+- **Micro-Frontends**
+- **Server Components (RSC)**
+- **Test-Driven Development (TDD) in Frontend**
diff --git a/10_Wiki/Topics/Frontend_Mastery/Frontend Scalability.md b/10_Wiki/Topics/Frontend_Mastery/Frontend Scalability.md
new file mode 100644
index 00000000..3b625184
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Frontend Scalability.md	
@@ -0,0 +1,42 @@
+## 📌 Brief Summary
+프론트엔드 스케일러빌리티(Frontend Scalability)는 코드베이스의 팽창과 팀 규모의 확장에 대응하여 시스템의 복잡도를 제어하고 성능을 유지하는 엔지니어링 역량이다. 기능 기반의 아키텍처 설계, 계층화된 상태 관리, 최적화된 빌드 파이프라인, 그리고 엄격한 코드 거버넌스를 통해 애플리케이션의 지속 가능한 성장을 보장한다.
+
+## 📖 Core Content
+1. **아키텍처 구조화 (Architecture Organization)**
+   - 파일 유형 중심의 구조를 탈피하고 비즈니스 도메인 중심의 **Feature-Based Structure**를 채택하여 응집도를 강화한다.
+   - **Feature-Sliced Design (FSD)**을 도입하여 계층 간 단방향 의존성과 Public API 규칙을 강제함으로써 결합도를 낮추고 인지적 부하를 줄인다.
+2. **상태 관리의 최적 확장 (Scaling State Management)**
+   - 리렌더링 최적화가 필요한 중대형 앱에서는 Selector 패턴을 지원하는 **Zustand** 또는 디버깅 환경이 강력한 **Redux**를 선택한다.
+   - 서버 상태(TanStack Query)와 클라이언트 상태를 분리하여 데이터 동기화와 캐싱의 복잡성을 관리한다.
+3. **런타임 및 빌드 성능 (Performance Scalability)**
+   - **코드 스플리팅(Code Splitting)**과 지연 로딩(Lazy Loading)을 통해 번들 팽창을 방어하고 초기 로딩 성능을 유지한다.
+   - 대규모 리스트 렌더링 시 가상화(Virtualization)를 적용하여 DOM 노드 수의 폭발을 방지한다.
+4. **코드 거버넌스 및 자동화 (Governance)**
+   - SOLID 원칙(특히 SRP)을 적용하여 컴포넌트를 분리하고, ESLint와 Husky 등을 통해 아키텍처 규칙과 컨벤션을 자동 검증한다.
+
+## ⚖️ Trade-offs & Caveats
+- **설계 복잡도 vs 유연성**: 엄격한 FSD 아키텍처는 결합도를 낮추지만, 초기 도입 시 파일 수가 급격히 늘어나고 단순한 기능 추가에도 여러 레이어를 수정해야 하는 오버헤드가 발생한다.
+- **도구 선택의 무게**: Redux와 같은 강력한 도구는 대규모 팀의 일관성에는 유리하나, 보일러플레이트 코드가 많아 소규모/고속 개발 환경에서는 생산성을 저하시킬 수 있다.
+- **과도한 추상화 경계**: 스케일링을 위해 도입한 공통 훅이나 유틸리티가 너무 범용적으로 설계될 경우, 오히려 내부 로직을 파악하기 어렵게 만드는 KISS 원칙 위배 상황을 초래할 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design**: 확장 가능한 프론트엔드 구조의 표준 (관계: 구조적 토대)
+- **Code Splitting**: 번들 사이즈 최적화 필수 기술 (관계: 성능 확장 전략)
+- **SOLID Principles**: 유지보수 가능한 코드의 근간 (관계: 설계 원칙)
+
+### Deeper Research Questions
+1. FSD 구조 내에서 두 개 이상의 기능(Features)이 상호 참조해야 할 때, 의존성 순환을 방지하기 위한 '상위 계층으로의 로직 승격' 패턴은 어떻게 작동하는가?
+2. Zustand의 Selector 패턴이 대규모 상태 트리에서 성능적 이점을 갖는 내부적 원리는 무엇인가?
+3. Vite의 `manualChunks` 설정 최적화를 통해 벤더 라이브러리 캐싱 효율을 정량적으로 얼마나 높일 수 있는가?
+4. 아키텍처 규칙을 위반하는 임포트(Import) 시도를 린트 단계에서 원천 차단하는 가장 효율적인 커스텀 규칙 설정 방법은?
+5. 서버 상태 관리 도구 도입 시 클라이언트 스토어의 역할이 축소되는 경향에 따른 아키텍처 슬림화 전략은?
+
+### Practical Application Contexts
+- **엔터프라이즈 앱 설계**: 다수의 개발자가 협업하는 대규모 대시보드 및 복잡한 워크플로우 시스템 구축.
+- **레거시 마이그레이션**: 비대해진 Context API 기반 상태 관리를 Zustand/Redux로 전환하여 성능 병목 해소.
+
+### Adjacent Topics
+- **React Performance Optimization**
+- **Micro-Frontends Architecture**
+- **Monorepo Management (Turborepo / Nx)**
diff --git a/10_Wiki/Topics/Frontend_Mastery/Frontend System Design.md b/10_Wiki/Topics/Frontend_Mastery/Frontend System Design.md
new file mode 100644
index 00000000..eeaf7a7d
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Frontend System Design.md	
@@ -0,0 +1,42 @@
+## 📌 Brief Summary
+프론트엔드 시스템 디자인은 현대의 대규모 웹 애플리케이션을 확장 가능하고(Scalable), 유지보수가 용이하며(Maintainable), 고성능인(Performant) 시스템으로 구축하기 위한 아키텍처 설계론이다. UI 구현을 넘어 상태 관리, 모듈화, 빌드 최적화, 거버넌스 등을 통합적으로 엔지니어링하여 비즈니스 가치를 안정적으로 전달하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **아키텍처 패러다임: FSD (Feature-Sliced Design)**
+   - 비즈니스 도메인 중심의 계층화(App, Pages, Widgets, Features, Entities, Shared)를 통해 모듈의 독립성을 확보한다.
+   - 단방향 의존성 규칙과 Public API(`index.ts`)를 강제하여 기능 간의 암시적 결합을 방지하고 코드의 예측 가능성을 높인다.
+2. **엔지니어링 원칙의 적용**
+   - **SOLID (특히 SRP)**: 컴포넌트의 책임을 단일화하고 비대한 컴포넌트에서 비즈니스 로직을 커스텀 훅으로 추출한다.
+   - **KISS & DRY**: 중복을 제거하되 과도한 추상화를 경계하여 코드의 단순성과 가독성을 유지한다.
+3. **상태 관리 아키텍처**
+   - 상태의 수명과 성격에 따라 로컬, 전역(Zustand/Redux), 서버 캐시(TanStack Query)로 명확히 레이어를 분리한다.
+   - 성능 저하를 방지하기 위해 Context API의 리렌더링 한계를 이해하고 최적화된 상태 구독(Selector) 패턴을 적용한다.
+4. **성능 엔지니어링**
+   - 번들 사이즈 최적화(Code Splitting)와 런타임 성능(Virtualization, Memoization)을 아키텍처 수준에서 고려하여 사용자 체감 성능을 극대화한다.
+
+## ⚖️ Trade-offs & Caveats
+- **유연성 vs 규격화**: 엄격한 시스템 디자인은 협업과 유지보수에 유리하지만, 빠른 실험과 프로토타이핑이 필요한 초기 단계에서는 개발 속도를 저해할 수 있다.
+- **도구의 종속성**: 특정 상태 관리나 빌드 도구에 기반한 디자인은 도구의 버전 업그레이드나 패러다임 변화 시 큰 전환 비용을 발생시킨다.
+- **인지적 부하**: 아키텍처가 복잡해질수록 신규 팀원의 온보딩 비용이 증가하므로, 문서화와 자동화된 린트 규칙이 반드시 수반되어야 한다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design**: 시스템 구조화의 핵심 방법론 (관계: 구조적 뼈대)
+- **State Management Architecture**: 데이터 흐름의 계층화 (관계: 혈액 순환 체계)
+- **Performance Engineering**: 시스템 효율성 극대화 (관계: 품질 지표)
+
+### Deeper Research Questions
+1. FSD 구조에서 계층 간 데이터 전달 시 'Prop Drilling'을 최소화하면서도 단방향 의존성을 지키는 전략은 무엇인가?
+2. 서버 컴포넌트(RSC) 환경에서 시스템 디자인의 'Client State' 레이어는 어떻게 재설계되어야 하는가?
+3. 아키텍처의 Public API 규칙을 위반하는 '심층 임포트(Deep Import)'를 정적 분석으로 완벽히 차단하는 방법은?
+4. 상태 관리 라이브러리 간의 아키텍처적 트레이드오프를 결정하는 정량적 기준(팀 규모, 컴포넌트 수 등)은 존재하는가?
+5. 시스템 디자인 단계에서 고려해야 할 '웹 접근성(A11y)'과 '국제화(i18n)' 레이어의 배치 전략은?
+
+### Practical Application Contexts
+- **신규 플랫폼 아키텍처 수립**: 제품 개발 초기 단계에서 확장 가능한 폴더 구조 및 기술 스택 레이어링 정의.
+- **기술 부채 해소**: 스파게티 코드로 변한 대규모 리액트 앱을 기능별로 모듈화하여 시스템 안정성 회복.
+
+### Adjacent Topics
+- **Micro-Frontends Architecture**
+- **Design Systems & Component Library Design**
+- **Frontend Observability & Monitoring**
diff --git a/10_Wiki/Topics/Frontend_Mastery/JSX.md b/10_Wiki/Topics/Frontend_Mastery/JSX.md
new file mode 100644
index 00000000..a7b294ab
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/JSX.md
@@ -0,0 +1,41 @@
+## 📌 Brief Summary
+JSX는 UI를 상태(state)와 속성(props)의 순수 함수로 표현하는 선언형(declarative) 컴포넌트 트리 작성 문법이다. HTML과 유사한 구문을 통해 UI 구조를 직관적으로 설계할 수 있게 하며, React Compiler와 같은 현대적인 도구들을 통해 고성능 렌더링 최적화를 자동으로 수행한다.
+
+## 📖 Core Content
+1. **선언적 컴포넌트 합성 (Composition)**
+   - UI를 독립적인 엘리먼트들의 트리 구조로 사고하고 조립하도록 유도하여 코드의 예측 가능성을 높인다.
+   - JSX 자체는 비즈니스 로직의 위치를 강제하지 않으므로, 아키텍처적 제약(FSD 등)을 통해 로직 누수를 방지해야 한다.
+2. **모던 빌드 시스템과 JSX 컴파일**
+   - Vite 환경에서는 esbuild 또는 SWC(Rust 기반)를 활용하여 대규모 프로젝트에서도 실시간에 가까운 컴파일 속도를 제공한다.
+   - `@vitejs/plugin-react-swc` 적용 시 HMR(Hot Module Replacement) 성능이 극대화된다.
+3. **React Compiler를 통한 자동 최적화**
+   - 기존의 수동 메모이제이션(useMemo 등) 한계를 극복하기 위해, 빌드 타임에 JSX 내의 개별 엘리먼트 단위로 독립적이고 정밀한 캐싱을 수행한다.
+4. **인라인 함수 사용 시 주의점**
+   - JSX 내부에서 익명 함수를 직접 정의하는 행위는 매 렌더링마다 새로운 참조를 생성하여 자식 컴포넌트의 불필요한 리렌더링을 유발하므로 지양해야 한다.
+
+## ⚖️ Trade-offs & Caveats
+- **로직 혼재의 위험**: JSX의 자유로운 특성으로 인해 UI 마크업 사이에 복잡한 비즈니스 규칙이 섞여 컴포넌트가 비대해지고 유지보수가 어려워질 수 있다.
+- **도구 의존성**: React Compiler와 같은 자동 최적화 도구는 'Rules of React'(순수성 등)를 엄격히 준수하는 코드에서만 안전하게 작동하므로, 기존 레거시 코드와의 호환성 검토가 필요하다.
+- **추상화 비용**: JSX 성능을 위해 모든 함수를 useCallback으로 감싸는 수동 최적화는 코드의 가독성을 해치고 관리 비용을 증가시키는 트레이드오프가 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+* **Component Trees**: JSX로 조립된 UI의 논리적 구조 (관계: 핵심 데이터 모델)
+* **React Compiler**: JSX 렌더링 자동 최적화 엔진 (관계: 성능 개선 도구)
+* **SWC**: 초고속 JSX 컴파일러 (관계: 빌드 타임 인프라)
+
+### Deeper Research Questions
+1. React Compiler가 JSX 내의 개별 태그를 메모이제이션할 때 사용하는 '의존성 분석' 알고리즘의 핵심 원리는 무엇인가?
+2. JSX 내부 인라인 함수가 성능에 미치는 악영향이 React Compiler 도입 이후에도 여전히 유효한 제약 사항인가?
+3. Vite + SWC 환경에서 JSX 컴파일 시 발생하는 'Fast Refresh'의 내부 작동 메커니즘은 무엇인가?
+4. 비즈니스 로직과 JSX 마크업을 물리적으로 완전히 분리하기 위한 'View-Model' 패턴의 프론트엔드적 해석은?
+5. JSX에서 'Fragment'와 'Wrapper Div'가 렌더링 성능 및 DOM 트리 깊이에 미치는 실질적인 차이는?
+
+### Practical Application Contexts
+* **렌더링 최적화**: JSX 내 이벤트 핸들러를 밖으로 분리하여 참조 안정성 확보.
+* **빌드 속도 개선**: Vite 설정에서 SWC 플러그인을 도입하여 로컬 개발 환경의 핫 리로딩 속도 개선.
+
+### Adjacent Topics
+* **Memoization (useMemo, useCallback)**
+* **Feature-Sliced Design (FSD)**
+* **Virtual DOM vs Incremental DOM**
diff --git a/10_Wiki/Topics/Frontend_Mastery/Large-scale React Systems.md b/10_Wiki/Topics/Frontend_Mastery/Large-scale React Systems.md
new file mode 100644
index 00000000..37a439f6
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Large-scale React Systems.md	
@@ -0,0 +1,42 @@
+## 📌 Brief Summary
+대규모 React 시스템은 뛰어난 유지보수성, 확장성, 그리고 고성능을 보장하기 위해 설계된 정교한 소프트웨어 아키텍처의 집합체이다. 비즈니스 로직과 UI의 엄격한 분리, 도메인 중심의 모듈 구조(FSD), 그리고 멀티 레이어 상태 관리 시스템을 통해 수백 명의 개발자와 방대한 코드베이스를 안정적으로 수용하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **도메인 중심 아키텍처: FSD (Feature-Sliced Design)**
+   - 기술적 타입이 아닌 비즈니스 기능(Feature) 단위로 코드를 그룹화하여 응집도를 높이고 의존성 스파게티를 방지한다.
+   - 단방향 의존성 규칙과 Public API(`index.ts`)를 통해 모듈 간의 결합도를 낮추고 독립적 배포와 테스트가 가능한 구조를 구축한다.
+2. **멀티 레이어 상태 관리 전략**
+   - **전역 상태**: 리렌더링 최적화가 강력한 Zustand 또는 엄격한 거버넌스의 Redux를 사용하여 앱 전반의 데이터를 제어한다.
+   - **서버 상태**: TanStack Query를 통해 API 통신, 캐싱, 동기화 로직을 UI와 완전히 디커플링한다.
+3. **자동화된 성능 엔지니어링**
+   - **React Compiler**: 수동 메모이제이션의 한계를 극복하고 빌드 타임에 컴포넌트를 자동 캐싱하여 런타임 성능을 극대화한다.
+   - **코드 스플리팅**: Vite와 `React.lazy`를 활용한 지연 로딩으로 초기 번들 크기를 최적화한다.
+4. **회복 탄력성(Resilience) 설계**
+   - Error Boundary를 통한 장애 격리와 Sentry/LogRocket 기반의 실시간 모니터링 및 세션 리플레이로 프로덕션 이슈 대응력을 확보한다.
+
+## ⚖️ Trade-offs & Caveats
+- **아키텍처 인지 부하**: FSD와 같은 엄격한 아키텍처는 코드 확장성에는 유리하지만, 신규 개발자의 온보딩 비용과 초기 설계 복잡도가 높다.
+- **수동 vs 자동 최적화**: React Compiler가 도입되어도 써드파티 라이브러리와의 참조 불일치로 인한 캐시 깨짐 현상이 발생할 수 있어 여전히 정밀한 디버깅 능력이 요구된다.
+- **도구 비대화**: 강력한 모니터링 및 상태 관리 도구들의 도입은 그 자체로 번들 사이즈를 키우는 요인이 되므로 샘플링과 최적화된 임포트 전략이 수반되어야 한다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design**: 대규모 시스템의 구조적 뼈대 (관계: 핵심 아키텍처)
+- **React Compiler**: 차세대 성능 최적화 엔진 (관계: 성능 보장 장치)
+- **Error Boundaries**: 시스템 가용성 보호 장치 (관계: 안정성 메커니즘)
+
+### Deeper Research Questions
+1. FSD 구조에서 복수의 'Features' 계층이 공통 데이터를 공유해야 할 때, 의존성 규칙을 위반하지 않는 최적의 상태 승격(State Lifting) 전략은 무엇인가?
+2. React Compiler가 써드파티 라이브러리에서 반환된 불안정한 객체 참조를 만났을 때 메모이제이션 연쇄를 어떻게 보호하는가?
+3. 대규모 번들에서 `manualChunks`를 라이브러리의 업데이트 빈도별로 세분화하여 브라우저 캐시 효율을 극대화하는 정량적 분석 모델은?
+4. 분리된 DOM 노드(Detached DOM nodes)를 실시간으로 탐지하여 자동 롤백을 수행하는 프로덕션 레벨의 모니터링 자동화는 가능한가?
+5. 대규모 팀에서 아키텍처 규칙(단방향 의존성 등)을 강제하기 위한 커스텀 ESLint 규칙의 유지보수 전략은?
+
+### Practical Application Contexts
+- **엔터프라이즈급 SaaS 개발**: 다수의 도메인이 얽힌 복잡한 비즈니스 시스템 아키텍처 설계.
+- **성능 중심 앱 리팩토링**: 렌더링 병목이 심한 대규모 React 앱을 자동 메모이제이션과 계층화된 상태 관리로 개선.
+
+### Adjacent Topics
+- **Micro-Frontends Architecture**
+- **Monorepo Management (Nx / Turborepo)**
+- **Visual Regression Testing in CI/CD**
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Architecture.md b/10_Wiki/Topics/Frontend_Mastery/React Architecture.md
new file mode 100644
index 00000000..269cdd65
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React Architecture.md	
@@ -0,0 +1,44 @@
+## 📌 Brief Summary
+React Architecture는 컴포넌트, 상태 관리, 파일 구조를 체계적으로 설계하여 애플리케이션의 확장성, 유지보수성, 성능을 극대화하는 소프트웨어 시스템 디자인이다. 특정 아키텍처를 강제하지 않는 라이브러리의 특성을 보완하기 위해 기능(Feature) 중심의 모듈화와 단방향 의존성 규칙을 적용하여 비즈니스 로직과 UI의 결합을 최소화하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **기능 기반 구조 (Feature-based Structure)**
+   - 기술적 타입(컴포넌트, 훅) 중심의 구조에서 벗어나 비즈니스 도메인별로 코드를 캡슐화하여 응집도를 높인다.
+   - 관련된 API, 상태, 타입, 컴포넌트를 하나의 기능 폴더 내에 배치하여 수정 범위를 명확히 한다.
+2. **Feature-Sliced Design (FSD)**
+   - 현대 React 아키텍처의 표준으로, 앱을 `Shared`, `Entities`, `Features`, `Widgets`, `Pages`, `App` 계층으로 나눈다.
+   - 상위 계층이 하위 계층에만 의존하는 **단방향 의존성**과 `index.ts`를 통한 **Public API** 규칙을 강제하여 결합도를 낮춘다.
+3. **분산형 상태 관리 아키텍처**
+   - 상태를 성격에 따라 로컬, 전역 앱 상태(Zustand/Redux), 서버 상태(TanStack Query), URL 상태로 세분화하여 관리한다.
+   - Context API의 리렌더링 한계를 이해하고, 성능이 중요한 전역 상태에는 Selector 패턴이 지원되는 도구를 사용한다.
+4. **클린 코드 및 SOLID 원칙**
+   - 컴포넌트당 단일 책임(SRP)을 부여하고, 컴포넌트 합성을 통해 수정 없이 기능을 확장(OCP)한다.
+5. **성능 및 복원력 설계**
+   - React Server Components(RSC)를 통한 번들 최적화와 Error Boundary를 활용한 장애 격리 전략을 아키텍처 수준에서 수립한다.
+
+## ⚖️ Trade-offs & Caveats
+- **아키텍처 인지 부하**: FSD와 같은 엄격한 레이어링은 팀의 학습 곡선을 높이며, 간단한 수정에도 여러 파일을 건드려야 하는 'Boilerplate' 오버헤드를 유발할 수 있다.
+- **과도한 캡슐화**: 기능을 너무 잘게 쪼갤 경우 기능 간 공통 로직(Shared)의 비대화를 초래하거나, 모듈 간 데이터 통신이 복잡해지는 트레이드오프가 있다.
+- **라이브러리 종속성**: 특정 아키텍처에 최적화된 도구(예: Next.js와 RSC)를 선택할 경우, 향후 다른 프레임워크로의 전환 비용이 매우 높아진다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design (FSD)**: 구조적 캡슐화와 의존성 제어의 핵심 (관계: 핵심 방법론)
+- **State Management Architecture**: 데이터 흐름의 계층화 (관계: 데이터 레이어 설계)
+- **SOLID Principles**: 확장 가능한 컴포넌트 설계의 근간 (관계: 설계 철학)
+
+### Deeper Research Questions
+1. FSD 구조에서 'Features'와 'Widgets' 계층의 책임 경계가 모호할 때, 어떤 비즈니스 기준을 적용해야 아키텍처의 일관성을 유지할 수 있는가?
+2. RSC(서버 컴포넌트) 도입이 기존의 클라이언트 중심 상태 관리 아키텍처를 어떻게 단순화하거나 복잡하게 만드는가?
+3. 아키텍처 규칙(단방향 의존성 등)을 어기는 코드 작성을 CI 단계에서 원천적으로 차단하기 위한 린트 규칙 커스터마이징 방안은?
+4. 대규모 팀에서 마이크로 프론트엔드로 전환할 때, 중앙 집중식 아키텍처 거버넌스와 팀별 자율성 사이의 균형점은 어디인가?
+5. React Compiler가 자동 메모이제이션을 수행할 때, 아키텍처적으로 '불변성(Immutability)'을 강제하는 것이 성능에 미치는 정량적 영향은?
+
+### Practical Application Contexts
+- **대규모 제품 설계**: 수백 개의 컴포넌트가 얽힌 엔터프라이즈급 SaaS의 확장 가능한 뼈대 구축.
+- **성능 및 품질 개선**: 스파게티 코드로 변한 레거시 React 앱을 기능별 모듈로 격리 및 리팩토링.
+
+### Adjacent Topics
+- **Micro-Frontends**
+- **Server Components (RSC)**
+- **Test-Driven Development (TDD) in React**
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Component Design.md b/10_Wiki/Topics/Frontend_Mastery/React Component Design.md
new file mode 100644
index 00000000..078ad918
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React Component Design.md	
@@ -0,0 +1,45 @@
+## 📌 Brief Summary
+React Component Design은 인터페이스 요소를 구조화하여 확장성, 유지보수성, 성능을 확보하는 아키텍처 실천법이다. 컴포넌트에 SOLID, DRY, KISS와 같은 소프트웨어 공학 원칙을 적용하여 각 컴포넌트가 명확한 책임을 갖고, 비즈니스 로직과 UI가 분리되며, 상호 독립적으로 합성될 수 있는 구조를 만드는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **SOLID 원칙의 컴포넌트적 해석**
+   - **SRP (단일 책임)**: 컴포넌트는 하나의 구체적 역할만 수행해야 하며, 비대해진 로직은 커스텀 훅으로 분리한다.
+   - **OCP (개방-폐쇄)**: 내부 코드를 수정하는 대신 컴포넌트 합성(Composition)이나 `children`을 통해 기능을 확장한다.
+   - **ISP (인터페이스 분리)**: 컴포넌트는 자신이 실제로 사용하는 최소한의 prop에만 의존해야 한다.
+2. **관심사의 분리 (Separation of Concerns)**
+   - UI 컴포넌트에서 비즈니스 로직, 데이터 패칭, 부수 효과를 추출하여 커스텀 훅으로 캡슐화한다.
+   - 이를 통해 UI는 프렌젠테이션 역할에만 집중하고 로직은 독립적으로 테스트 가능한 구조를 확보한다.
+3. **계층적 아키텍처 (FSD)**
+   - 범용 UI(Shared), 비즈니스 엔티티(Entities), 사용자 시나리오(Features) 등으로 컴포넌트의 범위를 계층화하여 관리한다.
+4. **안정성 및 성능 설계**
+   - **Error Boundaries**: 특정 컴포넌트의 런타임 오류가 앱 전체를 멈추지 않도록 선언적으로 장애를 격리한다.
+   - **메모이제이션**: 불필요한 리렌더링 방지를 위해 `React.memo`와 안정적인 `key` 전략을 사용한다.
+5. **명명 컨벤션**
+   - 파일명은 `kebab-case`, 컴포넌트 및 타입은 `PascalCase`, 변수 및 훅은 `camelCase`를 준수하여 일관성을 유지한다.
+
+## ⚖️ Trade-offs & Caveats
+- **추상화 vs 단순함**: 로직 분리와 추상화는 유지보수성을 높이지만, 너무 많은 커스텀 훅과 컴포넌트 분리는 코드를 한눈에 파악하기 어렵게 만드는 '인지적 파편화'를 초래할 수 있다(KISS 원칙과의 충돌).
+- **성능 오버헤드**: `React.memo` 등의 메모이제이션을 남발할 경우, 비교 연산 자체의 비용이 렌더링 비용보다 커지는 역효과가 발생할 수 있다.
+- **설계 시간 비용**: 확장을 고려한 OCP 설계는 초기 개발 시간을 증가시키며, 실제로 발생하지 않을 확장을 대비하는 과잉 엔지니어링(YAGNI 위반)이 될 위험이 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **SOLID Principles**: 고품질 컴포넌트 설계의 기준 (관계: 설계 원칙)
+- **Custom Hooks**: 로직 분리와 재사용의 핵심 도구 (관계: 실천 수단)
+- **Error Boundaries**: 시스템 복원력 확보 (관계: 방어적 설계)
+
+### Deeper Research Questions
+1. 컴포넌트 합성(Composition)을 통해 OCP를 지킬 때 발생하는 'Prop Drilling' 문제를 아키텍처적으로 우아하게 해결하는 방법은?
+2. React Server Components 환경에서 '프레젠테이션과 로직의 분리' 패턴은 어떻게 변화해야 하는가?
+3. `React.memo`를 통한 최적화가 실질적인 성능 이득을 주는지 판단하기 위한 정량적 프로파일링 기준은?
+4. 대규모 폼(Form) 설계 시, ISP를 준수하면서도 유효성 검사 로직의 응집도를 유지하는 컴포넌트 인터페이스 설계법은?
+5. Error Boundary가 포착하지 못하는 비동기 에러를 컴포넌트 생명주기 내부로 끌어들여 통합 처리하는 패턴은?
+
+### Practical Application Contexts
+- **UI 컴포넌트 라이브러리 구축**: 다양한 프로젝트에서 재사용 가능한 고도로 유연한 베이스 컴포넌트 설계.
+- **레거시 컴포넌트 리팩토링**: 1000줄 이상의 거대한 컴포넌트를 기능별로 쪼개고 로직을 훅으로 추출하여 유지보수성 확보.
+
+### Adjacent Topics
+- **React Hooks & Lifecycle**
+- **Feature-Sliced Design (FSD)**
+- **Design Systems & Atomic Design**
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Folder Structure.md b/10_Wiki/Topics/Frontend_Mastery/React Folder Structure.md
new file mode 100644
index 00000000..55c31f0f
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React Folder Structure.md	
@@ -0,0 +1,45 @@
+## 📌 Brief Summary
+React 폴더 구조는 애플리케이션의 디렉터리와 파일을 체계적으로 관리하여 유지보수성, 확장성, 협업 효율성을 높이기 위한 조직화 프레임워크다. 현대 React 생태계에서는 파일 유형 중심의 단순 분리를 넘어, 비즈니스 도메인과 기능을 중심으로 로직과 UI를 응집시키는 **Feature-based** 또는 **Feature-Sliced Design (FSD)** 구조가 권장된다.
+
+## 📖 Core Content
+1. **일반적인 폴더 구조 접근 방식**
+   - **File-Type Based**: 컴포넌트, 훅, 유틸리티 등 기술적 역할에 따라 분류 (소규모에 적합).
+   - **Feature-Based**: 인증, 대시보드 등 비즈니스 기능별로 폴더를 구성하여 캡슐화와 독립적 개발을 가능하게 함.
+2. **2025 권장 하이브리드 구조**
+   - `assets/`: 정적 자원 중앙 관리.
+   - `components/`: 전역 공유 공통 UI 컴포넌트.
+   - `features/`: 도메인 기반 기능 코드 (API, 고유 컴포넌트, 훅 포함).
+   - `services/` (또는 `api/`): 외부 통신 로직 격리.
+   - `store/` 또는 `context/`: 전역 상태 관리 로직.
+3. **Feature-Sliced Design (FSD) 아키텍처**
+   - 책임과 범위에 따라 `app`, `pages`, `widgets`, `features`, `entities`, `shared` 계층으로 분리.
+   - **단방향 의존성**과 **Public API(`index.ts`)** 규칙을 통해 모듈 독립성을 극대화한다.
+4. **네이밍 컨벤션과의 연계**
+   - 컴포넌트는 `PascalCase`, 파일 및 폴더 이름은 운영체제 호환성을 위해 `kebab-case`를 적용하는 것이 표준이다.
+
+## ⚖️ Trade-offs & Caveats
+- **구조적 복잡도**: FSD와 같은 엄격한 아키텍처는 코드의 예측 가능성을 높이지만, 초기 설계 비용이 크고 파일 이동 시 인지적 부하가 발생할 수 있다.
+- **공통 자원 비대화**: 기능별로 나누다 보면 `shared` 폴더가 쓰레기통처럼 비대해질 위험이 있으므로 정기적인 거버넌스가 필요하다.
+- **학습 곡선**: 새로운 팀원이 복잡한 계층 구조를 이해하고 올바른 위치에 코드를 작성하기까지 온보딩 시간이 소요된다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design (FSD)**: 대규모 시스템 구조화의 표준 (관계: 상위 아키텍처)
+- **Separation of Concerns**: 폴더 분리의 근본적 철학 (관계: 설계 원리)
+- **Single Responsibility Principle (SRP)**: 파일 단위 모듈화의 기준 (관계: 개별 컴포넌트 설계 원칙)
+
+### Deeper Research Questions
+1. 프로젝트의 복잡도가 어느 임계점에 도달했을 때 File-type 기반에서 Feature-based 구조로 전환하는 것이 가장 비용 효율적인가?
+2. FSD 구조 내에서 복수의 'Features'가 데이터를 공유해야 할 때, 의존성 순환을 방지하기 위한 'Entities' 레이어 활용법은?
+3. Next.js의 App Router 파일 규약(`page.tsx`, `layout.tsx`)과 커스텀 폴더 구조를 충돌 없이 통합하는 전략은?
+4. `index.ts`를 통한 캡슐화가 트리 쉐이킹(Tree Shaking) 성능에 미치는 구체적인 영향은 무엇인가?
+5. 대규모 팀에서 린트 규칙(ESLint)을 통해 폴더 계층 간의 잘못된 참조를 자동으로 감지하고 차단하는 설정 방안은?
+
+### Practical Application Contexts
+- **신규 대규모 프로젝트 셋업**: 확장성을 고려한 FSD 기반 폴더 구조 설계 및 템플릿화.
+- **레거시 구조 개선**: 엉망으로 섞인 `components` 폴더를 도메인 중심의 `features` 폴더로 점진적 재배치.
+
+### Adjacent Topics
+- **State Management Architectures**
+- **Frontend Naming Conventions**
+- **Micro-Frontends Project Structure**
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Frontend Development.md b/10_Wiki/Topics/Frontend_Mastery/React Frontend Development.md
index cb3cd3de..ce2d3c3a 100644
--- a/10_Wiki/Topics/Frontend_Mastery/React Frontend Development.md	
+++ b/10_Wiki/Topics/Frontend_Mastery/React Frontend Development.md	
@@ -1,35 +1,42 @@
-# [[React [[Frontend]] Development]]
-
-## 📌[[ brief]] Summary
-React는 가상 DOM([[Virtual DOM]])과 컴포넌트 기반 아키텍처(CBA)를 활용하여 사용자 인터페이스를 효율적이고 선언적으로 구축하는 프론트엔드 라이브러리입니다 [1-3]. 브라우저의 비용이 많이 드는 Reflow와 Repaint 작업을 최소화하기 위해 '재조정([[Reconciliation]])' 알고리즘을 사용하며, 최신 버전에서는 Fiber 아키텍처와 자동 메모이제이션([[React Compiler]])을 통해 렌더링 성능을 극대화합니다 [1, 3-5]. 또한, 애플리케이션의 특성에 맞춰 CSR, SSR, SSG 및 [[React Server Components]](RSC) 등 다양한 렌더링 전략을 지원하여 초기 로딩 속도, SEO, 상호작용(Interactivity)의 균형을 맞춥니다 [6-9].
+## 📌 Brief Summary
+React 프론트엔드 개발은 컴포넌트 기반 아키텍처를 통해 현대적인 웹 사용자 인터페이스를 구축하는 공정이다. 비즈니스 기능 중심의 폴더 구조(FSD), 계층화된 상태 관리, 그리고 자동화된 성능 최적화와 에러 핸들링을 결합하여 유지보수 가능하고 확장성 있는 시스템을 구축하는 것을 목표로 한다.
 
 ## 📖 Core Content
-*   **브라우저 렌더링 과정 (CRP) 및 비용 최소화**
-    브라우저의 중요 렌더링 경로([[Critical Rendering Path]])는 HTML과 CSS를 파싱하여 DOM과 [[CSSOM]] 트리를 생성하고, 이를 결합해 렌더 트리([[Render Tree]])를 만듭니다 [10, 11]. 이후 요소의 정확한 위치와 크기를 계산하는 레이아웃(Reflow) 단계와 화면에 픽셀을 그리는 페인트(Repaint) 단계를 거칩니다 [12, 13]. Reflow는 연산 비용이 매우 높으며, 잦은 Reflow와 Repaint는 성능 저하를 유발하므로 DOM 접근과 조작을 최소화하는 것이 필수적입니다 [14-16].
+1. **아키텍처 및 설계 원칙**
+   - **FSD (Feature-Sliced Design)**: 도메인 계층화와 단방향 의존성을 통해 시스템 결합도를 낮춘다.
+   - **SOLID & Clean Code**: 단일 책임 원칙(SRP)을 기반으로 비대해진 로직을 커스텀 훅으로 추출하여 캡슐화한다.
+2. **세분화된 상태 관리**
+   - 정적/글로벌 상태(Context), 빈번한 업데이트(Zustand), 서버 동기화(TanStack Query)로 역할을 분리하여 리렌더링 성능을 극대화한다.
+3. **성능 및 리소스 최적화**
+   - **React Compiler**: 빌드 타임 자동 메모이제이션을 통해 수동 최적화의 인적 오류를 줄인다.
+   - **Code Splitting**: `React.lazy`와 Vite 설정을 통해 번들 크기를 최적화하고 사용자 체감 로딩 속도를 개선한다.
+4. **안정성 및 관측성 (Observability)**
+   - **Error Boundaries**: 런타임 오류 격리로 시스템 복원력을 확보한다.
+   - **모니터링**: Sentry, LogRocket 및 브라우저 메모리 프로파일링을 통해 실시간 에러와 메모리 누수를 추적한다.
 
-*   **Virtual DOM 및 재조정 (Reconciliation)**
-    실제 DOM의 직접적인 조작으로 인한 성능 저하를 막기 위해, React는 메모리에 가벼운 UI 표현인 Virtual DOM을 유지합니다 [1, 3]. 상태가 변경되면 새로운 Virtual DOM을 생성하고 이전 트리와 비교(Diffing)하여 변경된 부분만 실제 DOM에 업데이트합니다 [1, 3]. 이 재조정 알고리즘은 요소의 타입 비교 및 리스트의 `key` 속성을 활용해 $O(n^3)$의 복잡도를 $O(n)$으로 최적화합니다 [17-20].
-
-*   **[[React Fiber]] 아키텍처와 동시성 렌더링 ([[Concurrent Rendering]])**
-    React 16에 도입된 Fiber 아키텍처는 렌더링 작업을 'Fiber 노드'라는 작은 작업 단위로 분할하여 동시성 렌더링을 가능하게 합니다 [21-23]. 우선순위 기반 모델([[Lane Model]])과 시간 분할([[Time-Slicing]])을 적용하여, 사용자의 입력(타이핑, 클릭 등)과 같은 긴급한 작업이 들어오면 무거운 렌더링 작업을 잠시 중단(Yield)하고 메인 스레드를 비워두어 UI의 반응성을 유지합니다 [22, 24-26].
-
-*   **컴포넌트 기반 아키텍처 ([[Component-Based Architecture]])**
-    애플리케이션을 독립적이고 재사용 가능한 컴포넌트 단위로 분할하여 구축합니다 [27-29]. 각 컴포넌트는 자체 로직과 UI 상태를 캡슐화하여 렌더링하므로 유지보수성과 확장성이 높으며, 다른 프로젝트에서도 재사용하기 쉽습니다 [30-32].
-
-*   **렌더링 전략: [[CSR vs SSR vs SSG]] vs RSC**
-    *   **CSR (Client-Side Rendering):** 서버에서 빈 HTML을 받고 브라우저가 [[JavaScript]]를 다운로드하여 UI를 그립니다. 동적 상호작용에 유리하지만, JS 다운로드 전까지 화면이 보이지 않아 초기 로딩과 SEO에 불리합니다 [6, 33-35].
-    *   **SSR (Server-Side Rendering):** 서버에서 HTML을 미리 렌더링하여 전송하므로 초기 콘텐츠 표시가 빠르고 SEO에 유리합니다 [7, 36, 37]. 이후 브라우저에서 JS를 연결해 상호작용을 가능하게 하는 수화([[Hydration]]) 과정을 거칩니다 [7, 36, 38].
-    *   **SSG (Static Site Generation):** 빌드 타임에 HTML을 생성하여 CDN으로 배포하므로 로딩 속도가 가장 빠릅니다 [8, 39].
-    *   **[[React [[Server Components]] (RSC)]]:** 서버에서만 렌더링되며 클라이언트로 JavaScript 번들을 전혀 보내지 않습니다 [9, 40]. 번들 크기를 줄이고 서버 데이터베이스에 직접 접근할 수 있으며, 상호작용이 필요한 곳에만 Client Component를 혼합해 사용할 수 있습니다 [41-43].
-
-*   **최신 렌더링 최적화 기법 ([[React 18]] & 19)**
-    *   **자동 배칭 ([[Automatic Batching]]):** React 18부터는 이벤트 핸들러뿐만 아니라 Promise, setTimeout 등 비동기 작업 내의 여러 상태 업데이트를 하나로 묶어([[Batching]]) 단일 리렌더링만 유발합니다 [44-46].
-    *   **React Compiler:** [[React 19]]에 도입된 빌드 타임 최적화 도구로, 개발자가 수동으로 작성하던 `useMemo`, `useCallback`을 제거하고 AST를 분석해 자동으로 메모이제이션 경계를 삽입합니다 [5, 47-49]. 이를 통해 불필요한 연산과 리렌더링을 지능적으로 방지합니다 [49, 50].
+## ⚖️ Trade-offs & Caveats
+- **기술 스택 파편화**: 상태 관리나 렌더링 방식(SSR vs CSR)에 따라 너무 많은 도구를 도입할 경우, 프로젝트의 복잡도가 기하급수적으로 상승하고 유지보수 비용이 증가한다.
+- **성능 최적화의 함정**: `useMemo`나 `useCallback`의 남발은 오히려 비교 연산 오버헤드를 발생시킬 수 있으므로, 실제 병목 지점을 프로파일링한 후 적용해야 한다.
+- **규격화의 인지적 비용**: 엄격한 네이밍 규칙과 아키텍처는 신규 개발자의 온보딩을 어렵게 만들 수 있으므로, 자동화된 린트 규칙과 문서화가 필수적이다.
 
 ## 🔗 Knowledge Connections
-- **Related Topics:** [[Virtual DOM]], [[Critical Rendering Path (CRP)]], [[React Fiber]], [[Component-Based Architecture]], [[Client-Side Rendering (CSR)]], [[Server-Side Rendering (SSR)]], [[React Server Components (RSC)]]
-- **Projects/Contexts:** [[Next.js]], Single-Page Applications (SPA)
-- **Contradictions/Notes:** React Compiler의 도입으로 `React.memo`, `useMemo`, `useCallback`과 같은 수동 메모이제이션이 90% 이상 불필요해졌으나, 서드파티 라이브러리의 불안정한 객체 참조를 다루거나 특정 Effect 의존성을 명시적으로 제어해야 하는 경우에는 여전히 탈출구(Escape Hatch)로써 수동 메모이제이션의 사용이 필요할 수 있습니다 [51-53].
+### Related Concepts
+- **Feature-Sliced Design (FSD)**: 확장 가능한 구조 설계 방법론 (관계: 구조적 가이드라인)
+- **Zustand & TanStack Query**: 성능 중심의 상태 관리 전략 (관계: 데이터 레이어 도구)
+- **React Compiler**: 차세대 자동 최적화 메커니즘 (관계: 성능 최신화)
 
----
-*Last updated: 2026-04-25*
\ No newline at end of file
+### Deeper Research Questions
+1. FSD 아키텍처에서 인증(Auth)과 같은 전역 관심사를 특정 레이어에 배치할 때 발생하는 의존성 딜레마를 어떻게 해결하는가?
+2. React Compiler 도입 시, 참조 안정성을 보장하지 않는 서드파티 라이브러리들과의 상호 운용성 한계는 무엇인가?
+3. Zustand의 외부 스토어 모델이 React의 Concurrent Rendering 모드와 충돌할 가능성과 그 해결책은?
+4. 모바일 및 저사양 기기에서 Hydration 비용을 최소화하기 위한 'Partial Hydration' 또는 'Islands Architecture'의 React적 구현 방안은?
+5. 프로덕션 환경에서 'Detached DOM nodes'로 인한 메모리 누수를 감지하기 위한 자동화된 회귀 테스트 구축이 가능한가?
+
+### Practical Application Contexts
+- **대규모 웹 앱 구축**: 수천 개의 컴포넌트를 가진 복잡한 대시보드나 SaaS 플랫폼의 안정적 개발.
+- **성능 중심 리팩토링**: 로딩 속도가 느리고 리렌더링이 빈번한 기존 프로젝트를 최신 아키텍처와 도구로 현대화.
+
+### Adjacent Topics
+- **Vite Build Optimization**
+- **Frontend Observability & Logging**
+- **Web Accessibility (A11y) & Core Web Vitals**
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Refactoring.md b/10_Wiki/Topics/Frontend_Mastery/React Refactoring.md
new file mode 100644
index 00000000..0e250f3a
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React Refactoring.md	
@@ -0,0 +1,42 @@
+## 📌 Brief Summary
+React Refactoring은 기존 애플리케이션의 외부 동작을 유지하면서 내부 구조, 가독성, 모듈성을 현대적 표준에 맞게 개선하는 작업이다. 클래스형 컴포넌트의 현대화, 비대한 컴포넌트의 분리, 최신 상태 관리 스택(Zustand, Query) 도입을 통해 기술 부채를 상환하고 확장 가능한 시스템으로 진화시키는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **안전망 확보 (Testing First)**
+   - 리팩토링 전 기능 깨짐을 방지하기 위해 단위 테스트와 UI 테스트 수트를 먼저 구축한다.
+2. **현대적 패러다임 마이그레이션**
+   - 클래스 컴포넌트를 함수형 컴포넌트와 훅으로 전환하고, 불필요한 `useEffect`를 제거한다.
+   - JavaScript 코드를 TypeScript로 점진적으로 전환하여 정적 안정성을 확보한다.
+3. **커스텀 훅을 통한 로직 분리 (SRP)**
+   - 300줄 이상의 컴포넌트에서 비즈니스 로직(데이터 패칭, 폼 처리 등)을 추출하여 커스텀 훅으로 캡슐화한다.
+4. **상태 관리 최신화**
+   - 무거운 단일 스토어(Redux 등)를 걷어내고 서버 상태(TanStack Query)와 클라이언트 전역 상태(Zustand/Context)로 분리한다.
+5. **점진적 마이그레이션 전략**
+   - 전체 재작성보다는 "Refactor, do not rewrite" 철학을 바탕으로 기능 단위의 단계적 전환을 수행한다.
+
+## ⚖️ Trade-offs & Caveats
+- **일시적 코드 중복**: 마이그레이션 과도기에는 구형 로직과 신규 로직이 공존하여 코드베이스가 일시적으로 지저분해질 수 있다.
+- **성능 회귀 위험**: 클래스 생명주기를 `useEffect`로 옮기는 과정에서 의도치 않은 무한 루프나 불필요한 렌더링이 발생할 수 있으므로 면밀한 검증이 필요하다.
+- **리팩토링 비용**: 당장의 기능 개발보다 시간이 많이 소요될 수 있으므로, 비즈니스 가치와 우선순위를 고려한 리팩토링 범위 설정이 중요하다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Custom Hooks**: 로직 분리의 핵심 단위 (관계: 실천 도구)
+- **SOLID Principles**: 구조 개선의 설계 기준 (관계: 이론적 근거)
+- **TanStack Query**: 서버 상태 관리에 최적화된 리팩토링 대상 (관계: 주요 마이그레이션 스택)
+
+### Deeper Research Questions
+1. 대규모 리팩토링 시 신/구 상태 관리 시스템 간의 데이터 동기화를 유지하기 위한 'Adapter' 패턴의 적용 방안은?
+2. `useEffect`를 제거하고 상태 업데이트 로직을 이벤트 핸들러나 훅 내부로 옮길 때 발생하는 동기화 시점 차이 문제 해결법은?
+3. FSD 아키텍처로 리팩토링 시, 기존에 얽혀있던 교차 관심사(Cross-cutting concerns)를 어떻게 안전하게 분리할 것인가?
+4. 리팩토링 과정에서 발생하는 'Breaking Changes'를 팀원들에게 공유하고 코드 일관성을 유지하기 위한 자동화된 문서화 방안은?
+5. TypeScript 전환 시 'Any' 타입을 점진적으로 제거하기 위한 정적 분석 도구 활용 전략은?
+
+### Practical Application Contexts
+- **레거시 React 앱 현대화**: 오래된 클래스 컴포넌트 기반 프로젝트를 최신 훅 및 상태 관리 체계로 개선.
+- **성능 및 유지보수성 강화**: 복잡하게 얽힌 컴포넌트들을 SRP 원칙에 따라 작고 명확한 단위로 분해.
+
+### Adjacent Topics
+- **Legacy System Migration**
+- **Clean Code & Refactoring Patterns**
+- **Frontend Observability**
diff --git a/10_Wiki/Topics/Frontend_Mastery/React Server Components.md b/10_Wiki/Topics/Frontend_Mastery/React Server Components.md
index 9ca6318c..e6dc215b 100644
--- a/10_Wiki/Topics/Frontend_Mastery/React Server Components.md	
+++ b/10_Wiki/Topics/Frontend_Mastery/React Server Components.md	
@@ -1,18 +1,40 @@
-# [[React Server Components]]
-
-## 📌[[ brief]] Summary
-React [[Server Components]](RSC)는 브라우저가 아닌 서버에서만 독점적으로 렌더링되어 클라이언트로 [[JavaScript]] 번들을 전송하지 않는 React의 혁신적인 렌더링 아키텍처입니다 [1]. 이 환경에서는 [[React Context]]에 대한 접근이 불가능하기 때문에 기존의 런타임 기반 스타일링 도구와의 호환성 문제를 야기했으며, 프론트엔드의 스타일링 패러다임에 큰 변화를 가져왔습니다 [2, 3]. 결과적으로 확장 가능한 프론트엔드 아키텍처를 구축하려면 서버와 클라이언트 컴포넌트의 역할을 명확히 분리하고 RSC 환경에 최적화된 스타일링 전략을 채택하는 것이 필수적입니다 [4, 5].
+## 📌 Brief Summary
+React Server Components(RSC)는 서버에서만 실행되어 클라이언트로 전송되는 자바스크립트 번들 크기를 획기적으로 줄이는 성능 최적화 아키텍처다. 상호작용이 없는 정적 UI는 서버에서 완전히 렌더링하고 필요한 클라이언트 컴포넌트만 브라우저로 전송함으로써, 하이드레이션 비용을 절감하고 초기 로딩 속도를 극대화한다.
 
 ## 📖 Core Content
-* **RSC의 동작 원리와 컴포넌트 구성**: 서버 컴포넌트는 완전히 서버에서 실행되어 데이터베이스에 직접 접근할 수 있으며, 렌더링된 정적 HTML만을 클라이언트에 전달하므로 성능 최적화와 보안 유지에 탁월합니다 [1]. 반면, 컴포넌트에 상태([[State]])나 이벤트 핸들러 같은 브라우저 상호작용이 필요한 경우에 한해 `'use client'` 지시어를 명시하여 클라이언트 컴포넌트로 분리해야 합니다 [6]. 모범적인 아키텍처 구성을 위해서는 데이터 패칭을 서버 컴포넌트에서 처리하고 상호작용이 필요한 최소한의 영역만 클라이언트 컴포넌트로 유지해야 합니다 [5, 7].
-* **기존 [[CSS-in-JS]] 아키텍처와의 마찰**: RSC의 서버 전용 렌더링 환경은 기존 프론트엔드 생태계에 큰 영향을 미쳤습니다. 특히 `[[styled-components]]`나 `Emotion`과 같은 런타임 CSS-in-JS 라이브러리는 테마 주입을 위해 내부적으로 React Context에 크게 의존하는데, RSC 환경에는 React Context가 존재하지 않으므로 구조적인 비호환성(incompatibility)이 발생합니다 [2, 3, 8].
-* **현대적인 스타일링 및 렌더링 전략**: 위와 같은 호환성 문제로 인해 현재 [[Next.js App Router]]를 비롯한 RSC 환경에서는 런타임 오버헤드가 없는 빌드 타임 스타일링 방식이 강력히 권장됩니다 [2, 9]. 정적 CSS를 생성하는 `[[Tailwind CSS]]`, `[[CSS Modules]]` 또는 [[Zero-Runtime CSS-in-JS]]인 `[[vanilla-extract]]`를 도입하는 것이 성능을 향상시키고 복잡성을 줄이는 핵심 전략입니다 [3, 4, 9]. RSC 환경에서는 수많은 고유 클래스를 런타임에 동적으로 생성하기보다, 정적인 스타일을 유지하되 데이터 속성(`data-*` attributes)을 변경하여 상태 변형을 제어하는 방식이 성능 최적화에 유리합니다 [10].
-* **Styled-components의 RSC 지원 및 우회 방식**: 완전한 대안으로 전환하지 못하는 프로젝트를 위해 `styled-components`는 v6.3.0부터 RSC 환경을 자동 감지하는 패치를 적용했습니다 [11]. RSC 환경에서는 `ThemeProvider`가 아무 동작도 하지 않는 패스스루(no-op)로 변하기 때문에, 이를 대체할 수 있도록 CSS Custom Properties(변수) 기반의 테마를 생성하는 `createTheme` 헬퍼 함수를 사용할 것을 권장합니다 [12, 13]. 또한 SSR 시 스타일이 유실되지 않도록 서버에서 렌더링 중 CSS를 수집하여 삽입하는 `[[Style Registry]]` 패턴을 구성해야 하며, 인라인 스타일 태그 삽입으로 인해 깨질 수 있는 자식 인덱스 선택자 문제(`:first-child` 등)를 방지하기 위한 `stylisPluginRSC` 플러그인도 함께 제공됩니다 [14, 15].
+1. **서버 사이드 전용 렌더링**
+   - 서버 컴포넌트는 클라이언트 번들에 포함되지 않아 번들 사이즈가 줄어들고 데이터베이스/API에 직접 접근이 가능하다.
+2. **번들 및 하이드레이션 최적화**
+   - 정적 UI를 서버에서 미리 렌더링하여 클라이언트의 JS 실행 비용(TTI, Total Blocking Time)을 최소화한다.
+3. **컴포넌트 조합 패턴**
+   - `use client` 지시어를 통해 상호작용이 필요한 영역만 클라이언트 컴포넌트로 선택적으로 정의한다.
+   - 서버 컴포넌트를 기본으로 사용하되, 사용자 인터랙션이 필요한 지점에서만 클라이언트 경계를 설정하는 것이 권장된다.
+4. **이중 페칭(Double Fetching) 해결**
+   - 브라우저에서 데이터를 요청하고 받는 대기 시간을 줄이기 위해 서버 내부에서 데이터를 직접 페칭하여 렌더링에 반영한다.
+
+## ⚖️ Trade-offs & Caveats
+- **환경 및 도구 제약**: 현재 주로 Next.js App Router와 같은 특정 프레임워크 환경에서만 안정적으로 작동하며, 기존 Pages Router와는 호환되지 않는다.
+- **상태 및 훅의 한계**: 서버 컴포넌트 내에서는 `useState`, `useEffect` 등의 클라이언트 전용 훅과 브라우저 API를 사용할 수 없다.
+- **구조적 복잡성**: 서버와 클라이언트 컴포넌트 간의 경계 설계 및 데이터 직렬화(Serialization) 이슈를 관리해야 하는 설계적 부담이 존재한다.
 
 ## 🔗 Knowledge Connections
-- **Related Topics:** [[Tailwind CSS]], [[Styled-components]], [[CSS-in-JS]], Zero-runtime CSS
-- **Projects/Contexts:** [[Next.js App Router]]
-- **Contradictions/Notes:** 소스 [2, 3, 8]에서는 `styled-components` 등 런타임 CSS-in-JS가 React Context 부재로 인해 RSC와 근본적으로 호환되지 않으므로 [[Next.js]] App Router 환경에서 피해야 한다고 설명합니다. 하지만 소스 [11-14]에 따르면, `styled-components`는 최신 업데이트를 통해 RSC 환경을 스스로 감지하고 Context 의존을 탈피하여 CSS Custom Properties를 사용하는 새로운 API 및 자동 스타일 인라인 주입 기능으로 RSC 환경에서의 사용을 계속해서 지원하고 있습니다.
+### Related Concepts
+- **Next.js App Router**: RSC의 표준 구현체 (관계: 구동 환경)
+- **Hydration**: RSC를 통해 비용을 절감하고자 하는 대상 과정 (관계: 최적화 목표)
+- **Client Components**: 상호작용을 위한 RSC의 보완재 (관계: 상호 운용 관계)
 
----
-*Last updated: 2026-04-26*
\ No newline at end of file
+### Deeper Research Questions
+1. RSC와 기존 SSR(Server Side Rendering)은 데이터 전달 방식과 번들링 메커니즘에서 구체적으로 어떤 기술적 차이가 있는가?
+2. 서버와 클라이언트 경계에서 데이터를 Props로 넘길 때 발생하는 '직렬화 가능성' 제약 조건을 해결하기 위한 패턴은?
+3. RSC를 사용할 때 서버 부하를 제어하고 효율적으로 데이터를 캐싱하기 위한 'Request Memoization' 전략은?
+4. 서드파티 라이브러리(예: CSS-in-JS, UI Kits)가 서버 컴포넌트 환경을 지원하지 않을 때의 우회 방법론은?
+5. RSC 환경에서 보안 민감 정보(API Key 등)가 클라이언트로 유출되지 않도록 보장하는 'Server-only' 모듈 활용 방안은?
+
+### Practical Application Contexts
+- **고성능 웹 서비스 구축**: 대규모 이커머스나 뉴스 미디어 같이 초기 로딩 속도가 비즈니스 지표에 직결되는 사이트 개발.
+- **번들 다이어트**: 무거운 서드파티 라이브러리를 서버 측에서만 실행하여 클라이언트 자산 최소화.
+
+### Adjacent Topics
+- **Code Splitting & Streaming SSR**
+- **Core Web Vitals Optimization**
+- **Edge Computing & Serverless Functions**
\ No newline at end of file
diff --git a/10_Wiki/Topics/Frontend_Mastery/React.md b/10_Wiki/Topics/Frontend_Mastery/React.md
new file mode 100644
index 00000000..c75e6db5
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/React.md
@@ -0,0 +1,42 @@
+## 📌 Brief Summary
+React는 사용자 인터페이스를 상태(State)와 속성(Props)의 순수 함수로 표현하여 예측 가능성과 테스트 용이성을 극대화하는 선언형(Declarative) UI 라이브러리다. 컴포넌트 기반 아키텍처와 훅(Hooks) 시스템을 통해 모듈화된 웹 애플리케이션 구축을 지원하며, 현대적인 아키텍처(FSD) 및 최적화 도구(React Compiler)를 결합하여 대규모 시스템으로 확장 가능하다.
+
+## 📖 Core Content
+1. **확장 가능한 아키텍처 (FSD)**
+   - 단순 파일 타입 분리에서 벗어나 비즈니스 기능(Feature) 중심으로 코드를 그룹화하여 결합도를 낮추고 캡슐화를 강화한다.
+2. **세분화된 상태 관리**
+   - 로컬 상태, 전역 앱 상태(Zustand/Redux), 서버 상태(TanStack Query)로 역할을 분리하여 리렌더링 폭포 현상을 방지한다.
+3. **자동화된 성능 최적화**
+   - **React Compiler**: 빌드 타임 자동 메모이제이션으로 수동 `useMemo` 등의 오류를 해결하고 런타임 성능을 개선한다.
+   - **코드 스플리팅**: `React.lazy`와 Suspense를 통해 번들 크기를 최적화한다.
+4. **복원력 있는 에러 핸들링**
+   - **Error Boundaries**: 런타임 자바스크립트 에러를 포착하여 전체 앱 다운을 방지하고 Fallback UI를 제공한다.
+5. **엔지니어링 원칙의 준수**
+   - SOLID, DRY, KISS, YAGNI 원칙을 컴포넌트 및 커스텀 훅 설계에 철저히 적용하여 기술 부채를 최소화한다.
+
+## ⚖️ Trade-offs & Caveats
+- **자유도의 대가**: 특정 구조를 강제하지 않으므로, 프로젝트 초기 단계에서 명확한 아키텍처 가이드라인이 부재할 경우 코드베이스가 빠르게 스파게티화될 수 있다.
+- **추상화 비용**: 훅과 컴포넌트 합성을 통한 고도의 추상화는 재사용성을 높이지만, 과할 경우 코드의 흐름을 파악하기 어렵게 만드는 인지적 부하를 초래한다.
+- **버전 변화의 속도**: Server Components, React Compiler 등 패러다임이 빠르게 변화하므로 팀의 기술 스택을 지속적으로 업데이트해야 하는 운영 부담이 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design (FSD)**: 대규모 구조화의 표준 (관계: 아키텍처 모델)
+- **React Compiler**: 차세대 자동 최적화 장치 (관계: 성능 개선 도구)
+- **State Management**: 데이터 흐름 제어의 핵심 (관계: 시스템 신경망)
+
+### Deeper Research Questions
+1. React Compiler 안정화 이후, 수동 메모이제이션(useMemo 등)이 여전히 필요한 유일한 시나리오는 무엇인가?
+2. FSD 아키텍처에서 'Entities'와 'Features' 간의 의존성 역전을 통해 도메인 순수성을 유지하는 가장 우아한 방법은?
+3. Context API의 브로드캐스트 성능 문제를 해결하기 위한 'Context Splitting' 패턴의 한계와 대안은?
+4. Error Boundary가 잡지 못하는 비동기 에러를 전역 모니터링 시스템과 통합하기 위한 최적의 아키텍처 설계는?
+5. Concurrent Mode에서 `useTransition`과 `useDeferredValue`가 실제 사용자 체감 성능(INP)에 미치는 정량적 영향은?
+
+### Practical Application Contexts
+- **신규 프로젝트 설계**: FSD 폴더 구조와 상태 관리 스택(Zustand/Query) 선정을 통한 안정적 개발 기반 마련.
+- **레거시 코드 현대화**: 클래스 컴포넌트를 훅 기반으로 전환하고 불필요한 이펙트를 제거하여 성능과 유지보수성 강화.
+
+### Adjacent Topics
+- **Vite & Modern Build Tooling**
+- **Design Systems & Storybook**
+- **Server Components (RSC) & Streaming**
diff --git a/10_Wiki/Topics/Frontend_Mastery/Scalable Frontend Architecture.md b/10_Wiki/Topics/Frontend_Mastery/Scalable Frontend Architecture.md
new file mode 100644
index 00000000..8dfe7736
--- /dev/null
+++ b/10_Wiki/Topics/Frontend_Mastery/Scalable Frontend Architecture.md	
@@ -0,0 +1,44 @@
+## 📌 Brief Summary
+Scalable Frontend Architecture는 단순한 스크립트 모음을 넘어 고성능과 유지보수성을 갖춘 정교한 분산 시스템을 구축하는 설계 방식이다. 비즈니스 로직과 UI의 분리, 명확한 상태 소유권, 모듈 간 낮은 결합도를 통해 팀의 규모와 제품의 기능이 확장되어도 안전하게 성장할 수 있는 기반을 제공한다.
+
+## 📖 Core Content
+1. **기능 중심 조직 (Feature-Sliced Design)**
+   - 앱을 `app`, `pages`, `widgets`, `features`, `entities`, `shared` 계층으로 나누어 도메인 경계를 명확히 한다.
+   - 단방향 의존성 규칙과 Public API(`index.ts`)를 통해 캡슐화를 실현하고 모듈 간 간섭을 차단한다.
+2. **소프트웨어 엔지니어링 원칙 적용**
+   - **SOLID**: 컴포넌트를 단일 책임(SRP)으로 분해하고 합성(OCP)을 통해 확장한다.
+   - **DRY & KISS**: 커스텀 훅으로 중복을 제거하되, 과도한 추상화로 인한 복잡성은 경계한다.
+3. **분업화된 상태 관리 아키텍처**
+   - 데이터 성격에 따라 정적 상태(Context), 동적 상태(Zustand), 서버 상태(TanStack Query)로 도구를 세분화하여 리렌더링 성능을 최적화한다.
+4. **성능 및 렌더링 거버넌스**
+   - Vite의 `manualChunks`를 통한 번들 분할과 `React.lazy`를 이용한 라우트 레벨의 코드 스플리팅을 적용한다.
+   - React Compiler 또는 수동 메모이제이션을 통해 불필요한 연산 비용을 최소화한다.
+5. **장애 격리 및 복원력 (Resilience)**
+   - Error Boundaries를 전략적으로 배치하여 특정 모듈의 오류가 전체 시스템 다운으로 이어지지 않도록 방어한다.
+
+## ⚖️ Trade-offs & Caveats
+- **아키텍처 오버헤드**: FSD와 같은 엄격한 레이어링은 간단한 기능 추가에도 여러 파일을 생성하게 만들어 초기 개발 속도를 늦출 수 있다.
+- **도입 비용 및 학습 곡선**: 팀 전체가 아키텍처 원칙을 이해하고 준수하기까지 상당한 온보딩 시간과 코드 리뷰 비용이 소요된다.
+- **유연성 감소**: 너무 엄격한 규칙은 때로 빠른 실험이 필요한 스타트업 환경에서 민첩성을 저해하는 족쇄가 될 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Feature-Sliced Design (FSD)**: 구조적 캡슐화의 핵심 (관계: 핵심 방법론)
+- **SOLID Principles**: 견고한 컴포넌트 설계의 근간 (관계: 설계 철학)
+- **Error Boundaries**: 시스템 복원력 확보 (관계: 방어적 설계)
+
+### Deeper Research Questions
+1. FSD 계층 구조에서 'Features'와 'Widgets' 간의 순환 참조를 방지하면서 복잡한 UI를 조합하는 최적의 패턴은?
+2. 상태 관리 도구의 선택이 실제 런타임 성능(TBT, INP)에 미치는 정량적 영향과 아키텍처적 가치는?
+3. React Compiler 도입이 기존의 수동 최적화 기반 아키텍처 설계 원칙을 어떻게 근본적으로 변화시키는가?
+4. 코드 스플리팅 적용 시 발생할 수 있는 'Network Waterfall' 현상을 방지하기 위한 리소스 프리패칭 전략은?
+5. 마이크로 프론트엔드 환경에서 각 팀이 독립적인 아키텍처를 유지하면서도 전역적인 일관성을 확보하는 방법은?
+
+### Practical Application Contexts
+- **엔터프라이즈급 제품 개발**: 수백 명의 개발자가 협업하는 대규모 SaaS 플랫폼의 안정적 구조 설계.
+- **모노레포 환경 구축**: 여러 서비스가 공통 모듈을 공유하면서도 독립적으로 배포되는 시스템 아키텍처 수립.
+
+### Adjacent Topics
+- **Micro-Frontends Architecture**
+- **React Server Components (RSC)**
+- **CI/CD & Automated Governance**
diff --git a/10_Wiki/Topics/Infrastructure & Automation/Git Branching Strategy.md b/10_Wiki/Topics/Infrastructure & Automation/Git Branching Strategy.md
new file mode 100644
index 00000000..903817e7
--- /dev/null
+++ b/10_Wiki/Topics/Infrastructure & Automation/Git Branching Strategy.md	
@@ -0,0 +1,43 @@
+## 📌 Brief Summary
+Git Branching Strategy 및 협업 워크플로우는 다수의 개발자가 하나의 코드베이스에서 안전하고 효율적으로 협업하기 위한 체계적인 약속이다. 브랜치 명명 규칙, 커밋 메시지 표준화, Pull Request(PR) 기반의 코드 리뷰 프로세스를 통해 코드의 안정성을 유지하고 변경 이력의 추적성(Traceability)을 확보하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **주요 브랜칭 전략**
+   - **Feature-Branch Workflow**: 짧은 수명의 브랜치를 통해 기능을 격리 개발하고 `main`의 안정성을 유지하는 소규모 팀 최적화 방식.
+   - **Trunk-Based Development**: 메인 브랜치에 매우 빈번하게 병합하여 빠른 피드백을 추구하는 경량화 전략.
+   - **GitHub Flow**: 지속적 배포에 적합한 단순한 구조로 `main` 브랜치는 항상 배포 가능 상태를 유지한다.
+2. **브랜치 및 커밋 거버넌스**
+   - **명명 규칙**: `{type}/{ticket-id}-{description}` 형식을 준수하여 작업의 성격과 비즈니스 맥락(티켓 ID)을 연결한다.
+   - **Conventional Commits**: `feat:`, `fix:`, `refactor:` 등 표준 접두사를 사용하여 변경의 의도를 명확히 하고 릴리즈 노트를 자동화한다.
+   - **원자적 커밋 (Atomic Commits)**: 하나의 커밋에는 하나의 논리적 변경만 담아 롤백 및 디버깅을 용이하게 한다.
+3. **Pull Request(PR) 및 코드 리뷰**
+   - 최소 1명 이상의 승인을 거치는 게이트웨이 프로세스를 구축한다.
+   - **Squash Merge**: 기능 브랜치의 자잘한 이력을 압축하여 메인 브랜치의 히스토리를 깔끔하게 관리한다.
+   - **CI 연동**: PR 생성 시 빌드 및 테스트 자동 통과를 필수 조건으로 설정한다.
+
+## ⚖️ Trade-offs & Caveats
+- **속도 vs 안정성**: 엄격한 PR 리뷰와 브랜칭 전략은 안정성을 높이지만, 긴급한 배포가 필요한 상황에서는 병목 지점이 될 수 있다.
+- **수명이 긴 브랜치의 위험**: 메인 브랜치와 장시간 동기화되지 않은 브랜치는 병합 시 '머지 지옥(Merge Hell)'을 유발하므로 잦은 리베이스와 동기화가 필수적이다.
+- **커밋 압축의 정보 소실**: Squash Merge는 히스토리를 깨끗하게 만들지만, 기능 브랜치 내부의 세부적인 결정 과정을 추적하기 어렵게 만들 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Pull Request (PR)**: 코드 품질의 최종 관문 (관계: 실천 프로세스)
+- **Conventional Commits**: 변경 이력의 표준화 (관계: 커밋 가이드라인)
+- **Trunk-Based Development**: 고속 반복 개발을 위한 전략 (관계: 대안 방법론)
+
+### Deeper Research Questions
+1. 티켓 ID(Jira/GitHub)와 Git 커밋을 연동하여 개발 진척도를 자동으로 대시보드화하는 최적의 CI 설정은?
+2. 'Merge'와 'Rebase' 중 팀의 히스토리 관리 철학에 따라 어떤 것을 기본 전략으로 삼아야 하는가?
+3. 대규모 충돌을 방지하기 위해 Feature Flag를 도입하여 수명이 긴 브랜치를 Trunk-Based로 전환하는 구체적인 절차는?
+4. 코드 리뷰 시 기술적 결함 외에 아키텍처적 일관성을 검증하기 위한 '체크리스트'의 구성 요소는 무엇인가?
+5. 커밋 메시지 규칙 준수를 강제하기 위해 Git Hooks(Husky)와 commitlint를 연동하는 최적의 환경 구성은?
+
+### Practical Application Contexts
+- **팀 협업 표준화**: 3인 이상 팀 프로젝트 시작 시 브랜칭 전략과 커밋 컨벤션 합의 및 문서화.
+- **이슈 추적성 강화**: 장애 발생 시 특정 티켓 ID와 연관된 커밋을 역추적하여 근본 원인 신속 파악.
+
+### Adjacent Topics
+- **CI/CD Pipeline Automation**
+- **GitHub Actions / GitLab CI**
+- **Semantic Versioning (SemVer)**
diff --git a/10_Wiki/Topics/Programming & Tools/Debugging Methods.md b/10_Wiki/Topics/Programming & Tools/Debugging Methods.md
new file mode 100644
index 00000000..cb65b167
--- /dev/null
+++ b/10_Wiki/Topics/Programming & Tools/Debugging Methods.md	
@@ -0,0 +1,41 @@
+## 📌 Brief Summary
+현대 프론트엔드 디버깅은 런타임 에러 포착, 성능 병목 진단, 상태 불일치 해결을 아우르는 체계적인 분석 과정이다. 브라우저 개발자 도구(Chrome DevTools)를 통한 로컬 분석부터 Sentry, Datadog과 같은 관측성(Observability) 플랫폼을 활용한 프로덕션 모니터링까지 통합적인 접근을 통해 시스템의 신뢰성을 확보한다.
+
+## 📖 Core Content
+1. **프로덕션 관측성 (Observability Platforms)**
+   - Sentry, LogRocket 등을 통한 실시간 에러 그룹화 및 사용자 여정(Breadcrumbs) 추적.
+   - **세션 리플레이(Session Replay)**: 에러 발생 전의 사용자 조작과 상태 변화를 시각적으로 재현하여 재현 불가능한 버그 차단.
+   - **분산 트레이싱**: 프론트엔드 에러와 백엔드 트레이스 ID를 연결하여 엔드-투-엔드 문제 진단.
+2. **메모리 누수 진단 (Memory Profiling)**
+   - Chrome DevTools의 **Heap Snapshots**을 비교하여 분리된 DOM 노드(Detached DOM nodes)와 가비지 컬렉션(GC)되지 않는 객체 식별.
+   - **Allocation Timelines**: 메모리 할당 시점과 리테이너 경로(Retainer paths)를 분석하여 객체 보존 원인 파악.
+3. **상태 및 렌더링 디버깅**
+   - **Time-travel Debugging**: Redux DevTools 등을 통해 상태 변화를 기록하고 특정 시점으로 액션을 재생하여 비동기 버그 추적.
+   - **Error Boundaries**: React의 렌더링 에러를 선언적으로 포착하여 전체 앱 크래시를 방지하고 에러 스택 정보를 확보.
+
+## ⚖️ Trade-offs & Caveats
+- **로깅 오버헤드**: 과도한 로깅 및 관측성 도구 도입은 번들 사이즈 증가와 런타임 성능 저하를 유발할 수 있으므로 샘플링 전략이 필요하다.
+- **데이터 프라이버시**: 세션 리플레이 및 클라우드 로깅 시 사용자 민감 정보(비밀번호, PII)가 노출되지 않도록 엄격한 마스킹 처리가 선행되어야 한다.
+- **디버깅 도구의 제약**: React Context 등 특정 상태 관리 모델은 전용 디버깅 툴의 부재로 인해 문제 추적이 상대적으로 어렵다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Heap Snapshots**: 자바스크립트 메모리 구조의 정적 분석 도구 (관계: 메모리 진단 핵심)
+- **Error Boundaries**: 런타임 에러 전파를 차단하는 선언적 격리 장치 (관계: 안정성 확보)
+- **Time-Travel Debugging**: 상태 불일치 원인을 규명하는 시계열 분석 기법 (관계: 비동기 로직 검증)
+
+### Deeper Research Questions
+1. OpenTelemetry를 활용하여 프론트엔드와 마이크로서비스 백엔드 간의 트레이스 컨텍스트를 어떻게 안전하게 전파하는가?
+2. Heap Snapshot 분석 시 'Shallow Size'와 'Retained Size'의 차이가 의미하는 가비지 컬렉션의 실제 작동 원리는?
+3. 세션 리플레이 도구가 캔버스(Canvas)나 WebGL 기반 렌더링의 상호작용을 어떻게 기록하고 재현하는가?
+4. 프로덕션 환경에서 소스 맵(Source Map) 노출 없이 에러 스택을 정확히 복구하는 보안 가이드라인은?
+5. 메모리 리테이너 경로 분석을 통해 발견된 '클로저(Closure)에 의한 메모리 누수'를 해결하는 코드 패턴은?
+
+### Practical Application Contexts
+- **이슈 재현성 확보**: 고객사에서 보고된 불분명한 오류를 LogRocket 리플레이로 확인하여 재현 단계 생략.
+- **성능 튜닝**: 장시간 실행되는 대시보드 앱의 메모리 누수를 Allocation Timeline으로 추적하여 수정.
+
+### Adjacent Topics
+- **Performance Profiling (Lighthouse / Core Web Vitals)**
+- **Static Application Security Testing (SAST)**
+- **Unit & Integration Testing Strategies**
diff --git a/10_Wiki/Topics/Programming & Tools/Naming Conventions.md b/10_Wiki/Topics/Programming & Tools/Naming Conventions.md
new file mode 100644
index 00000000..cd983d57
--- /dev/null
+++ b/10_Wiki/Topics/Programming & Tools/Naming Conventions.md	
@@ -0,0 +1,46 @@
+## 📌 Brief Summary
+Naming Conventions(명명 규칙)은 코드의 가독성, 유지보수성, 그리고 협업 효율성을 높이기 위해 파일, 컴포넌트, 변수 등의 이름을 짓는 합의된 표준이다. 명확한 규칙을 통해 코드의 역할을 직관적으로 파악하게 하며, 특히 운영체제 간의 대소문자 구분 차이로 인한 빌드 오류를 방지하는 실질적인 엔지니어링 목적을 갖는다.
+
+## 📖 Core Content
+1. **파일 및 폴더 (kebab-case)**
+   - 대소문자 구분이 없는 OS(Windows, macOS)와 엄격한 OS(Linux) 간의 CI/CD 빌드 충돌을 막기 위해 소문자와 하이픈을 사용하는 `kebab-case`를 권장한다.
+   - Next.js의 예약어(`page.js`, `layout.js`)나 라우트 그룹(`(folder)`) 등의 규칙을 준수한다.
+2. **React 컴포넌트 및 타입 (PascalCase)**
+   - 컴포넌트명과 TypeScript의 Type/Interface, Enum 등은 첫 글자를 대문자로 하는 `PascalCase`를 사용하여 일반 변수와 구별한다.
+3. **변수, 함수, 프로퍼티 (camelCase)**
+   - JavaScript 표준에 따라 첫 단어는 소문자로 시작하는 `camelCase`를 사용한다.
+   - Boolean 값은 `is`, `has`, `should` 접두사를, 이벤트 핸들러는 `handle`, `on` 접두사를 붙여 의미를 명확히 한다.
+4. **커스텀 훅 (use 접두사)**
+   - React의 Rules of Hooks를 준수하기 위해 반드시 `use` 접두사로 시작하는 `camelCase`를 사용한다.
+5. **상수 (UPPER_SNAKE_CASE)**
+   - 변경되지 않는 고정 값은 대문자와 밑줄을 사용하는 `UPPER_SNAKE_CASE`로 작성하여 식별력을 높인다.
+6. **Git 및 워크플로우**
+   - 브랜치명: `{type}/{ticket-id}-{description}` 형식의 소문자 kebab-case 사용.
+   - 커밋 메시지: Conventional Commits(`feat:`, `fix:` 등) 형식을 준수하여 추적성을 확보한다.
+
+## ⚖️ Trade-offs & Caveats
+- **엄격함 vs 유연성**: 너무 복잡한 네이밍 규칙은 개발자의 인지 부하를 늘리고 생산성을 저하시킬 수 있으므로, 팀 규모에 맞는 적절한 수준의 합의가 필요하다.
+- **자동화 도구의 한계**: ESLint 등으로 많은 네이밍 규칙을 강제할 수 있으나, '의미론적(Semantic) 적절성'까지는 도구가 판단할 수 없으므로 여전히 코드 리뷰가 중요하다.
+- **프레임워크 제약**: 사용 중인 프레임워크(예: Next.js)의 예약어 규칙이 팀의 컨벤션과 충돌할 경우, 프레임워크의 규칙을 우선시해야 시스템 오류를 방지할 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **kebab-case**: 파일 시스템 호환성을 위한 소문자-하이픈 조합 (관계: 물리적 저장 표준)
+- **Conventional Commits**: 변경 이력 가독성을 위한 표준 (관계: 협업 워크플로우 규칙)
+- **PascalCase**: 컴포넌트 및 타입 식별을 위한 대문자 시작 조합 (관계: 논리적 식별 표준)
+
+### Deeper Research Questions
+1. OS별 대소문자 인식 차이가 실제 프로덕션 빌드 환경에서 유발하는 'Silent failure' 사례와 그 디버깅 방법은?
+2. 네이밍 규칙 준수가 TypeScript의 타입 추론 성능이나 트리 쉐이킹(Tree Shaking) 효율에 간접적인 영향을 미치는가?
+3. 대규모 리팩토링 시, 기존의 네이밍 컨벤션을 일괄 변경하기 위한 AST(Abstract Syntax Tree) 기반 자동화 도구 활용 방안은?
+4. `isVisible` vs `showComponent`와 같이 상태 중심 네이밍과 명령 중심 네이밍 중 어떤 것이 유지보수에 더 유리한가?
+5. 다국어 지원(i18n) 프로젝트에서 키값(Key) 네이밍을 도메인 중심으로 짓는 것과 페이지 중심으로 짓는 것의 트레이드오프는?
+
+### Practical Application Contexts
+- **협업 환경 구축**: ESLint 및 Prettier 설정을 통해 팀원 전체가 동일한 네이밍 케이스를 사용하도록 자동 강제.
+- **이슈 추적**: 브랜치명에 티켓 ID를 포함하여 Jira/GitHub Issues와 코드를 유기적으로 연결.
+
+### Adjacent Topics
+- **Clean Code & Meaningful Names**
+- **Feature-Sliced Design (FSD)**
+- **Git Branching Strategies**
diff --git a/10_Wiki/Topics/Programming & Tools/Refactoring Techniques.md b/10_Wiki/Topics/Programming & Tools/Refactoring Techniques.md
new file mode 100644
index 00000000..fd2c4711
--- /dev/null
+++ b/10_Wiki/Topics/Programming & Tools/Refactoring Techniques.md	
@@ -0,0 +1,41 @@
+## 📌 Brief Summary
+리팩토링(Refactoring)은 소프트웨어의 외부 동작을 변경하지 않으면서 내부 구조, 가독성, 모듈성을 개선하는 정교한 공학적 작업이다. React 환경에서는 비대한 컴포넌트 분할, 커스텀 훅을 통한 로직 추출, 그리고 기술 부채 상환을 위한 점진적 마이그레이션을 통해 시스템의 확장성과 유지보수성을 극대화하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **점진적 마이그레이션 (Refactor, Do Not Rewrite)**
+   - 전체 시스템을 한 번에 재작성하는 위험을 피하고, 기능 단위나 도메인 단위로 하나씩 새로운 아키텍처로 옮긴다.
+2. **커스텀 훅을 통한 로직 추출**
+   - 비대한 컴포넌트 내의 데이터 패칭, 폼 처리, 복잡한 계산 로직을 커스텀 훅으로 추출하여 UI와 비즈니스 로직을 분리한다.
+   - 이를 통해 독립적이고 빠른 단위 테스트(Unit Testing) 환경을 확보한다.
+3. **안전망으로서의 테스트 구축**
+   - 리팩토링 전 기존 기능의 동작을 보장하는 테스트 수트를 먼저 작성하여, 변경으로 인한 기능 파손을 즉각 탐지한다.
+4. **구조적 표준화 및 거버넌스**
+   - 클래스형 컴포넌트를 함수형으로 전환하고, TypeScript를 도입하여 정적 안정성을 강화한다.
+   - ESLint 및 Prettier 등 자동화 도구를 통해 팀의 코드 컨벤션과 아키텍처 규칙을 강제한다.
+
+## ⚖️ Trade-offs & Caveats
+- **단기 생산성 저하**: 리팩토링은 당장의 비즈니스 기능 추가보다 많은 시간을 소요할 수 있으므로, 적절한 일정 조율과 경영진의 합의가 필요하다.
+- **과도한 추상화의 위험**: 리팩토링 과정에서 DRY 원칙에만 집착하여 만든 지나치게 복잡한 추상화는 오히려 코드 가독성을 해칠 수 있다(KISS 원칙과의 충돌).
+- **마이그레이션 중단의 위험**: 부분적인 리팩토링이 완료되지 않고 중단될 경우, 시스템 내에 두 가지 이상의 서로 다른 패턴이 혼재되어 유지보수 난이도가 상승할 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Custom Hooks**: 로직 분리의 물리적 단위 (관계: 실천 도구)
+- **Incremental Migration**: 안전한 아키텍처 전환 전략 (관계: 핵심 방법론)
+- **Unit Testing**: 리팩토링의 안전을 보장하는 장치 (관계: 필수 선행 조건)
+
+### Deeper Research Questions
+1. 리팩토링 과정에서 기존의 통합 테스트(E2E)를 유지하면서 내부 로직을 단위 테스트로 분리해 나가는 최적의 프로세스는?
+2. 300줄 이상의 거대 컴포넌트를 분할할 때, 상태(State) 전달을 위해 Prop Drilling을 감수할 것인가, 아니면 전역 상태로 승격할 것인가에 대한 판단 기준은?
+3. 리팩토링 중 발견된 레거시 코드의 '잠재적 버그'를 즉시 수정할 것인가, 아니면 리팩토링 완료 후 별도 작업으로 처리할 것인가?
+4. 아키텍처 캡슐화(FSD 등)가 리팩토링 시 사이드 이펙트를 물리적으로 차단하는 구체적인 메커니즘은?
+5. 성능 리팩토링 시, 가독성 좋은 코드와 고성능(메모이제이션 남발 등) 코드 사이의 적절한 타협점은 어디인가?
+
+### Practical Application Contexts
+- **레거시 코드 현대화**: 오래된 React 프로젝트의 기술 스택(Redux -> Zustand 등) 및 컴포넌트 스타일 개선.
+- **지속적 품질 관리**: 기능 추가 전후로 관련 모듈을 SRP 원칙에 맞게 정돈하여 기술 부채 누적 방지.
+
+### Adjacent Topics
+- **Software Engineering Principles (SOLID)**
+- **Technical Debt Management**
+- **Automated Governance & Linting**
diff --git a/10_Wiki/Topics/Programming & Tools/Refactoring.md b/10_Wiki/Topics/Programming & Tools/Refactoring.md
new file mode 100644
index 00000000..5ea5f35e
--- /dev/null
+++ b/10_Wiki/Topics/Programming & Tools/Refactoring.md	
@@ -0,0 +1,45 @@
+## 📌 Brief Summary
+리팩토링(Refactoring)은 소프트웨어의 외부 동작을 유지하면서 내부 구조를 개선하여 코드베이스의 건강함과 유지보수성을 확보하는 전문적인 개발 과정이다. 낡은 패러다임을 현대화하고 책임을 분리하며, 강력한 테스트 안전망을 구축함으로써 기술 부채를 상환하고 시스템의 복잡도를 제어하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **리팩토링 철학: 점진적 마이그레이션**
+   - 위험이 큰 전면 재작성 대신, 기능 단위로 하나씩 새로운 아키텍처로 옮기는 점진적 방식을 취한다.
+   - 이를 통해 시스템 현대화 중에도 신규 기능 개발을 지속할 수 있다.
+2. **React 리팩토링의 핵심: 커스텀 훅**
+   - 비대한 UI 컴포넌트에서 비즈니스 로직을 추출하여 커스텀 훅으로 분리한다.
+   - UI와 로직의 분리를 통해 모듈성을 높이고, 독립적이고 빠른 단위 테스트(Unit Testing) 환경을 확보한다.
+3. **실무적 개선 기법**
+   - 클래스형 컴포넌트의 함수형 전환, JavaScript의 TypeScript 마이그레이션.
+   - 불필요한 `useEffect` 제거 및 서버 상태 관리(TanStack Query) 도입.
+   - DRY(중복 제거) 및 YAGNI(불필요 기능 제거) 원칙을 통한 코드 정리.
+4. **표준화 및 거버넌스**
+   - CSS 작성 방식 표준화, 폴더 구조(FSD 등) 재정렬, 직관적 네이밍 적용.
+   - ESLint 등 자동화 도구를 통해 팀의 모범 사례를 강제한다.
+
+## ⚖️ Trade-offs & Caveats
+- **마이그레이션 과도기 복잡성**: 구형과 신규 패턴이 공존하는 기간 동안 시스템의 일관성이 일시적으로 깨질 수 있으며, 개발자의 인지 부하가 증가한다.
+- **테스트 부재의 위험**: 충분한 테스트 안전망 없이 진행되는 리팩토링은 오히려 예기치 못한 회귀(Regression) 오류를 유발할 수 있다.
+- **과도한 추상화**: 중복 제거(DRY)에 너무 집착할 경우, 오히려 코드가 복잡해져 이해하기 어려워지는 'KISS 원칙 위반' 사례가 발생할 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Incremental Migration**: 안전한 아키텍처 전환 전략 (관계: 핵심 방법론)
+- **Custom Hooks**: 로직 분리의 기본 단위 (관계: 실천 도구)
+- **Unit Testing**: 리팩토링의 안정성 보장 (관계: 필수 전제 조건)
+- **Feature-Sliced Design (FSD)**: 캡슐화를 통한 부작용 차단 (관계: 구조적 목표)
+
+### Deeper Research Questions
+1. 대규모 리팩토링 시 구/신규 아키텍처 공존 기간을 최소화하기 위한 'Feature Toggle' 활용 방안은?
+2. 테스트 코드가 전혀 없는 레거시 시스템에서 '안전한 리팩토링'을 시작하기 위한 최소한의 테스트 전략은?
+3. 순환 복잡도를 줄이기 위한 조건문 리팩토링(Guard Clauses 등)이 React JSX 내부 구조에 미치는 영향은?
+4. 리팩토링 중 발견된 '기존의 의도된 버그(Legacy Bug)'를 처리하는 아키텍처적 의사결정 기준은?
+5. AI 도구(LLM)를 활용한 대규모 코드 리팩토링 시, 로직 변질 여부를 자동으로 검증하는 파이프라인 구축 방법은?
+
+### Practical Application Contexts
+- **기술 부채 상환**: 스파게티 코드로 변한 레거시 프로젝트의 구조 개선 및 현대화.
+- **시스템 안정성 강화**: 잦은 에러가 발생하는 모듈을 SRP 원칙에 따라 분해하고 테스트 코드를 보강.
+
+### Adjacent Topics
+- **Technical Debt Management**
+- **Clean Code & Code Smells**
+- **SOLID Principles**
diff --git a/10_Wiki/Topics/Software Architecture/Agile Development.md b/10_Wiki/Topics/Software Architecture/Agile Development.md
new file mode 100644
index 00000000..9aa66b3b
--- /dev/null
+++ b/10_Wiki/Topics/Software Architecture/Agile Development.md	
@@ -0,0 +1,38 @@
+## 📌 Brief Summary
+애자일 개발(Agile Development)은 불확실한 요구사항과 급변하는 환경 속에서 반복적이고 점진적인 프로세스를 통해 가치를 창출하는 소프트웨어 개발 방법론이다. 불필요한 사전 설계를 지양하는 YAGNI 원칙과 기능 중심의 코드 구조화를 통해 개발 속도와 유연성을 극대화하는 것을 핵심으로 한다.
+
+## 📖 Core Content
+1. **YAGNI 원칙의 철저한 준수 (You Aren't Gonna Need It)**
+   - 애자일 환경에서는 미래의 불확실한 사용 사례를 위해 미리 복잡한 기능을 구축하는 오버엔지니어링을 지양해야 한다.
+   - 현재의 요구사항에 집중함으로써 불필요한 복잡성을 제거하고 작업 낭비를 최소화한다.
+2. **기능 기반 구조(Feature-Based Structure) 설계**
+   - 파일 유형(Type)이 아닌 비즈니스 기능(Feature) 또는 모듈을 중심으로 폴더 구조를 설계하는 것이 애자일 방법론과 높은 정합성을 갖는다.
+   - 각 기능이 독립적으로 생성, 구현, 배포될 수 있도록 보장하여 팀 간의 병렬 협업 효율성을 높인다.
+3. **반복적 품질 확보**
+   - 단일 책임 원칙(SRP)과 같은 SOLID 원칙을 기반으로 컴포넌트를 설계하여, 빠른 스프린트 주기 속에서도 코드의 유지보수성과 확장성을 유지한다.
+
+## ⚖️ Trade-offs & Caveats
+- **기술 부채의 위험**: YAGNI를 지나치게 엄격하게 적용할 경우, 미래의 확장성을 고려하지 않은 설계로 인해 추후 대규모 리팩토링 비용이 발생할 수 있는 트레이드오프가 존재한다.
+- **초기 설계 오버헤드**: 소규모 프로젝트에서 기능 기반 구조를 채택할 경우, 단순한 파일 유형 기반 구조보다 폴더 깊이가 깊어지고 초기 구성 비용이 증가할 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **YAGNI**: 애자일 개발의 핵심적인 효율성 추구 원칙 (관계: 하위 실천 지침)
+- **Feature-Based Structure**: 애자일 팀의 독립적 협업을 돕는 아키텍처 (관계: 구조적 구현체)
+- **KISS Principle**: 복잡성을 최소화하여 변경에 신속히 대응하는 철학 (관계: 가치 공유)
+
+### Deeper Research Questions
+1. 기능 기반 폴더 구조가 마이크로 프론트엔드 아키텍처로의 전환 시 어떤 이점을 제공하는가?
+2. YAGNI 원칙과 장기적인 코드 품질(Clean Code) 사이의 균형을 맞추는 구체적인 결정 프레임워크는 무엇인가?
+3. 애자일 반복 주기 내에서 단위 테스트와 통합 테스트의 비중을 어떻게 조절해야 하는가?
+4. 스프린트 중 발생하는 기술 부채를 백로그에 효과적으로 반영하고 해소하는 프로세스는?
+5. 기능 독립성이 강화된 구조에서 공통 모듈(Shared)의 비대화를 막기 위한 전략은 무엇인가?
+
+### Practical Application Contexts
+- **스프린트 설계**: 새로운 기능을 추가할 때 미래의 확장성보다는 현재 스프린트 목표 달성에 집중하여 코드를 단순하게 유지.
+- **팀 협업 구조**: 기능별로 폴더를 나누어 개발자 간의 코드 충돌을 최소화하고 독립적인 기능 배포 환경 구축.
+
+### Adjacent Topics
+- **SOLID Principles**
+- **Lean Software Development**
+- **Extreme Programming (XP)**
diff --git a/10_Wiki/Topics/Software Architecture/Clean Code & SOLID Principles.md b/10_Wiki/Topics/Software Architecture/Clean Code & SOLID Principles.md
new file mode 100644
index 00000000..553856d1
--- /dev/null
+++ b/10_Wiki/Topics/Software Architecture/Clean Code & SOLID Principles.md	
@@ -0,0 +1,43 @@
+## 📌 Brief Summary
+Clean Code와 SOLID 원칙은 유지보수성, 가독성, 확장성을 확보하기 위한 소프트웨어 공학의 핵심 설계 지침이다. 현대의 React 생태계에서 이러한 원칙들은 비즈니스 로직과 UI의 결합도를 낮추고, 예측 가능한 컴포넌트 아키텍처를 구축하며, 기술 부채 누적을 방지하는 기반 역할을 한다.
+
+## 📖 Core Content
+1. **SOLID Principles in React**
+   - **SRP (단일 책임)**: 컴포넌트나 훅은 하나의 명확한 목적만 가져야 한다 (300줄 기준).
+   - **OCP (개방-폐쇄)**: 코드 수정 대신 컴포넌트 합성(Composition)을 통해 기능을 확장한다.
+   - **ISP (인터페이스 분리)**: 필요한 Props만 전달하여 컴포넌트 간 불필요한 결합을 차단한다.
+   - **DIP (의존성 역전)**: 구체적 구현이 아닌 추상화(Context, Props)에 의존하여 주입받는다.
+2. **Clean Code & 핵심 원칙**
+   - **DRY (중복 제거)**: 커스텀 훅으로 공통 로직을 추출하되, 과도한 추상화는 경계한다.
+   - **KISS (단순성 유지)**: 복잡한 로직보다 직관적이고 단순한 코드를 우선시한다.
+   - **YAGNI (불필요 기능 배제)**: 당장 필요하지 않은 미래의 확장성을 미리 구현하지 않는다.
+3. **실무적 가이드라인**
+   - 명확한 네이밍(PascalCase, camelCase)과 낮은 중첩 구조를 유지한다.
+   - 동일 패턴이 3번 이상 반복될 때(`Rule of Three`) 비로소 추상화를 진행하여 섣부른 최적화를 방지한다.
+
+## ⚖️ Trade-offs & Caveats
+- **추상화 vs 단순함**: DRY 원칙을 지키려다 만든 고차원적인 추상화가 오히려 코드의 흐름을 파악하기 어렵게 만들어 KISS 원칙을 위반할 수 있다.
+- **초기 개발 속도**: 엄격한 원칙 준수는 초기 보일러플레이트와 설계 시간을 증가시키나, 장기적인 유지보수 비용을 획기적으로 줄여준다.
+- **오버엔지니어링의 위험**: YAGNI를 무시하고 설계한 '미래 대비용' 코드는 결국 사용되지 않는 'Dead Code'가 되어 시스템의 짐이 될 가능성이 높다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Component Composition**: OCP 실현의 핵심 (관계: 구현 패턴)
+- **Custom Hooks**: DRY 및 SRP를 위한 물리적 단위 (관계: 실천 도구)
+- **Feature-Sliced Design (FSD)**: 원칙의 구조적 강제 (관계: 아키텍처 프레임워크)
+
+### Deeper Research Questions
+1. 함수형 React 환경에서 상속 없이 리스코프 치환 원칙(LSP)을 준수하는 인터페이스 설계 전략은?
+2. 섣부른 추상화(Premature Abstraction)가 전체 프로젝트의 인지 부하와 유지보수 비용에 미치는 정량적 영향은?
+3. DIP(의존성 역전)를 위해 Context를 남발할 때 발생하는 성능 저하와 이를 방지하기 위한 'Inversion of Control' 패턴의 조화는?
+4. Clean Code를 강제하기 위한 정적 분석 도구(ESLint, SonarQube)의 규칙을 팀의 기술적 성숙도에 따라 어떻게 커스터마이징하는가?
+5. YAGNI 원칙 하에서 '나중에 고치기 쉬운 코드'를 작성하기 위한 아키텍처적 유연성(Flexibility)의 최소 단위는?
+
+### Practical Application Contexts
+- **코드 리뷰 기준 수립**: 팀 전체의 코드 품질 상향 평준화를 위한 명확한 체크리스트 제공.
+- **대규모 리팩토링 가이드**: 복잡하게 얽힌 레거시 코드를 단일 책임 원칙에 따라 분해하고 정돈.
+
+### Adjacent Topics
+- **Software Engineering Principles**
+- **Refactoring Techniques**
+- **Test Driven Development (TDD)**
diff --git a/10_Wiki/Topics/Software Architecture/Legacy System Migration.md b/10_Wiki/Topics/Software Architecture/Legacy System Migration.md
new file mode 100644
index 00000000..f38c9703
--- /dev/null
+++ b/10_Wiki/Topics/Software Architecture/Legacy System Migration.md	
@@ -0,0 +1,43 @@
+## 📌 Brief Summary
+레거시 시스템 마이그레이션은 낡은 아키텍처와 코드를 최신 기술 표준으로 전환하여 시스템의 유지보수성, 안정성, 성능을 개선하는 공정이다. 프론트엔드 환경에서는 전체 시스템을 한 번에 재작성하는 위험을 피하기 위해, 기능 개발과 병행 가능한 **점진적 마이그레이션(Incremental Migration)** 전략을 핵심으로 한다.
+
+## 📖 Core Content
+1. **점진적 마이그레이션 전략 (Refactor, Do Not Rewrite)**
+   - 시스템 전체를 중단시키지 않고 기능 단위로 하나씩 새로운 스택으로 옮기는 방식을 취한다.
+   - 예: Context API에서 Zustand로 전환 시, 단순한 전역 알림 기능부터 시작하여 점진적으로 복잡한 결제/상태 로직으로 범위를 확대한다.
+2. **현대화 체크리스트 (Solid Wins)**
+   - JavaScript 코드를 TypeScript로 전환하여 정적 안정성 확보.
+   - 클래스 기반 컴포넌트를 함수형 컴포넌트 및 Hooks로 현대화.
+   - 불필요한 `useEffect`를 제거하고 서버 상태 관리를 Tanstack Query로 이관.
+3. **커스텀 훅을 통한 로직 격리**
+   - 컴포넌트 내부에 복잡하게 얽힌 비즈니스 로직을 커스텀 훅으로 추출하여 UI와 분리한다.
+   - 이를 통해 UI와 무관하게 비즈니스 로직에 대한 고속 단위 테스트(Unit Test) 수행이 가능해진다.
+4. **안전망으로서의 테스트**
+   - 마이그레이션 시작 전 기존 동작을 검증하는 테스트 코드를 우선 작성하여, 변경 과정에서 발생할 수 있는 기능 회귀(Regression)를 방지한다.
+
+## ⚖️ Trade-offs & Caveats
+- **과도기적 복잡성**: 점진적 마이그레이션 중에는 두 가지 이상의 기술 스택(예: Redux와 Zustand)이 공존하게 되어 번들 사이즈가 일시적으로 증가하고 데이터 동기화 로직이 복잡해질 수 있다.
+- **개발 속도 저하**: 새로운 기능 개발과 마이그레이션을 병행할 경우, 리팩토링 비용으로 인해 단기적인 제품 출시 속도가 느려질 수 있다.
+- **기술 부채의 잔존**: 부분적인 마이그레이션이 중단될 경우, 오히려 시스템이 더 파편화된 상태로 남게 될 위험이 있으므로 명확한 마이그레이션 로드맵이 필요하다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Incremental Migration**: 리스크 최소화를 위한 단계적 전환 기법 (관계: 핵심 전략)
+- **State Management Architecture**: 레거시 전환의 가장 빈번한 대상 (관계: 주요 마이그레이션 영역)
+- **Unit Testing**: 마이그레이션의 안정성을 보장하는 안전 장치 (관계: 필수 선행 작업)
+
+### Deeper Research Questions
+1. 전체 재작성(Big Bang Rewrite)이 점진적 마이그레이션보다 경제적으로 유리해지는 기술 부채의 임계점은 어디인가?
+2. 마이그레이션 과도기에서 서로 다른 상태 관리 도구 간의 일관성을 유지하기 위한 'Bridge' 패턴의 구현 방법은?
+3. 대규모 JS 코드베이스를 TS로 전환할 때, 'any' 타입을 최소화하면서 빌드 오류를 막는 단계적 타입 강화 전략은?
+4. 마이그레이션 중 발생한 버그가 기술적 결함인지, 기존 레거시의 의도된 동작인지 판별하는 기준은 무엇인가?
+5. 서버 사이드 렌더링(SSR) 환경에서의 레거시 프레임워크와 최신 프레임워크 간의 트래픽 라우팅 처리 방안은?
+
+### Practical Application Contexts
+- **레거시 React 앱 현대화**: 클래스 컴포넌트와 Redux 기반 앱을 함수형 컴포넌트와 Zustand/Query 체제로 전환.
+- **기술 스택 교체**: 기존 라이브 서비스를 유지하면서 백엔드 API 명세 변경에 따른 프론트엔드 데이터 레이어 리팩토링.
+
+### Adjacent Topics
+- **Technical Debt Management**
+- **Clean Code & Refactoring Patterns**
+- **Strangler Fig Pattern in Software Architecture**
diff --git a/10_Wiki/Topics/Software Architecture/Open-Closed Principle (OCP).md b/10_Wiki/Topics/Software Architecture/Open-Closed Principle (OCP).md
new file mode 100644
index 00000000..461a7a2e
--- /dev/null
+++ b/10_Wiki/Topics/Software Architecture/Open-Closed Principle (OCP).md	
@@ -0,0 +1,41 @@
+## 📌 Brief Summary
+개방-폐쇄 원칙(Open/Closed Principle, OCP)은 소프트웨어 개체(클래스, 모듈, 함수 등)가 **확장에는 열려 있어야 하고, 수정에는 닫혀 있어야 한다**는 설계 원칙이다. 이는 기존 소스 코드를 변경하지 않고도 시스템의 기능을 확장할 수 있어야 함을 의미하며, React에서는 컴포넌트 합성(Composition)과 주입 패턴을 통해 이를 실현한다.
+
+## 📖 Core Content
+1. **확장성과 폐쇄성 (Open & Closed)**
+   - 신규 기능 추가 시 기존 코드를 건드리지 않음으로써 의도치 않은 버그 발생(Side Effects)을 원천 차단한다.
+   - 기존 기능의 안정성을 유지하면서도 변화하는 요구사항에 유연하게 대응하는 것이 핵심 목적이다.
+2. **React에서의 구현: 컴포넌트 합성 (Composition)**
+   - 상속이 아닌 합성을 권장하는 React의 특성에 따라, `children` prop을 활용하여 외부에서 렌더링 내용을 주입받는 방식으로 확장성을 확보한다.
+   - 예: 기본 Modal 컴포넌트를 수정하지 않고, 내부 콘텐츠를 `children`으로 전달하여 다양한 형태의 모달로 확장.
+3. **Render Props 및 Slot 패턴**
+   - 구체적인 로직이나 UI 조각을 함수나 객체 형태로 주입받아 컴포넌트 내부 소스 코드의 수정 없이 동작을 변경한다.
+4. **선언적 추상화**
+   - 조건문(`if/else`)을 통해 컴포넌트 내부에서 모든 케이스를 처리하는 대신, 외부에서 주입된 컴포넌트가 각자의 책임을 다하도록 설계한다.
+
+## ⚖️ Trade-offs & Caveats
+- **추상화 오버헤드**: OCP를 엄격히 지키기 위해 모든 컴포넌트를 합성 구조로 만들면, 컴포넌트 트리가 깊어지고 `props` 전달 경로가 복잡해지는 'Prop Drilling'이나 인지적 부하가 발생할 수 있다.
+- **KISS 원칙과의 충돌**: 단순한 기능 추가를 위해 복잡한 Render Props나 고차 컴포넌트(HOC)를 도입하는 것은 'Keep It Simple' 원칙에 어긋날 수 있으므로 적절한 균형이 필요하다.
+- **초기 설계 비용**: 확장을 고려한 인터페이스 설계는 초기 개발 시간을 더 많이 소요하게 만들며, 미래에 발생하지 않을 확장을 대비하는 YAGNI 위반 가능성이 존재한다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Component Composition**: OCP를 실현하는 React의 핵심 기술 (관계: 실천 방법)
+- **SOLID Principles**: OCP를 포함한 5대 설계 원칙 (관계: 상위 철학)
+- **Render Props / Children Prop**: 기능 주입을 위한 구체적 API (관계: 구현 도구)
+
+### Deeper Research Questions
+1. 컴포넌트 합성을 통해 OCP를 준수할 때, 깊은 트리에 의한 리렌더링 성능 저하를 방지하기 위한 메모이제이션 전략은?
+2. 함수형 패러다임에서 'Dependency Injection' 개념이 OCP 구현에 어떻게 적용되는가?
+3. 수백 개의 조건부 UI가 필요한 엔터프라이즈 환경에서 OCP를 지키기 위한 'Strategy Pattern'의 프론트엔드적 해석은?
+4. 코드 수정 없이 확장만 허용하는 원칙이 대규모 리팩토링이나 기술 스택 교체 시에는 어떻게 유연하게 적용되어야 하는가?
+5. CSS-in-JS 환경에서 스타일 확장을 OCP 관점에서 설계하는 모범 사례는?
+
+### Practical Application Contexts
+- **UI 라이브러리 설계**: 공통 버튼, 모달, 테이블 컴포넌트 제작 시 스타일과 동작을 외부에서 주입 가능하도록 설계.
+- **복잡한 폼(Form) 엔진**: 새로운 입력 타입이 추가되어도 메인 폼 로직을 수정할 필요 없는 플러그인 방식 구조 구축.
+
+### Adjacent Topics
+- **Single Responsibility Principle (SRP)**
+- **KISS (Keep It Simple, Stupid)**
+- **Inversion of Control (IoC)**
diff --git a/10_Wiki/Topics/Software Architecture/Software Engineering Principles.md b/10_Wiki/Topics/Software Architecture/Software Engineering Principles.md
new file mode 100644
index 00000000..31da79a3
--- /dev/null
+++ b/10_Wiki/Topics/Software Architecture/Software Engineering Principles.md	
@@ -0,0 +1,44 @@
+## 📌 Brief Summary
+Software Engineering Principles(소프트웨어 엔지니어링 원칙)는 유지보수 가능하고 확장 용이한 시스템을 구축하기 위한 핵심 설계 지침이다. 프론트엔드 및 React 생태계에서는 **SOLID**, **Clean Code**, **DRY**, **KISS**, **YAGNI** 원칙을 통해 코드 복잡성을 제어하고 비즈니스 로직과 UI의 명확한 분리를 달성한다.
+
+## 📖 Core Content
+1. **SOLID Principles**
+   - **SRP (단일 책임)**: 하나의 컴포넌트/모듈은 하나의 책임만 갖는다 (300줄 룰 등).
+   - **OCP (개방-폐쇄)**: 코드 수정 없이 컴포넌트 합성 등을 통해 기능을 확장한다.
+   - **ISP (인터페이스 분리)**: 필요한 속성(Props)만 전달하여 불필요한 의존성을 제거한다.
+   - **DIP (의존성 역전)**: 구체적 구현이 아닌 추상화(Props, Context)에 의존한다.
+2. **Clean Code**
+   - 명확한 네이밍, 낮은 중첩 구조, 이해하기 쉬운 함수 작성을 통해 가독성을 확보한다.
+3. **효율적 개발 원칙 (DRY, KISS, YAGNI)**
+   - **DRY**: 커스텀 훅 등으로 로직을 재사용하되 과도한 추상화는 경계한다.
+   - **KISS**: 단순함을 유지하여 디버깅 용이성을 확보한다.
+   - **YAGNI**: 당장 필요하지 않은 기능(미래 예측)을 미리 구현하지 않아 기술 부채를 방지한다.
+4. **아키텍처적 적용 (FSD)**
+   - 엔지니어링 원칙을 폴더 구조와 의존성 규칙으로 구현하여 모듈 간 캡슐화를 극대화한다.
+
+## ⚖️ Trade-offs & Caveats
+- **DRY vs KISS**: 중복을 제거하기 위해 만든 복잡한 추상화가 오히려 코드의 가독성을 떨어뜨릴 수 있으므로, 'Rule of Three'(3번 반복 시 추출)를 권장한다.
+- **YAGNI vs 확장성**: 미래를 대비하지 않는 것이 자칫 아키텍처의 유연성을 떨어뜨려 나중에 더 큰 수정 비용을 발생시킬 수 있으므로 적절한 밸런스가 필요하다.
+- **추상화의 비용**: 인터페이스 분리와 의존성 역전을 철저히 지키려다 보면 보일러플레이트 코드가 증가하여 개발 속도가 일시적으로 저하될 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **SOLID**: 세부 설계 원칙의 집합 (관계: 상위 원칙)
+- **Clean Code**: 궁극적인 코드 상태 (관계: 품질 목표)
+- **Feature-Sliced Design (FSD)**: 원칙의 물리적 구현 (관계: 구조적 방법론)
+
+### Deeper Research Questions
+1. 함수형 React 환경에서 상속이 없는 LSP(리스코프 치환)와 DIP(의존성 역전)의 실질적인 구현 패턴은?
+2. '추상화의 비용'이 실제 프로젝트의 유지보수 비용(TCO)을 앞지르는 임계점은 어떻게 판단하는가?
+3. 애자일 환경에서 YAGNI 원칙을 지키면서도 '기술적 런웨이(Architectural Runway)'를 확보하는 방법은?
+4. 인터페이스 분리 원칙(ISP)을 위반하여 거대 객체를 Props로 넘길 때 발생하는 리렌더링 성능 저하의 메커니즘은?
+5. Clean Code 원칙을 팀원들 사이에서 동기화하기 위한 자동화된 '코드 스멜' 탐지 도구 활용 방안은?
+
+### Practical Application Contexts
+- **신규 프로젝트 초기 설계**: 아키텍처 원칙 수립 및 코드 컨벤션 강제를 통한 품질 기반 마련.
+- **레거시 코드 리팩토링**: 냄새나는 코드를 식별하고 엔지니어링 원칙에 따라 구조화 및 분해.
+
+### Adjacent Topics
+- **Design Patterns in Frontend**
+- **Refactoring Techniques**
+- **Test Driven Development (TDD)**
diff --git a/10_Wiki/Topics/Software Architecture/Startup Projects.md b/10_Wiki/Topics/Software Architecture/Startup Projects.md
new file mode 100644
index 00000000..06042329
--- /dev/null
+++ b/10_Wiki/Topics/Software Architecture/Startup Projects.md	
@@ -0,0 +1,40 @@
+## 📌 Brief Summary
+스타트업 프로젝트(Startup Projects)는 제한된 리소스와 시간 내에 빠른 시장 검증(MVP)을 목표로 하는 고속 개발 환경이다. 요구사항이 수시로 변하는 특성에 맞춰, 단순하면서도 확장성 있는 기술 스택(Zustand 등)과 실용적인 개발 원칙(YAGNI, 단순 브랜치 전략)을 채택하여 민첩성을 확보하는 것이 핵심이다.
+
+## 📖 Core Content
+1. **상태 관리 도구의 실용적 선택**
+   - 초기부터 복잡한 Redux를 도입하기보다, 보일러플레이트가 적고 빠른 배포가 가능한 **Zustand**를 활용하여 MVP를 신속히 구축한다.
+2. **YAGNI 원칙의 철저한 준수**
+   - 미래의 불확실한 요구사항을 미리 대비한 오버엔지니어링을 지양하고, 현재 당장 필요한 핵심 기능 구현에만 집중한다.
+3. **비용 효율적 모니터링**
+   - Sentry의 무료 티어나 초기 비용이 저렴한 오픈소스/클라우드 대안(SigNoz 등)을 활용하여 프로덕션 안정성을 확보하면서 지출을 관리한다.
+4. **민첩한 협업 프로세스**
+   - 복잡한 Git Flow 대신 단순한 **Feature-branch workflow**를 사용하여 코드 리뷰 속도를 높이고 병합 충돌을 최소화한다.
+   - 짧은 수명의 브랜치와 Squash Merge를 통해 깨끗한 main 이력을 유지한다.
+
+## ⚖️ Trade-offs & Caveats
+- **기술적 부채의 축적**: 빠른 배포를 위한 단순한 설계가 서비스 성장 시점에서 성능이나 확장성 병목을 유발할 수 있으므로, 적절한 시기의 리팩토링 계획이 병행되어야 한다.
+- **도구의 한계**: Zustand와 같은 가벼운 도구는 규모가 커질 때 엄격한 구조적 제약이 부족하여 상태 관리가 파편화될 위험이 있다.
+- **오버엔지니어링의 유혹**: 최신 기술이나 복잡한 아키텍처(FSD 등)를 무분별하게 도입할 경우 스타트업의 최대 자산인 '속도'를 잃을 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Zustand**: 스타트업에 적합한 가벼운 상태 관리 (관계: 권장 도구)
+- **YAGNI**: 자원 낭비를 막는 핵심 원칙 (관계: 설계 철학)
+- **Feature-branch workflow**: 소규모 팀 협업 최적화 (관계: 프로세스 모델)
+
+### Deeper Research Questions
+1. Zustand 기반 MVP가 대규모 엔터프라이즈급(Scale-up)으로 전환될 때 마주하는 기술적 임계점과 전환 시나리오는?
+2. YAGNI를 고수하면서도 '수정하기 쉬운 코드'를 작성하여 미래의 변화 가능성을 열어두는 구체적 기법은?
+3. 스타트업 환경에서 FSD와 같은 엄격한 아키텍처가 개발 속도에 미치는 실제 영향과 도입 시점은 언제인가?
+4. 초기 비용을 아끼기 위해 채택한 오픈소스 모니터링 도구가 운영 부하로 돌아올 때의 트레이드오프 계산법은?
+5. 소수 인원 팀에서 코드 리뷰의 품질과 속도 사이의 균형을 맞추기 위한 자동화(Lint, CI)의 최소 범위는?
+
+### Practical Application Contexts
+- **MVP 신속 구축**: 수 주 내에 시장 반응을 확인해야 하는 신규 서비스 런칭.
+- **소규모 개발팀 리드**: 2~5인 규모의 조직에서 협업 효율을 극대화하는 워크플로우 수립.
+
+### Adjacent Topics
+- **Agile Development & Scrum**
+- **Minimum Viable Product (MVP) Strategy**
+- **Technical Debt Management**
diff --git a/10_Wiki/Topics/System Design & Modeling/system_analysis_and_improvement_plan.md b/10_Wiki/Topics/System Design & Modeling/system_analysis_and_improvement_plan.md
new file mode 100644
index 00000000..ae32c17d
--- /dev/null
+++ b/10_Wiki/Topics/System Design & Modeling/system_analysis_and_improvement_plan.md	
@@ -0,0 +1,52 @@
+## 📌 Brief Summary
+G1nation 프로젝트의 기술적 부채를 해결하고 시스템의 근본적인 안정성(Stability)과 사용자 경험(UX)을 고도화하기 위한 전략적 실행 계획이다. 트랜잭션 관리 부재, 상태 관리의 휘발성, 테스트 부재 등 현재의 핵심 병목 지점을 진단하고, 원자적 작업 단위 확보와 구조화된 오류 보고 시스템 구축을 통해 에이전트의 신뢰성을 'Zero-Friction' 수준으로 끌어올리는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **신뢰성 기반 트랜잭션 시스템 (Atomicity & Rollback)**
+   - **문제**: 작업 중단 시 부분적 변경으로 인한 데이터 오염.
+   - **해결**: `TransactionManager` 도입. `begin()` 단계에서 상태 스냅샷을 생성하고, 실패 시 `rollback()`을 통해 초기 상태로 복구하는 원자성 확보.
+2. **영속적 상태 관리 (Persistence & Context)**
+   - **문제**: 세션 중단 시 작업 맥락 소실.
+   - **해결**: `SessionState` 스키마 정의 및 디스크 기반 실시간 업데이트. 중단 지점부터 즉시 재개 가능한 '신뢰할 수 있는 기억 장치' 구현.
+3. **구조화된 오류 진단 및 보고**
+   - **문제**: 모호한 에러 메시지로 인한 디버깅 효율 저하.
+   - **해결**: 커스텀 에러 클래스(`AgentExecutionError` 등) 정의 및 오류 유형, 위치, 원인을 포함한 정형화된 보고서 생성.
+4. **알고리즘적 비효율성 개선 (Performance P1)**
+   - **문제**: `DataProcessor.aggregate()` 등 핵심 집계 함수의 $O(N^2)$ 복잡도로 인한 지수적 성능 저하.
+   - **해결**: 해시 맵(Hash Map) 기반 인덱싱 도입을 통해 시간 복잡도를 $O(N)$으로 최적화하고 CPU 부하 최소화.
+5. **유지보수성 및 복잡도 관리 (Architecture P2)**
+   - **문제**: 라우팅 로직의 높은 순환 복잡도(CC > 15) 및 인프라-비즈니스 로직의 강한 결합.
+   - **해결**: 단일 책임 원칙(SRP)에 따른 도메인 서비스 분리 및 인터페이스 기반의 느슨한 결합 구현.
+6. **품질 게이트 및 환경 규격화**
+   - **문제**: 테스트 부재 및 환경 설정 파편화.
+   - **해결**: Jest 기반 테스트 수트 구축(Mocking 필수), `config/` 모듈화를 통한 환경별 설정 분리 및 실행 전 유효성 검사(Validator) 수행.
+7. **사용자 경험 고도화 (Transparency & Control)**
+   - **문제**: 내부 작동 과정의 불투명성 및 제어권 부족.
+   - **해결**: 실시간 진행률 위젯 제공 및 `Dry Run Mode` 도입을 통한 사전 승인 프로세스 강화.
+
+## ⚖️ Trade-offs & Caveats
+- **구현 복잡도 증가**: 트랜잭션 및 상태 영속화 로직 도입 시 코드 베이스의 베이스라인 복잡도가 상승하며, 스냅샷 생성에 따른 미세한 성능 오버헤드가 발생할 수 있다.
+- **테스트 유지보수 비용**: Mocking 기반의 테스트는 실제 시스템 변경 시 테스트 코드도 함께 업데이트해야 하는 관리 비용이 발생한다.
+- **사용자 간섭의 양날의 검**: `Dry Run` 및 승인 단계가 많아질수록 안전성은 높아지나, 자동화의 속도와 흐름(Flow)이 끊길 수 있으므로 적절한 밸런스가 필요하다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **ACID 원칙**: 트랜잭션 설계의 근본 철학 (관계: 구현 모델)
+- **State Machine Architecture**: 상태 전환의 명확성을 위한 설계 패턴 (관계: 확장 방향)
+- **Observability**: 시스템 내부 상태를 외부에서 파악하는 능력 (관계: UX 개선)
+
+### Deeper Research Questions
+1. 분산 환경에서의 트랜잭션 롤백을 파일 시스템 수준에서 어떻게 최적화할 것인가?
+2. 에이전트의 '기억'을 벡터 DB와 로컬 세션 상태 사이에서 어떻게 효율적으로 분배할 것인가?
+3. 가상 파일 시스템(VFS)을 이용한 Dry Run 시뮬레이션의 정확도를 어떻게 보장할 것인가?
+4. 설정 유효성 검사(Config Validation)를 런타임이 아닌 빌드 타임에 수행할 수 있는 방안은?
+5. 사용자 개입(Human-in-the-loop)의 최소화와 시스템 안정성 사이의 정량적 임계점은 어디인가?
+
+### Practical Application Contexts
+- **ConnectAI Extension**: VS Code 내에서 에이전트의 작업 진행 상황을 시각화하고 사용자 승인을 받는 인터페이스 설계 시 적용.
+- **CI/CD Pipeline**: PR 생성 시 테스트 커버리지 및 정적 분석 결과를 게이트로 활용하는 운영 맥락.
+
+### Adjacent Topics
+- **Error Boundary Pattern in React**
+- **Git Internals (Snapshot & Rollback)**
+- **Event-Driven Microservices Architecture**
diff --git a/10_Wiki/Topics/Web & Performance/Bundle Size Optimization.md b/10_Wiki/Topics/Web & Performance/Bundle Size Optimization.md
new file mode 100644
index 00000000..1307f0b0
--- /dev/null
+++ b/10_Wiki/Topics/Web & Performance/Bundle Size Optimization.md	
@@ -0,0 +1,44 @@
+## 📌 Brief Summary
+Bundle Size Optimization(번들 크기 최적화)은 클라이언트로 전송되는 자바스크립트 자산의 물리적 용량을 최소화하여 초기 로딩 성능(LCP)과 런타임 반응성(TBT/INP)을 개선하는 기술적 공정이다. 코드 분할(Code Splitting), 지연 로딩(Lazy Loading), 트리 쉐이킹 등을 통해 브라우저의 파싱 및 실행 오버헤드를 근본적으로 줄이는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **번들 팽창의 원인 진단**
+   - 단일 엔트리 포인트(`index.js`)에 모든 종속성(React, heavy libraries)이 결합된 구조.
+   - 무분별한 Eager Import와 거대한 전이적 종속성(Transitive Dependencies)으로 인한 메인 스레드 점유율 상승.
+2. **코드 분할 및 지연 로딩 (Strategic Splitting)**
+   - `React.lazy()`와 `<Suspense>`를 활용하여 특정 라우트나 무거운 UI 요소(차트, 모달 등)를 독립적인 청크(Chunk)로 분리.
+   - 사용자가 필요로 하는 시점에만 코드를 로드하여 초기 번들 페이로드를 획기적으로 절감.
+3. **벤더 분할 전략 (Vendor Splitting)**
+   - Vite/Rollup의 `manualChunks` 설정을 통해 자주 변경되지 않는 핵심 라이브러리(React 등)를 별도의 청크로 고정.
+   - 브라우저 캐싱 효율을 극대화하여 재방문자의 로딩 속도를 가속화.
+4. **서버 컴포넌트(RSC)를 통한 근본적 절감**
+   - 상호작용이 없는 정적 UI를 서버에서 렌더링하여 클라이언트로 전송되는 JS 페이로드를 '0'으로 수렴시키는 아키텍처 적용.
+5. **분석 및 정제 도구 활용**
+   - `rollup-plugin-visualizer` 또는 Webpack Bundle Analyzer를 통해 번들 내부의 'Bloat'을 시각적으로 식별하고 제거.
+
+## ⚖️ Trade-offs & Caveats
+- **워터폴(Waterfall) 현상**: 지연 로딩을 남발할 경우 청크 간의 의존성으로 인해 순차적 로딩 지연이 발생하여 체감 성능이 오히려 저하될 수 있다.
+- **네트워크 요청 수 증가**: 번들을 너무 작게 쪼개면 HTTP 요청 수가 급증하여 네트워크 오버헤드가 발생할 수 있으므로 적절한 청크 사이즈(예: 30KB~100KB) 유지가 필요하다.
+- **캐시 무효화 관리**: 청크 분할 전략이 잘못될 경우 작은 코드 수정에도 모든 벤더 청크의 해시가 변경되어 캐시 효율이 떨어질 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Code Splitting**: 번들을 물리적으로 분리하는 구현 패턴 (관계: 실천 방법)
+- **Core Web Vitals**: 번들 최적화의 성공 여부를 측정하는 정량적 지표 (관계: 성능 평가)
+- **Hydration**: 번들 크기가 클수록 직접적으로 지연되는 클라이언트 활성화 과정 (관계: 직접 영향)
+
+### Deeper Research Questions
+1. Vite의 `manualChunks` 설정 시 변동 주기가 다른 라이브러리들을 어떻게 그룹화하는 것이 캐시 히트율에 가장 유리한가?
+2. `React.lazy`를 비동기 데이터 페칭 로직과 결합할 때 레이턴시를 최소화하는 프리페칭(Prefetching) 전략은?
+3. 트리 쉐이킹이 작동하지 않는 CommonJS 기반 라이브러리를 ESM 환경에서 어떻게 효율적으로 격리할 것인가?
+4. 서버 컴포넌트 환경에서 클라이언트 번들에 의도치 않게 포함되는 서버 사이드 로직을 어떻게 정적으로 감지할 것인가?
+5. 번들 압축 기법(Gzip vs Brotli)과 번들 크기 최적화 사이의 실제 사용자 로딩 시간 상관관계는?
+
+### Practical Application Contexts
+- **Vite Configuration**: `vite.config.ts`에서 Rollup 옵션을 조정하여 벤더 청크 분리.
+- **Performance Budgeting**: CI/CD 단계에서 특정 번들 사이즈 초과 시 빌드를 실패하게 만드는 성능 예산 설정.
+
+### Adjacent Topics
+- **Brotli / Gzip Compression**
+- **Tree Shaking & ES Modules**
+- **HTTP/2 & HTTP/3 Multi-plexing**
diff --git a/10_Wiki/Topics/Web & Performance/Frontend Observability & Logging.md b/10_Wiki/Topics/Web & Performance/Frontend Observability & Logging.md
new file mode 100644
index 00000000..bafb7184
--- /dev/null
+++ b/10_Wiki/Topics/Web & Performance/Frontend Observability & Logging.md	
@@ -0,0 +1,43 @@
+## 📌 Brief Summary
+프론트엔드 관측성(Frontend Observability) 및 로깅 시스템은 다양한 브라우저와 기기 환경에서 실행되는 웹 애플리케이션의 런타임 동작을 가시화하는 기술이다. 단순한 에러 추적을 넘어 세션 리플레이, 분산 추적, 지능형 에러 그룹화를 통해 복잡한 프로덕션 오류의 원인을 심층 분석하고 서비스 안정성을 보장하는 것을 목표로 한다.
+
+## 📖 Core Content
+1. **관측성의 핵심 기능**
+   - **세션 리플레이 (Session Replay)**: 에러 발생 전의 DOM 변경, 네트워크 요청, 상태 변화를 영상처럼 재생하여 재현 경로를 파악한다.
+   - **지능형 에러 그룹화**: 노이즈가 되는 중복 에러를 묶어 실제 해결이 필요한 고유 이슈에 집중하게 한다.
+   - **분산 추적 (Distributed Tracing)**: 프론트엔드 에러를 백엔드 트레이스와 연결하여 풀스택 관점의 장애 원인을 진단한다.
+2. **주요 도구 및 특징**
+   - **Sentry**: 개발자 친화적인 에러 추적 및 브레드크럼(Breadcrumb) 기능 제공.
+   - **LogRocket**: 강력한 세션 리플레이와 상태 변화 기록에 특화.
+   - **Datadog RUM**: 대규모 환경의 풀스택 관측성 및 지표 통합 관리.
+   - **SigNoz & Grafana**: OpenTelemetry 기반의 개방형 표준 준수 및 벤더 종속 방지.
+3. **도입 시 고려사항**
+   - **성능 오버헤드**: 로깅 SDK가 브라우저 로드 타임에 미치는 영향(최대 120ms 등)을 검토해야 한다.
+   - **개인정보 보호**: 민감한 데이터 유출을 막기 위한 데이터 마스킹 및 프라이버시 제어 설정이 필수적이다.
+
+## ⚖️ Trade-offs & Caveats
+- **비용 vs 가시성**: Datadog 등 일부 유료 도구는 데이터 수집량에 따라 비용이 기하급수적으로 증가하므로, 중요 로그만 선별적으로 수집하는 전략이 필요하다.
+- **성능 저하**: 모든 사용자 상호작용을 기록하는 도구는 브라우저의 메인 스레드 점유율을 높여 사용자 경험을 저해할 수 있다.
+- **설계 복잡성**: 세션 리플레이 도구 도입 시 개인정보 보호를 위한 복잡한 마스킹 규칙 설정이 운영 부담으로 작용할 수 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **OpenTelemetry**: 벤더 종속 없는 데이터 표준 (관계: 기술 기반)
+- **Session Replay**: 디버깅 컨텍스트 확보 (관계: 주요 기능)
+- **Distributed Tracing**: 풀스택 장애 진단 (관계: 확장 기능)
+
+### Deeper Research Questions
+1. SDK 도입이 실제 사용자의 TBT(Total Blocking Time) 및 LCP(Largest Contentful Paint)에 미치는 정량적 영향은?
+2. 세션 리플레이 데이터 수집 시, 보안 규제(GDPR, CCPA)를 준수하면서 실무에 필요한 정보를 확보하는 최적의 마스킹 전략은?
+3. 서버 사이드 렌더링(SSR) 환경에서 클라이언트와 서버 로그를 유기적으로 연결하기 위한 트레이스 ID 전파 기법은?
+4. 오픈소스 기반 관측성 도구(SigNoz 등)를 자체 구축할 때 발생하는 인프라 유지보수 비용과 관리형 서비스(Sentry 등)의 비용 편익 분석은?
+5. 수만 개의 유사 에러 중 '비즈니스에 치명적인 에러'를 실시간으로 우선순위화하는 AI 기반 그룹화 알고리즘의 원리는?
+
+### Practical Application Contexts
+- **프로덕션 장애 디버깅**: 재현이 어려운 간헐적 버그나 사용자 환경 의존적 에러 신속 해결.
+- **성능 모니터링**: 사용자 세션 데이터 분석을 통한 실제 로딩 병목 구간 식별 및 개선.
+
+### Adjacent Topics
+- **Web & Performance Optimization**
+- **Frontend Security & Privacy**
+- **Error Boundaries & Resilience**
diff --git a/10_Wiki/Topics/Web & Performance/Vite Build Optimization.md b/10_Wiki/Topics/Web & Performance/Vite Build Optimization.md
new file mode 100644
index 00000000..5f051d3e
--- /dev/null
+++ b/10_Wiki/Topics/Web & Performance/Vite Build Optimization.md	
@@ -0,0 +1,39 @@
+## 📌 Brief Summary
+Vite 빌드 번들 최적화는 초기 로딩 속도와 캐시 효율을 극대화하기 위해 JavaScript 번들 크기를 줄이고 로딩 구조를 최적화하는 과정이다. Rollup 옵션을 통한 벤더 라이브러리 분리(`manualChunks`)와 지연 로딩(`React.lazy`)을 결합하여, 사용자가 필요한 시점에 필요한 코드만 다운로드하도록 설계하는 것이 핵심이다.
+
+## 📖 Core Content
+1. **대규모 번들 이슈 해결**
+   - 기본적으로 하나의 거대한 `index.js`로 묶이는 문제를 해결하여 FCP, LCP 등 Core Web Vitals 지표를 개선한다.
+2. **manualChunks를 통한 벤더 분리**
+   - 자주 바뀌지 않는 `react`, `react-dom` 등 외부 라이브러리를 별도 청크로 분리하여 브라우저 캐싱 효율을 극대화한다.
+3. **라우트 레벨 코드 스플리팅**
+   - `React.lazy`와 `<Suspense>`를 활용해 페이지 단위로 코드를 쪼개어 초기 진입 시 다운로드되는 리소스를 최소화한다.
+4. **번들 시각화 및 분석**
+   - `rollup-plugin-visualizer`를 통해 번들 내부를 시각적으로 분석하고, 불필요하게 비대해진 모듈을 찾아 트리 쉐이킹(Tree-shaking)을 적용하거나 대체한다.
+
+## ⚖️ Trade-offs & Caveats
+- **청크 파편화**: 번들을 너무 잘게 쪼갤 경우 HTTP 요청 횟수가 급증하여 오히려 네트워크 병목과 Waterfall 현상이 발생할 수 있다.
+- **개발 vs 프로덕션 차이**: Vite는 개발 시 네이티브 ESM을 사용하지만 프로덕션은 Rollup을 사용하므로, 빌드 결과물에서만 발생하는 성능 이슈나 경고를 상시 확인해야 한다.
+- **캐시 무효화**: 벤더 번들을 너무 크게 묶으면 라이브러리 하나만 업데이트해도 거대한 벤더 파일 전체의 캐시가 무효화되는 트레이드오프가 있다.
+
+## 🔗 Knowledge Connections
+### Related Concepts
+- **Rollup**: Vite의 프로덕션 빌드 엔진 (관계: 구동 원리)
+- **React.lazy & Suspense**: 코드 스플리팅의 실천 수단 (관계: 구현 도구)
+- **Core Web Vitals**: 최적화의 최종 목적지 (관계: 성능 지표)
+
+### Deeper Research Questions
+1. `manualChunks`를 세밀하게 설정할 때, 네트워크 오버헤드를 최소화하면서 캐시 히트율을 극대화하는 최적의 청크 크기 기준은?
+2. Vite의 ESM 기반 개발 서버와 Rollup 기반 빌드 환경 간의 차이로 인해 발생하는 'Silent Errors' 사례와 방지책은?
+3. 동적 임포트로 쪼개진 청크들을 사용자가 클릭하기 전에 미리 불러오는 'Prefetching' 전략의 Vite 자동화 방법은?
+4. 트리 쉐이킹이 작동하지 않는 CommonJS 기반 라이브러리를 ESM으로 안전하게 변환하거나 대체하는 가이드라인은?
+5. HTTP/2 또는 HTTP/3 환경에서 다수의 작은 청크 전송이 번들링된 하나의 큰 파일 전송보다 유리해지는 구체적 조건은?
+
+### Practical Application Contexts
+- **성능 경고 해결**: "Chunks are larger than 500 kB" 빌드 경고 발생 시 즉각적인 대응.
+- **사용자 경험 개선**: 느린 네트워크 환경의 사용자를 위한 초기 로딩 최적화 및 안정적 인터랙션 제공.
+
+### Adjacent Topics
+- **Service Worker & Caching Strategy**
+- **React Server Components (RSC)**
+- **Modern Build Tools (Turbopack, Rspack) Comparison**