파일 인덱서 + RAG 검색 MCP
300줄로 만드는 개인 지식 검색

Session 11 · RAG 검색 MCP 서버로 여는 개인 지식 검색

sqlite · OpenAI Embeddings · FastMCP Tool·Resource · watchdog · Claude·Codex 등록

강사 박수현 · 🚀 젠아이랩스(GenAI Labs)

🎨 이미지 프롬프트: "Editorial illustration on dark navy #0f1722 background showing a folder full of markdown file icons on the left, a central server box with a Python snake emblem labeled 'RAG Indexer' connected to a small sqlite cylinder, and two terminal windows on the right labeled 'Claude Code' and 'Codex'. Two-way arrows flow between the server and both terminals. Clean editorial illustration style, warm orange gradient accents with teal #00b894 and purple #6c5ce7 highlights, 16:9. CRITICAL: All visible text MUST be in English ONLY (no Korean characters). Each label appears EXACTLY ONCE — no duplicates. No mirrored or reversed text."

PART 1

왜 이 실습인가 — 문제 · RAG · MCP 노출 이유

세션 목표 — 노트북에서 네 가지가 동시에

이 세션이 끝나면 참여자 노트북에서 다음 네 가지가 동시에 일어난다.

사내 문서 검색이 안 풀리는 이유 — 세 겹의 벽

컨플루언스 검색을 켰고, 노션 검색을 켰고, GitHub 리포에서 grep 을 돌렸다. 그런데도 '이 정보 어디 있더라' 는 사라지지 않는다.

RAG 3단계 — Retrieval · Augmentation · Generation

RAG · Retrieval-Augmented Generation 은 이름과 달리 흐름이 단순하다.

📌 핵심은 임베딩

• 감각 먼저 — 임베딩은 문장을 좌표로 바꾼 것이다. 1,536 개 축을 가진 공간에 각 문장이 점 하나로 찍힌다. 의미가 비슷하면 점끼리 가깝고, 무관하면 멀다.
• 텍스트를 고정 길이 벡터로 바꾼 것. OpenAI 의 text-embedding-3-small 은 1,536 차원 벡터를 낸다.
• 의미가 비슷한 두 문장은 벡터 공간에서 가까이 위치한다. '결제 실패' 와 'payment gateway timeout' 의 코사인 유사도가 0.8 이상이 되는 식.
• 인덱싱 시점에 문서를 조각내고 각 조각을 벡터로 저장 → 검색 시점에 질의를 같은 방식으로 임베딩해 저장된 벡터들과 코사인 유사도 계산 → 상위 K 개 반환.

📖 OpenAI · New embedding models and API updates · text-embedding-3-small Model

MCP 로 노출하는 이유 — 세 가지 이득

같은 RAG 파이프라인을 웹서비스로 만들 수도 있다. FastAPI 로 검색 API 를 노출하고 프론트를 붙이는 흐름. 그 결과물은 브라우저 창 하나가 더 늘어날 뿐이다. 개발자는 이미 하루 종일 Claude Code · Codex 창에 있다.

🎨 Image Prompt: "Editorial illustration on dark navy #0f1722 background split-composition. Left half: browser window with search UI titled 'Traditional RAG'. Right half: terminal window with Claude Code prompt titled 'MCP Integration'. Bottom center caption 'Same RAG, Different Interface' appearing EXACTLY ONCE. No random text inside chat bubbles — use blank speech shapes or thin lines only. Clean editorial style, 16:9. English ONLY, each label EXACTLY ONCE."

MCP 로 노출하는 이유 — 세 가지 이득

PART 2

아키텍처 — 4개 컴포넌트 · sqlite · 청킹 · 임베딩

4개 컴포넌트 — 파일 하나 = 책임 하나

서버는 네 조각. 각 조각의 책임을 처음부터 분리해 두면 구조가 단순하게 유지된다.

🎨 Image Prompt: "Editorial illustration on dark navy #0f1722 background — horizontal architecture diagram, far left a labeled 'Docs Folder' icon, next to it two stacked boxes labeled 'Watcher' and 'Indexer' with a teal arrow from folder into both, center a large sqlite cylinder labeled 'sqlite', to its right two stacked boxes labeled 'Searcher' and 'MCP Server', far right two terminal windows labeled 'Claude' and 'Codex' — arrows flow left to right, Watcher and Indexer write into sqlite, Searcher reads from sqlite and feeds MCP Server, MCP Server connects to both terminals — teal #00b894 and purple #6c5ce7 accents, 16:9. CRITICAL: All visible text MUST be in English ONLY. Each label appears EXACTLY ONCE. No mirrored text."

아키텍처 — 왜 sqlite 를 매개로

sqlite 스키마 — sources · chunks · embeddings

sqlite 로 충분하다. 개인 문서 수만 개 규모까지 성능 문제 없다. 3개 테이블로 나눈다.

CREATE TABLE sources (
    id INTEGER PRIMARY KEY, path TEXT UNIQUE NOT NULL,
    mtime REAL NOT NULL, doc_type TEXT NOT NULL, indexed_at TEXT NOT NULL
);
CREATE TABLE chunks (
    id INTEGER PRIMARY KEY,
    source_id INTEGER NOT NULL REFERENCES sources(id) ON DELETE CASCADE,
    ord INTEGER NOT NULL, start_line INTEGER, end_line INTEGER, text TEXT NOT NULL
);
CREATE TABLE embeddings (
    chunk_id INTEGER PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
    dim INTEGER NOT NULL, vec BLOB NOT NULL   -- float32 × dim
);
CREATE INDEX idx_chunks_source ON chunks(source_id);

청킹 전략 — 문서 유형별

문서를 통째로 임베딩하면 안 된다. 임베딩 모델의 컨텍스트 한계보다 검색 정밀도 가 더 큰 이유다. 문서 전체를 한 벡터로 압축하면 문서의 특정 문단만 관련된 질문에서 유사도가 낮아진다.

임베딩 · 배치 · float32 BLOB

청크 100개를 임베딩한다고 API 를 100번 호출하지 않는다. OpenAI 는 배치 요청을 지원한다.

vec = np.array([0.1, 0.2, ...], dtype=np.float32)
blob = vec.tobytes()                            # 저장
back = np.frombuffer(blob, dtype=np.float32)    # 복원

📖 OpenAI Embeddings 요금 (2026) · $0.02 / 1M tokens

PART 3

Python 구현 — indexer · searcher

인덱서 · sqlite 초기화 — indexer.py

indexer.py 부터. 폴더 경로를 받아 청킹·임베딩·저장까지 처리한다.

"""파일 인덱서 · 청킹 · 임베딩 · sqlite 저장."""
import os, sqlite3
from datetime import datetime
from pathlib import Path

DB_PATH = os.environ.get("RAG_DB_PATH", "./rag_index.db")
SCHEMA = """<PART 2 의 스키마 그대로>"""

def get_db() -> sqlite3.Connection:
    conn = sqlite3.connect(DB_PATH)
    conn.execute("PRAGMA foreign_keys = ON")   # CASCADE 활성화
    conn.executescript(SCHEMA)
    return conn

파일 유형 판별 · 청킹 함수

확장자로 유형을 판별하고 그에 맞는 청킹 함수를 부른다.

def detect_doc_type(path: Path) -> str:
    ext = path.suffix.lower()
    if ext in {".md", ".markdown"}: return "markdown"
    if ext in {".py", ".ts", ".js", ".go", ".rs", ".java"}: return "code"
    return "text"

def chunk_markdown(text: str, max_tokens: int = 800) -> list[dict]:
    """H1·H2 헤딩 경계로 청킹."""
    import re
    lines = text.splitlines()
    chunks, current, current_start = [], [], 1
    heading_pat = re.compile(r"^#{1,2}\s")
    for i, line in enumerate(lines, start=1):
        if heading_pat.match(line) and current:
            chunks.append({"text": "\n".join(current),
                           "start_line": current_start, "end_line": i - 1})
            current, current_start = [line], i
        else:
            current.append(line)
    if current:
        chunks.append({"text": "\n".join(current),
                       "start_line": current_start, "end_line": len(lines)})
    return [c for c in chunks if c["text"].strip()]

텍스트 청킹 · 라우터 함수

일반 텍스트와 코드에 쓰이는 슬라이딩 윈도우 · 라우터 함수.

def chunk_text(text: str, words: int = 200, overlap: int = 30) -> list[dict]:
    """단어 슬라이딩 윈도우 + 오버랩."""
    tokens, chunks, step = text.split(), [], words - overlap
    for i in range(0, len(tokens), step):
        seg = tokens[i:i + words]
        if not seg: break
        chunks.append({"text": " ".join(seg), "start_line": None, "end_line": None})
    return chunks

def chunk_file(path: Path) -> list[dict]:
    text = path.read_text(encoding="utf-8", errors="ignore")
    doc_type = detect_doc_type(path)
    if doc_type == "markdown": return chunk_markdown(text)
    if doc_type == "code":     return chunk_text(text, words=400, overlap=50)
    return chunk_text(text)

[  1 ─────────────── 200 ]                   ← 청크 1 (words=200)
             [ 171 ─────────────── 370 ]     ← 청크 2 (30 단어 겹침)
                          [ 341 ─────────────── 540 ]  ← 청크 3

OpenAI 임베딩 배치 호출 — embed_batch

청크 100개를 한 요청으로 벡터 100개를 받는다.

import numpy as np
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
EMBED_MODEL, EMBED_DIM = "text-embedding-3-small", 1536

def embed_batch(texts: list[str]) -> np.ndarray:
    """(len, 1536) float32 배열 반환."""
    if not texts:
        return np.zeros((0, EMBED_DIM), dtype=np.float32)
    resp = client.embeddings.create(model=EMBED_MODEL, input=texts)
    return np.stack([np.array(d.embedding, dtype=np.float32) for d in resp.data])

📖 OpenAI Python SDK · openai · PyPI

파일 인덱싱 · index_file

파일 하나를 받아 청킹·임베딩·저장까지 한 함수에서 처리한다. mtime 비교로 skip 이 핵심 결정.

def index_file(conn: sqlite3.Connection, path: Path) -> int:
    """이미 최신이면 skip. 반환은 저장된 청크 수."""
    mtime = path.stat().st_mtime
    doc_type = detect_doc_type(path)

    # 1) 최신이면 skip
    row = conn.execute("SELECT id, mtime FROM sources WHERE path = ?",
                       (str(path),)).fetchone()
    if row and row[1] >= mtime:
        return 0
    # 2) 변경분이면 기존 source 삭제 (CASCADE)
    if row:
        conn.execute("DELETE FROM sources WHERE id = ?", (row[0],))

    # 3) 청킹 · 임베딩
    chunks = chunk_file(path)
    if not chunks: return 0
    vecs = embed_batch([c["text"] for c in chunks])

    # 4) 저장 · 청크·벡터 삽입 (다음 슬라이드)
    ...
    conn.commit()
    return len(chunks)

청크·벡터 삽입 — index_file 뒷부분

앞 슬라이드의 # 4) 저장 이하가 아래처럼 이어진다.

    # 4) 저장
    cur = conn.execute(
        "INSERT INTO sources (path, mtime, doc_type, indexed_at) VALUES (?, ?, ?, ?)",
        (str(path), mtime, doc_type, datetime.utcnow().isoformat()))
    source_id = cur.lastrowid
    for ord_, (chunk, vec) in enumerate(zip(chunks, vecs)):
        cur = conn.execute(
            "INSERT INTO chunks (source_id, ord, start_line, end_line, text) "
            "VALUES (?, ?, ?, ?, ?)",
            (source_id, ord_, chunk["start_line"], chunk["end_line"], chunk["text"]))
        conn.execute("INSERT INTO embeddings (chunk_id, dim, vec) VALUES (?, ?, ?)",
                     (cur.lastrowid, EMBED_DIM, vec.tobytes()))
    conn.commit()
    return len(chunks)

폴더 인덱싱 · 삭제 감지 — index_folder

폴더 전체 훑기와 삭제된 파일 정리를 한 함수에.

def index_folder(conn: sqlite3.Connection, root: Path,
                 patterns: list[str] = None) -> dict:
    patterns = patterns or ["*.md", "*.markdown", "*.txt",
                            "*.py", "*.ts", "*.js"]
    files = set()
    for pat in patterns:
        files.update(root.rglob(pat))

    stats = {"added": 0, "skipped": 0, "removed": 0, "chunks": 0}
    for f in files:
        n = index_file(conn, f)
        if n: stats["added"] += 1; stats["chunks"] += n
        else: stats["skipped"] += 1

    # 디스크에 없는데 sqlite 에 남은 것 정리 (orphans)
    known = {r[0] for r in conn.execute("SELECT path FROM sources")}
    disk = {str(f) for f in files}
    for path in known - disk:
        conn.execute("DELETE FROM sources WHERE path = ?", (path,))
        stats["removed"] += 1
    conn.commit()
    return stats

유사도 검색 — searcher.py · numpy 벡터화

searcher.py — 질의를 받아 상위 K 개 청크 반환.

"""유사도 검색."""
import numpy as np, sqlite3
from indexer import embed_batch

SQL = ("SELECT e.chunk_id, e.vec, c.text, c.start_line, c.end_line, s.path, s.doc_type "
       "FROM embeddings e JOIN chunks c ON c.id = e.chunk_id "
       "JOIN sources s ON s.id = c.source_id")

def search(conn: sqlite3.Connection, query: str, top_k: int = 5) -> list[dict]:
    if not query.strip(): return []
    q_vec = embed_batch([query])[0]                       # (1536,)
    rows = conn.execute(SQL).fetchall()
    if not rows: return []

    vecs = np.stack([np.frombuffer(r[1], dtype=np.float32) for r in rows])
    q_norm  = q_vec / (np.linalg.norm(q_vec) + 1e-8)      # 0 벡터 방어
    v_norms = vecs / (np.linalg.norm(vecs, axis=1, keepdims=True) + 1e-8)
    scores  = v_norms @ q_norm                            # (N,) 코사인 유사도
    top_idx = np.argsort(-scores)[:top_k]
    return [{"score": float(scores[i]), "path": rows[i][5], "doc_type": rows[i][6],
             "start_line": rows[i][3], "end_line": rows[i][4], "text": rows[i][2]}
            for i in top_idx]

🎨 이미지 프롬프트: "Editorial illustration on dark navy #0f1722 background — horizontal 5-stage pipeline flowing left to right. Stage 1 'Query' with question mark icon. Stage 2 'Embed' with vector arrow. Stage 3 'Search' with magnifier. Stage 4 'Rerank' with sort icon. Stage 5 'Result' with 3 chunks showing DESCENDING similarity scores 0.92, 0.87, 0.73, each chunk labeled with plausible file path like 'docs/deployment.md', 'docs/architecture.md', 'notes/setup.md'. Similarity scores MUST be descending. Clean editorial style, 16:9. English ONLY."

검색 파이프라인 — 한눈 요약

PART 4

MCP 서버 노출 — Tool · Resource · Watchdog · 등록

Tool · Resource 설계 — 두 조각의 역할

서버는 Tool 하나, Resource 하나를 노출한다.

FastMCP 서버 뼈대 — server.py

server.py 의 도입부. 로거·루트 폴더 확정·FastMCP 인스턴스.

"""파일 시스템 인덱서 + RAG 검색 MCP 서버."""
import os, sys, logging
from pathlib import Path
from mcp.server.fastmcp import FastMCP
from indexer import get_db, index_folder, index_file
from searcher import search as search_impl

logging.basicConfig(level=logging.INFO, stream=sys.stderr,
                    format="%(asctime)s [%(levelname)s] %(message)s")
log = logging.getLogger("rag-indexer")
ROOT = Path(os.environ["RAG_INDEX_ROOT"]).expanduser().resolve()
mcp = FastMCP("rag-indexer")

search Tool — docstring 이 곧 LLM 스펙

@mcp.tool()
def search(query: str, top_k: int = 5) -> list[dict]:
    """파일 인덱스에서 질의와 관련된 문서 조각을 유사도 상위 K개 반환한다.

    Args:
        query: 검색 질의. 자연어 문장.
        top_k: 반환할 조각 개수. 기본 5, 최대 20 권장.

    Returns:
        각 조각은 dict — score·path·doc_type·start_line·end_line·text 키.
        결과는 유사도 내림차순.
    """
    log.info("search: %r / top_k=%d", query, top_k)
    conn = get_db()
    try:
        return search_impl(conn, query, top_k=min(top_k, 20))
    finally:
        conn.close()

file:// Resource — 경로 탈출 방어

Resource 는 URI 로 참조되며, {path} 파라미터가 자동 매핑된다.

@mcp.resource("file://{path}")
def file_content(path: str) -> str:
    """인덱스에 있는 파일의 원문. LLM 이 검색 청크의 path 를 그대로 열어
    파일 전체를 컨텍스트로 가져갈 수 있다."""
    from urllib.parse import unquote
    target = Path(unquote(path)).resolve()
    try:
        target.relative_to(ROOT)                 # target 이 ROOT 하위가 아니면
    except ValueError:                           # ValueError 발생 → 경로 탈출 시도로 판정
        raise PermissionError(f"인덱스 밖 파일 접근 금지: {target}")
    if not target.is_file():
        raise FileNotFoundError(str(target))
    return target.read_text(encoding="utf-8", errors="ignore")

📖 MCP · Build an MCP server · MCP Python SDK · GitHub

watchdog · 실시간 인덱싱

서버가 뜬 동안 폴더 변경을 즉시 반영한다. watchdog 의 Observer 가 별도 스레드로 파일 이벤트를 감지해 Handler 로 재인덱싱을 넘긴다 — 메인 서버는 MCP 응답에 전념.

from watchdog.events import PatternMatchingEventHandler
from watchdog.observers import Observer

class RagHandler(PatternMatchingEventHandler):
    def __init__(self):
        super().__init__(patterns=["*.md", "*.txt", "*.py", "*.ts", "*.js"],
                         ignore_directories=True)

    def _reindex(self, path: str):
        try:
            conn = get_db()
            log.info("reindexed %s (%d chunks)", path, index_file(conn, Path(path)))
            conn.close()
        except Exception as e:
            log.error("reindex failed: %s / %s", path, e)

    def on_created(self, event):  self._reindex(event.src_path)
    def on_modified(self, event): self._reindex(event.src_path)
    def on_deleted(self, event):
        conn = get_db()
        conn.execute("DELETE FROM sources WHERE path = ?", (event.src_path,))
        conn.commit(); conn.close()

📖 watchdog · PyPI

watcher 시작 · 서버 부트스트랩

Observer 를 데몬 스레드로 띄우고, 서버 진입점에서 초기 인덱싱 + 워처 시작을 한 번에 처리한다.

def start_watcher(root: Path):
    observer = Observer()
    observer.schedule(RagHandler(), str(root), recursive=True)
    observer.daemon = True
    observer.start()
    log.info("watcher started on %s", root)

def bootstrap():
    conn = get_db()
    stats = index_folder(conn, ROOT)
    log.info("initial index: %s", stats)
    conn.close()
    start_watcher(ROOT)

if __name__ == "__main__":
    bootstrap()
    mcp.run()

Claude Code 등록 — claude mcp add

Claude Code 에서 서버를 붙이는 명령은 하나다. 환경 변수 3개를 함께 담는다.

claude mcp add rag-indexer \
  --env OPENAI_API_KEY=sk-... \
  --env RAG_INDEX_ROOT=/home/me/notes \
  --env RAG_DB_PATH=/home/me/.rag/index.db \
  -- python /absolute/path/to/server.py

claude mcp list          # rag-indexer  running  1 tool · 1 resource

회의록 중에 배포 실패
원인 언급된 것 찾아줘

Codex 등록 · 한 서버 두 클라이언트

Codex 는 ~/.codex/config.toml 에 정의한다. 서버 코드는 동일, 등록 방식만 다르다.

[mcp.servers.rag-indexer]
command = "python"
args = ["/absolute/path/to/server.py"]

[mcp.servers.rag-indexer.env]
OPENAI_API_KEY = "sk-..."
RAG_INDEX_ROOT = "/home/me/notes"
RAG_DB_PATH = "/home/me/.rag/index.db"

PART 5

재순위화 · 확장 — 실전 시나리오 · rerank · 확장 5선

실전 시나리오 3종 — 개념·심볼·크로스 파일

Claude Code 대화창에서 실제로 써 본다.

결제 실패 관련
회의록 찾아줘

인덱서에서 mtime
비교하는 부분 어디야?

이번 달 회의록 3개 훑고
배포 관련 결정 사항만
정리해줘

🎨 Image Prompt: "Editorial illustration on dark navy #0f1722 background — vertical flow inside a Claude Code terminal window, top a natural language prompt bubble labeled 'Ask', below three horizontal Tool call cards each labeled 'search' with small query text, below two file resource cards labeled 'file://' with document icons, at the bottom a rendered markdown answer panel labeled 'Result' with a few teal bullet lines — connectors between layers are thin purple arrows — teal #00b894 and purple #6c5ce7 accents, 16:9. CRITICAL: All visible text MUST be in English ONLY. Each label appears EXACTLY ONCE. No mirrored text."

시나리오 흐름 — 자연어 → 툴 → 리소스 → 답변

재순위화 — 필요와 함정

코사인 유사도 상위 5개가 항상 최선은 아니다. 'SLA 관련 논의' 검색에서 SLA 라는 단어가 지나가는 말로 한 번 언급된 청크가 상위에 뜨는 식.

🧠 왜 — 임베딩은 단어의 존재만으로도 유사도가 오른다. 'SLA' 를 스쳐 언급한 회의록 각주가 상위 5에 섞인다. 재순위화는 이 노이즈를 LLM 의 의미 판단으로 걷어내는 후처리.

RERANK_PROMPT = """질의 '{query}' 의 검색 후보 {n}개를 0~10 점으로 평가.
10점 직접 답변 · 5점 부수적 · 0점 무관.
후보 번호·점수·이유(한 문장) 를 JSON 배열로 반환.
--- 후보 ---
{candidates}"""

def rerank(query: str, results: list[dict]) -> list[dict]:
    from anthropic import Anthropic
    client = Anthropic()
    candidates = "\n\n".join(
        f"[{i}] {r['path']}\n{r['text'][:500]}"
        for i, r in enumerate(results))
    resp = client.messages.create(
        model="claude-haiku-4-5", max_tokens=1000,
        messages=[{"role": "user",
                   "content": RERANK_PROMPT.format(
                       query=query, n=len(results), candidates=candidates)}])
    # 점수 파싱 · 재정렬 (파싱 실패 시 원 순위 유지)
    ...

확장 아이디어 5선 — 같은 뼈대에서 방향만

PART 6

정리 · 코스 마무리

만든 것 · 얻은 것 — 300줄의 네 가지 자산

85분 동안 만든 것은 indexer.py · searcher.py · watcher.py · server.py 네 파일. 실제 코드 300줄 남짓. 그 300줄로 다음을 얻었다.

📌 재사용 지점 4가지

코스 완주 · 수고 많으셨습니다

오늘 만든 300줄의 RAG 서버가 실무에서 계속 쓰이게 만드는 것은 코드 실력이 아니라 실험 습관이다. '이 검색을 매일 쓰는 문서 폴더에 붙여 보자' 는 한 번의 결정이 다음 실험으로 이어지고, 확장은 그 과정에서 자연스럽게 따라온다.

여기까지 오신 노력, 정말 수고 많으셨습니다. 🎉

🎨 이미지 프롬프트: "Editorial illustration on dark navy #0f1722 background — closing ring composition with hub in center labeled 'RAG MCP Server'. Four spokes radiating outward to labeled clients: 'Claude Code' (appearing EXACTLY ONCE), 'Codex', 'Cursor', 'Windsurf'. Clean editorial style, teal + purple accents, 16:9. English ONLY, each label EXACTLY ONCE."

코스 완주 · 수고 많으셨습니다

하네스 다음 — 에이전트 시스템 엔지니어링

하네스 다음이 무엇인지에 대해서는 아직 하나의 용어가 정착하지 않았다. 여러 흐름으로 분화하는 중이고, 각 진영이 서로 다른 이름을 붙이고 있다. 한 우산으로 묶으면 에이전트 시스템 엔지니어링 이다.

프롬프트 → 컨텍스트 → 하네스 — 이 코스가 채운 세 축. → 에이전트 오케스트레이션 → 운영 · 신뢰성 → 에이전틱 조직 — 그 너머로 이어지는 세 축. 앞의 세 축은 그 자체로 완결이 아니라 더 긴 사슬의 앞부분이다.

선명한 세 계단은 이 코스가 밟은 자리 · 점선 세 계단은 아직 형성 중인 자리

다섯 갈래 ①∼③ — 나누고 · 지켜보고 · 검증한다

다섯 갈래 ④∼⑤ — 잇고 · 배분한다

커뮤니티 생태계 — 기본기를 프레임워크로 엮다

기본기 다음, 남들은 이 확장들(Skills · CLAUDE.md · subagent)을 어떻게 프레임워크로 묶었나. 각기 다른 실패 모드를 겨냥한 셋을 본다.

한 겹 더 — 어떻게 쓰나 · 주요 기능 · repo

겉모습은 저마다 다르다. 안을 뜯어보면 Skills · 플러그인 · subagent · worktree · TDD 의 조합이다.

코스와의 연결 — 여기까지 만들었다 · 여기서부터 이어진다

다섯 갈래는 먼 이야기가 아니다. 이 2일 동안 손으로 만져 본 것들이 그 입구다.

바이브코딩은 개인 생산성 기술로 시작해 시스템 설계 기술로 넘어가는 중이다. 이 코스가 채운 것은 그 앞의 세 축이고, 그 세 축이 없으면 뒤의 세 축은 세우지 못한다.