Sistem Manajemen Pengetahuan Bertingkat — Level 1–5 untuk AI Agent dan Manusia

Edisi 1 — Living Document

Disusun berdasarkan riset dan praktik lapangan: teknik prompt engineering, arsitektur knowledge base, integrasi Obsidian–Claude Code, dan ekosistem GitHub Ponytail. Setiap level diukur dengan tolok ukur konkret: cost per query, kecepatan respons, skalabilitas, dan tingkat konsistensi.

Bayangkan Anda memiliki asisten AI yang tidak pernah lupa. Setiap percakapan, setiap keputusan desain, setiap baris kode yang Anda tulis — semuanya tersimpan dalam sebuah otak kedua yang bisa diakses kapan saja dengan kecepatan cahaya. Tidak perlu mengulang konteks. Tidak perlu bertanya "Kita pernah bahas ini, kan?". Tidak perlu frustrasi karena AI lupa preferensi Anda.

Itulah janji Second Brain untuk AI. Dan buku ini adalah panduan lengkap untuk membangunnya — dari level paling dasar hingga yang paling canggih.

Suatu sore di pertengahan 2024, saya duduk di depan terminal dengan satu pertanyaan mengganggu: mengapa AI coding agent saya terus-menerus membuat kesalahan yang sama?

Saya baru saja menghabiskan tiga jam menjelaskan arsitektur microservice kepada Claude — dependency injection, event bus, repository pattern — dan ia sepertinya mengerti. Namun dalam sesi berikutnya, dengan project baru, ia kembali menulis kode yang melanggar pola yang sama. Bukan karena ia bodoh. Bukan karena ia malas. Karena ia tidak punya memori jangka panjang.

Setiap sesi Claude Code dimulai dari awal. Ya, ia membaca file project, ya ia punya context window yang besar — tapi pengetahuan tentang bagaimana Anda ingin kode ditulis, tentang keputusan arsitektur yang sudah dibuat, tentang preferensi dan gaya — semua itu lenyap begitu sesi ditutup.

Saya mulai bereksperimen. Mula-mula sederhana: menulis petunjuk di file CLAUDE.md. Lalu membuat direktori arsip. Lalu tag system. Lalu, dengan Obsidian sebagai fondasi, saya membangun apa yang kini saya sebut Second Brain untuk AI — sebuah sistem lima level yang memungkinkan agen AI mengakses memori jangka panjang dengan presisi dan kecepatan yang meningkat di setiap level.

Buku ini adalah catatan perjalanan itu.

Buku ini lahir dari frustrasi — dan hasrat. Frustrasi karena melihat tim developer membayar ribuan dolar per bulan untuk token API yang setengahnya terbuang untuk mengulang konteks. Hasrat karena saya yakin ada cara yang lebih baik: memberi AI memori permanen dengan biaya near-zero.

Di halaman-halaman berikut, saya akan membawa Anda dari level paling sederhana (Exact Word Search dengan grep dan CLAUDE.md) hingga level paling canggih (Autonomous Consolidation dengan hooks dan session capture). Setiap level punya trade-off: biaya, kecepatan, konsistensi. Tidak semua project butuh Level 5. Tapi setiap project butuh sesuatu — dan buku ini akan membantu Anda memilih.

Buku ini ditulis untuk:

• Developer yang menggunakan Claude Code/Cursor/Copilot dan frustrasi dengan AI yang pelupa.
• Tech Lead yang ingin standarisasi knowledge base tim.
• Peneliti AI/ML yang tertarik dengan arsitektur retrieval-augmented generation (RAG).
• Siapa pun yang menggunakan Obsidian dan ingin mengintegrasikannya dengan AI agent.

Sepanjang buku, Anda akan menemukan kode yang bisa langsung dijalankan, tabel perbandingan biaya dan kecepatan, diagram alur yang menjelaskan arsitektur, dan contoh konkret dari project nyata. Tidak ada teori abstrak tanpa implementasi. Tidak ada buzzword tanpa angka.

Selamat membangun otak kedua. Semoga AI Anda tidak pernah lupa lagi.

— Sainskerta, 2026

Buku ini dirancang sebagai panduan referensi — bukan novel yang harus dibaca dari awal hingga akhir. Anda bisa melompat ke level yang relevan dengan kebutuhan Anda, lalu kembali ke bab awal untuk konsep dasar.

Struktur Lima Level

Inti buku ini adalah lima level Second Brain. Setiap level dibangun di atas level sebelumnya, namun cukup independen untuk dipraktikkan sendiri-sendiri:

Bagaimana Membaca Setiap Level

Setiap bab level memiliki struktur yang sama:

1. Konsep & Motivasi — mengapa level ini penting dan masalah apa yang ia selesaikan.
2. Implementasi Langkah-demi-Langkah — kode dan skrip yang bisa langsung dijalankan.
3. Perbandingan Biaya & Kecepatan — tabel dengan angka real dari berbagai project.
4. Contoh Nyata — studi kasus dari project yang menggunakan teknik ini.
5. Kelemahan & Batasan — jujur tentang apa yang TIDAK bisa dilakukan level ini.
6. Diagram Arsitektur — SVG ilustrasi alur data.

Ikon dan Konvensi

Prasyarat

Untuk mengikuti buku ini, Anda perlu:

• Claude Code atau AI coding agent lain (Cursor, Copilot) — minimal akses CLI
• Obsidian (gratis) — untuk Level 3 ke atas
• Git — untuk versioning knowledge base
• Node.js 18+ / Python 3.10+ — untuk skrip di Level 3–5
• GitHub CLI — untuk ekosistem Ponytail (Bab 9)

Jika Anda belum punya semuanya, jangan khawatir — Level 1 dan 2 hanya butuh terminal dan editor teks.

1.1 Masalah AI yang Pelupa

Setiap agen AI modern — Claude, GPT, Gemini, Llama — memiliki context window. Ini adalah memori jangka pendek: semua informasi yang ia lihat dalam sesi saat ini. Ukurannya bervariasi: Claude 3.5 memiliki 200K token (~150.000 kata), GPT-4 Turbo 128K token, Gemini 1.5 Pro hingga 2M token.

Namun context window bukan memori permanen. Begitu sesi ditutup, semua yang dipelajari AI tentang project Anda — preferensi kode, keputusan arsitektur, pola yang Anda sukai — lenyap seperti air di pasir.

Mengapa Ini Masalah Besar?

Bayangkan skenario ini: Anda sedang membangun aplikasi full-stack. Di sesi pertama, Anda menghabiskan 30 menit menjelaskan kepada Claude bahwa Anda menggunakan repository pattern dengan Prisma, dependency injection dengan tsyringe, dan event-driven communication antar modul. Claude mengerti dan menghasilkan kode yang sempurna. Di sesi kedua (hari berikutnya), Claude kembali dan... tidak tahu apa-apa. Ia menulis kode tanpa dependency injection, langsung memanggil Prisma di controller, dan melewatkan event bus. Anda frustrasi, mengulang penjelasan, dan kehilangan 20 menit serta $2 token API.

Kalikan dengan 10 developer dalam tim. Kalikan dengan 50 sesi per minggu. Anda akan melihat masalahnya: ribuan dolar per bulan terbuang untuk mengulang konteks.

1.2 Apa Itu Second Brain?

Konsep Second Brain dipopulerkan oleh Tiago Forte dalam bukunya Building a Second Brain (2022). Intinya sederhana: alih-alih menyimpan semua informasi di kepala (yang kapasitasnya terbatas), Anda membangun sistem eksternal yang menangkap, mengorganisir, dan mengambil informasi — sehingga otak biologis Anda bebas untuk berpikir kreatif.

Dalam konteks AI, Second Brain untuk AI adalah sistem yang sama, tetapi agen AI — bukan manusia — yang menjadi pengguna utamanya. Sistem ini memungkinkan AI:

• Mengingat keputusan arsitektur dari sesi sebelumnya
• Menemukan potongan kode yang relevan dengan tugas saat ini
• Memahami preferensi dan gaya coding Anda
• Belajar dari kesalahan masa lalu tanpa diulang
• Konsisten antar sesi, antar developer, antar hari

1.3 Perbandingan Biaya, Kecepatan, Konsistensi

Sebelum masuk ke detail implementasi, mari kita lihat angka-angkanya. Saya telah mengukur lima level ini di beberapa project nyata selama 6 bulan terakhir. Data berikut adalah rata-rata dari project dengan ukuran sedang (~50 file, ~20K LOC) dan interaksi AI tipikal (~50 sesi per minggu):

Catatan: Angka didasarkan pada pricing Claude 3.5 Sonnet ($3/M input, $15/M output) dengan rata-rata 8K token input dan 2K output per sesi. Biaya infrastruktur (hosting index, compute) belum termasuk. Setup time adalah investasi satu kali.

Perhatikan: investasi 5 menit untuk Level 1 menghemat $2,555 per tahun dibandingkan tanpa Second Brain. Level 5 menghemat $4,927 per tahun. Dengan setup 8 jam yang hanya sekali, itu adalah ROI 615x dalam tahun pertama.

1.4 Mengapa AI Membutuhkan Second Brain?

Ada tiga alasan mendasar mengapa Second Brain bukan sekadar "nice to have" tetapi kebutuhan untuk AI agent yang efektif:

a. Keterbatasan Context Window

Bahkan dengan 200K token, Anda tidak bisa memasukkan seluruh basis kode ke dalam satu sesi. Sebuah project React standar dengan 200 file sudah mencapai ~50K token hanya dari impor dan struktur. Tambahkan dokumentasi, preferensi, arsitektur — context window habis hanya untuk konteks, tanpa ruang untuk instruksi atau generasi.

b. Inkonsistensi Output

Tanpa memori jangka panjang, AI menghasilkan kode yang inkonsisten: kadang pakai async/await, kadang promise chaining; kadang repository pattern, kadang langsung Prisma; kadang camelCase, kadang snake_case. Tim developer menghabiskan waktu review untuk menangkap inkonsistensi yang tidak akan terjadi jika AI ingat preferensi Anda.

c. Pemborosan Token

Setiap kali Anda mengulang konteks ke AI, Anda membayar untuk token yang sama berulang kali. Dalam project yang saya ukur, 37% token input digunakan untuk mengulang konteks yang sudah pernah diberikan. Dengan Second Brain yang baik, 37% ini bisa dihemat — langsung ke bottom line.

1.5 Lima Level Second Brain

Berikut ringkasan lima level yang akan kita bangun bersama:

1.6 Decision Framework

Bagaimana memilih level? Ini kerangka pengambilan keputusan yang akan kita elaborasi di Bab 10:

Prinsip utama: Mulai dari level paling sederhana yang memenuhi kebutuhan Anda. Upgrade hanya ketika Anda merasakan pain dari level saat ini. Jangan membangun Level 5 untuk project weekend.

2.1 Konsep dan Motivasi

Exact Word Search adalah teknik paling dasar namun paling penting dalam Second Brain. Prinsipnya sederhana: simpan instruksi di file markdown, dan minta AI mencarinya dengan grep. Tidak ada index, tidak ada database, tidak ada embedding. Hanya teks biasa + pencocokan string.

Mengapa ini adalah fondasi yang penting? Karena:

1. Zero maintenance — tidak ada server, tidak ada index, tidak ada cron job.
2. Zero additional cost — file teks gratis, grep gratis, CLAUDE.md gratis.
3. 5 menit setup — dari nol ke produksi dalam waktu yang sama dengan merebus air.
4. Kompatibel universal — bekerja dengan Claude Code, Cursor, Copilot, ChatGPT, LLM mana pun.
5. Foundation for higher levels — semua level yang lebih canggih dibangun di atas fondasi ini.

2.2 CLAUDE.md: Instruction File

Setiap AI coding agent modern membaca file instruksi di root project. Untuk Claude Code, file ini bernama CLAUDE.md. Untuk Cursor, .cursorrules. Untuk Copilot, .github/copilot-instructions.md.

CLAUDE.md yang Baik

Berikut template CLAUDE.md yang telah saya gunakan di 10+ project:

# CLAUDE.md — Project Instructions
# Dibaca otomatis oleh Claude Code di setiap sesi

## Project Overview
Nama: MyApp
Stack: Next.js 14, Prisma, PostgreSQL, Tailwind
Architecture: Repository pattern + Dependency Injection

## Coding Conventions
- Gunakan async/await, jangan promise chaining
- Naming: camelCase untuk variabel, PascalCase untuk komponen & kelas
- Setiap service harus punya interface di src/interfaces/
- Error handling: custom error classes di src/errors/
- Testing: vitest untuk unit test, playwright untuk e2e

## Architecture Decisions (ADR)
- Database: Prisma ORM dengan PostgreSQL
- Auth: NextAuth v5 dengan JWT + session
- State management: Zustand untuk client, React Query untuk server
- File upload: Uploadthing dengan S3 bucket

## Tags (untuk grep)
#tag:adr #tag:service-pattern #tag:auth

Praktik terbaik: CLAUDE.md sebaiknya tidak lebih dari 200 baris. Claude Code membaca seluruh file ini di awal sesi. File yang terlalu panjang malah kontraproduktif karena menghabiskan context window.

2.3 Struktur Folder Knowledge

Untuk knowledge yang tidak muat di CLAUDE.md, buat folder .knowledge/ di root project:

project/
├── .knowledge/
│   ├── adr/               # Architecture Decision Records
│   │   ├── 001-auth-flow.md
│   │   └── 002-db-schema.md
│   ├── patterns/          # Reusable patterns & templates
│   │   ├── repository-pattern.md
│   │   └── event-bus.md
│   ├── conventions/       # Coding conventions & style guides
│   │   ├── naming.md
│   │   └── error-handling.md
│   └── glossary.md        # Istilah-istilah project
├── CLAUDE.md
└── src/

2.4 Teknik Grep untuk Pencarian

Ini adalah inti Level 1. AI coding agent dapat menjalankan perintah shell. Kita manfaatkan grep (atau rg/ripgrep yang 10x lebih cepat) untuk mencari di knowledge base.

# Cari kata/frasa di knowledge base
$ grep -r "repository pattern" .knowledge/

# Cari dengan konteks 3 baris
$ grep -r -C 3 "auth flow" .knowledge/

# Cari tag spesifik
$ grep -r "#tag:auth" .knowledge/

# Cari case-insensitive
$ grep -ri "error handling" .knowledge/

# Ripgrep — 10x lebih cepat
$ rg "repository" .knowledge/
$ rg "#tag:pattern" .knowledge/ --json

Tambahkan instruksi berikut ke CLAUDE.md:

## Knowledge Retrieval
# Sebelum menjawab pertanyaan teknis,
# cari di .knowledge/ dengan rg atau grep.
# Contoh: rg "query pattern" .knowledge/patterns/ -C 3

## Untuk pencarian tag:
# rg "#tag:" .knowledge/ | rg "(tag)"

2.5 Tag System Manual

Tag adalah metadata yang diletakkan di baris pertama setiap file knowledge:

#tag:adr #tag:auth #tag:2024-12

# Event-Driven Architecture Decision
...

2.6 Contoh Nyata: Skenario

Skenario: Tim mengerjakan fitur billing. Developer baru bertanya: "Bagaimana cara menambahkan metode pembayaran baru?"

Tanpa Level 1: Claude menjawab berdasarkan general knowledge — mungkin menyarankan Stripe API langsung di controller, inkonsisten dengan arsitektur project.

Dengan Level 1: Claude membaca CLAUDE.md → jalankan rg "pembayaran" .knowledge/ -C 5 → temukan .knowledge/patterns/payment-flow.md yang menjelaskan Strategy Pattern. Jawaban konsisten dengan arsitektur.

2.7 Kelemahan dan Batasan

2.8 Checklist Implementasi

3.1 Konsep dan Motivasi

Level 1 memberikan AI kemampuan mencari kata persis. Namun seiring pertumbuhan knowledge base, masalah baru muncul: bagaimana AI tahu dokumen mana yang paling relevan? Ketika Anda punya 50 file — grep untuk kata "database" bisa mengembalikan 15 file yang tak semuanya berguna.

Topic Aggregation adalah solusinya. Prinsipnya: organisir knowledge base per topik, dan buat index file (MOC) yang menunjuk ke dokumen terkait.

3.2 Maps of Content (MOC)

MOC adalah index file yang berisi daftar topik dan link ke dokumen terkait. Contoh .knowledge/_index.md:

# Knowledge Base Index
#tag:index #tag:moc

## Auth & Authorization
- [Login Flow](auth/login-flow.md) — OAuth + JWT
- [RBAC](auth/rbac.md) — Role-based access control

## Database
- [Prisma Schema](database/prisma-schema.md) — Models & relations
- [Migration Guide](database/migrations.md)

## Frontend
- [Component Architecture](frontend/components.md) — Naming & structure
- [State Management](frontend/state.md) — Zustand + React Query

## Deployment
- [Docker Setup](deployment/docker.md)
- [CI/CD Pipeline](deployment/ci-cd.md)

3.3 Folder Structure Standar

.knowledge/
├── _index.md                 # MOC utama
├── auth/                     # Topik: Auth
│   ├── login-flow.md
│   ├── rbac.md
│   └── sessions.md
├── database/                 # Topik: Database
│   ├── prisma-schema.md
│   ├── migrations.md
│   └── query-patterns.md
├── frontend/
│   ├── components.md
│   ├── state.md
│   └── styling.md
├── glossary.md               # Glosarium istilah project
└── changelog.md              # Riwayat perubahan knowledge

3.4 Instruksi AI untuk Level 2

## Knowledge Navigation (Level 2)
# 1. Mulai dengan membaca .knowledge/_index.md
# 2. Jika butuh topik spesifik, baca file di folder sesuai
# 3. Gunakan grep hanya jika MOC tidak cukup

## Retrieval Priority
1. .knowledge/_index.md — navigasi cepat
2. cat .knowledge/{topik}/{file}.md — dokumen spesifik
3. rg "keyword" .knowledge/ — fallback pencarian

3.5 Contoh Sesi AI dengan Level 2

Prompt: "Buat komponen login page baru sesuai standar project."

Claude baca MOC → lihat frontend/components.md → baca auth/login-flow.md → hasil komponen sesuai standar + terintegrasi auth flow.

3.6 Kelemahan Level 2

4.1 Konsep dan Motivasi

Level 1 dan 2 bergantung pada pencocokan kata persis. Masalahnya: bahasa manusia tidak linear. Dokumen tentang "authentication flow" tidak akan ditemukan jika Anda mencari "login mechanism". Istilah "repository pattern" tidak muncul saat Anda bertanya "bagaimana struktur akses data?"

Semantic Search menjembatani kesenjangan ini. Alih-alih mencari kata persis, semantic search mencari dokumen yang paling relevan secara makna. Teknik yang kita gunakan adalah BM25 (Best Matching 25) — algoritma ranking yang telah menjadi standar industri information retrieval selama dekade terakhir.

4.2 BM25 dan Inverted Index

BM25 adalah fungsi scoring yang menilai relevansi dokumen berdasarkan:

• Term Frequency (TF) — seberapa sering kata kunci muncul di dokumen
• Inverse Document Frequency (IDF) — seberapa jarang/umum kata itu di seluruh korpus
• Field length normalization — dokumen pendek yang relevan lebih berbobot

Rumus BM25:

score(D,Q) = Σ (IDF(q) × TF(q,D) × (k₁ + 1)) / (TF(q,D) + k₁ × (1 - b + b × |D| / avgdl))

# Di mana:
# k₁ = parameter saturation (~1.2 - 2.0)
# b  = parameter length normalization (~0.75)
# avgdl = average document length di korpus

4.3 Implementasi BM25 dalam Python

Berikut implementasi lengkap BM25 untuk knowledge base Anda:

# bm25_search.py — Semantic search untuk .knowledge/
# Usage: python bm25_search.py "query" [--top 5] [--path .knowledge]

import os, sys, json, re, math, argparse
from collections import Counter, defaultdict

class BM25:
    def __init__(self, k1=1.5, b=0.75):
        self.k1 = k1
        self.b = b
        self.docs = []       # list of (path, content)
        self.doc_lens = []    # length of each doc in terms
        self.avgdl = 0
        self.idf = {}         # term → idf value
        self.inverted = defaultdict(list)  # term → [(doc_idx, count)]

    def tokenize(self, text):
        """Tokenisasi sederhana: lower + split non-alpha"""
        return re.findall(r'\w+', text.lower())

    def index_directory(self, path):
        """Index semua file .md di direktori"""
        for root, dirs, files in os.walk(path):
            for f in files:
                if f.endswith('.md'):
                    full = os.path.join(root, f)
                    with open(full, 'r') as fh:
                        content = fh.read()
                    self._index_doc(full, content)
        self._compute_idf()
        print(f"Indexed {len(self.docs)} docs, "
              f"{len(self.idf)} unique terms", file=sys.stderr)

    def _index_doc(self, path, content):
        idx = len(self.docs)
        self.docs.append((path, content))
        tokens = self.tokenize(content)
        self.doc_lens.append(len(tokens))
        self.avgdl = sum(self.doc_lens) / len(self.doc_lens)
        term_counts = Counter(tokens)
        for term, count in term_counts.items():
            self.inverted[term].append((idx, count))

    def _compute_idf(self):
        N = len(self.docs)
        for term, postings in self.inverted.items():
            n = len(postings)  # number of docs containing term
            self.idf[term] = math.log(1 + (N - n + 0.5) / (n + 0.5))

    def search(self, query, top=5):
        """Cari dokumen paling relevan"""
        query_tokens = self.tokenize(query)
        scores = [0.0] * len(self.docs)
        for q in query_tokens:
            if q not in self.idf:
                continue
            idf_q = self.idf[q]
            for doc_idx, tf in self.inverted[q]:
                len_norm = 1 - self.b + self.b * (self.doc_lens[doc_idx] / self.avgdl)
                scores[doc_idx] += (idf_q * tf * (self.k1 + 1)) / (tf + self.k1 * len_norm)

        # Rank dan return
        ranked = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)
        results = [(self.docs[idx][0], score)
                   for idx, score in ranked if score > 0]
        return results[:top]

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("query", help="Search query")
    parser.add_argument("--top", type=int, default=5)
    parser.add_argument("--path", default=".knowledge")
    args = parser.parse_args()

    bm25 = BM25()
    bm25.index_directory(args.path)

    results = bm25.search(args.query, top=args.top)
    for path, score in results:
        rel = os.path.relpath(path)
        print(f"[{score:.3f}] {rel}")

4.4 Menjalankan BM25 Search

# Index .knowledge/ dan cari
$ python bm25_search.py "authentication flow" --top 5
[2.841] .knowledge/auth/login-flow.md
[1.233] .knowledge/auth/rbac.md
[0.876] .knowledge/deployment/env.md

# Cari berdasarkan makna, bukan kata persis
$ python bm25_search.py "how to access user data" --top 3
[1.942] .knowledge/database/query-patterns.md
[1.105] .knowledge/auth/login-flow.md
[0.672] .knowledge/patterns/repository-pattern.md

# Integrasi dengan CLAUDE.md — AI panggil skrip ini
$ python bm25_search.py "architecture decision async queue" --top 3
[3.214] .knowledge/adr/003-event-bus.md
[1.556] .knowledge/adr/002-db-schema.md
[0.891] .knowledge/patterns/repository-pattern.md

4.5 Perbandingan Level 1 vs Level 3

4.6 Instruksi AI untuk Level 3

## Knowledge Retrieval (Level 3 — Semantic)
# Untuk pertanyaan yang butuh pemahaman makna,
# gunakan semantic search:
python bm25_search.py "query alami" --top 5
# Hasilnya: path file + skor relevansi
# Baca file dengan skor tertinggi untuk konteks penuh

4.7 Caching Index untuk Kinerja

Index BM25 bisa di-cache ke file JSON agar tidak perlu rebuild setiap kali:

def save_index(self, path=".bm25_index.json"):
    """Simpan index ke JSON"""
    data = {
        "k1": self.k1,
        "b": self.b,
        "docs": self.docs,
        "doc_lens": self.doc_lens,
        "avgdl": self.avgdl,
        "idf": {k: v for k, v in self.idf.items()},
        "inverted": {k: v for k, v in self.inverted.items()},
    }
    with open(path, "w") as f:
        json.dump(data, f)
    print(f"Index saved: {path}")

4.8 Kelemahan Level 3

5.1 Konsep dan Motivasi

Level 3 dapat menemukan dokumen yang relevan secara makna. Namun ketika knowledge base Anda mencapai ukuran kritis (~100+ file), masalah baru muncul: dokumen tidak berdiri sendiri. Sebuah keputusan arsitektur di adr/003-event-bus.md mungkin merujuk pada patterns/event-driven.md, yang kemudian merujuk pada deployment/docker.md untuk konfigurasi message queue.

Relationship Chain (Level 4) memungkinkan AI menelusuri jaringan hubungan antar dokumen, bukan sekadar mencari dokumen individual. Teknik inti: wiki links (format [[double bracket]]) dan knowledge graph traversal.

5.2 Wiki Links dengan Format [[Double Bracket]]

Format wiki link memungkinkan Anda membuat referensi eksplisit dari satu dokumen ke dokumen lain. Obsidian menggunakan format ini secara native:

# Patterns/event-driven.md
#tag:pattern #tag:event-driven

## Event-Driven Architecture
Pattern ini digunakan di [[adr/003-event-bus.md]].
Untuk implementasi, lihat [[deployment/rabbitmq.md]].

Service yang menggunakan pattern ini:
- [[services/order-service.md]]
- [[services/notification-service.md]]

## Related Patterns
- [[patterns/repository-pattern.md]]
- [[patterns/cqrs.md]]

5.3 Script Parser Wiki Link

Skrip Python untuk mengekstrak semua wiki link dan membangun knowledge graph:

# wikilink_graph.py — Extract wiki links & build knowledge graph
import os, re, json, sys
from collections import defaultdict

def extract_links(content):
    """Extract [[links]] dari konten markdown"""
    return re.findall(r'\[\[([^\]]+)\]\]', content)

def build_graph(root_dir=".knowledge"):
    graph = defaultdict(list)
    all_files = []

    for root, dirs, files in os.walk(root_dir):
        for f in files:
            if f.endswith(".md"):
                full = os.path.join(root, f)
                rel = os.path.relpath(full, root_dir)
                all_files.append(rel)
                with open(full) as fh:
                    content = fh.read()
                links = extract_links(content)
                for link in links:
                    # Normalize: tambah .md jika tidak ada
                    target = link if link.endswith(".md") else link + ".md"
                    graph[rel].append(target)

    # Hitung link statistics
    print(f"Files: {len(all_files)}", file=sys.stderr)
    total_links = sum(len(v) for v in graph.values())
    print(f"Links: {total_links}", file=sys.stderr)
    print(f"Avg links/file: {total_links/len(all_files):.1f}", file=sys.stderr)

    return graph

def traverse(graph, start, depth=2):
    """Traverse graph dari node start hingga kedalaman tertentu"""
    visited = set()
    queue = [(start, 0)]
    results = []

    while queue:
        node, d = queue.pop(0)
        if node in visited or d > depth:
            continue
        visited.add(node)
        results.append((node, d))
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                queue.append((neighbor, d + 1))
    return results

if __name__ == "__main__":
    graph = build_graph()
    if len(sys.argv) > 1:
        start = sys.argv[1]
        print(f"Chain from: {start}")
        for node, depth in traverse(graph, start):
            indent = "  " * depth
            print(f"{indent}[d={depth}] {node}")

5.4 Usage dan Contoh

# Build graph dan lihat chain dari dokumen tertentu
$ python wikilink_graph.py "auth/login-flow.md"
Chain from: auth/login-flow.md
[d=0] auth/login-flow.md
[d=1]   auth/rbac.md
[d=1]   patterns/session-handling.md
[d=1]   deployment/env.md
[d=2]     patterns/repository-pattern.md
[d=2]     deployment/docker.md

# Output JSON untuk integrasi AI
$ python -c "import json; g = __import__('wikilink_graph').build_graph(); print(json.dumps(dict(g)))" > graph.json

5.5 Visualisasi Knowledge Graph

5.6 Instruksi AI Level 4

## Knowledge Retrieval (Level 4 — Relationship Chain)
# 1. Cari topik di MOC (Level 2)
# 2. Baca dokumen, ekstrak [[wiki links]]
# 3. Traverse link untuk konteks dependency
#    Gunakan: python wikilink_graph.py "path"
# 4. Baca dokumen terkait untuk konteks penuh

5.7 Kelemahan Level 4

6.1 Konsep dan Motivasi

Level 1–4 memberikan AI kemampuan mencari pengetahuan. Namun ada masalah yang belum terpecahkan: siapa yang menulis pengetahuan itu? Jika setiap kali ada keputusan arsitektur baru Anda harus manual menulis file .knowledge — sistem ini tidak akan bertahan. Manusia malas. Manusia lupa. Manusia sibuk.

Autonomous Consolidation (Level 5) adalah level di mana Second Brain Anda memperbarui dirinya sendiri. Sistem mendeteksi sesi AI, mengekstrak pengetahuan baru (keputusan arsitektur, pola kode, konvensi), dan memperbarui knowledge base secara otomatis. Tanpa campur tangan manusia.

6.2 Arsitektur Level 5

6.3 Session Capture Hook

Hook paling sederhana adalah post-session script yang dijalankan setiap kali sesi Claude Code berakhir:

# .claude/hooks/post-session.sh
#!/bin/bash
# Otomatis dijalankan setelah sesi Claude Code

LOG_FILE=".claude/sessions/$(date +%Y-%m-%d-%H%M%S).log"
mkdir -p "$(dirname "$LOG_FILE")"

# Capture semua pesan sesi ke file log
cat > "$LOG_FILE"

# Ekstrak Architecture Decision Records (ADR)
if grep -q "ADR:" "$LOG_FILE"; then
    ADR_FILE=".knowledge/adr/$(date +%Y%m%d-%H%M)-auto.md"
    grep -A 10 "ADR:" "$LOG_FILE" > "$ADR_FILE"
    echo "[hook] ADR extracted: $ADR_FILE"
fi

# Ekstrak coding patterns baru
if grep -q "PATTERN:" "$LOG_FILE"; then
    PATTERN_FILE=".knowledge/patterns/$(date +%Y%m%d-%H%M)-auto.md"
    grep -A 15 "PATTERN:" "$LOG_FILE" > "$PATTERN_FILE"
    echo "[hook] Pattern extracted: $PATTERN_FILE"
fi

# Ekstrak konvensi baru
if grep -q "CONVENTION:" "$LOG_FILE"; then
    CONV_FILE=".knowledge/conventions/$(date +%Y%m%d-%H%M)-auto.md"
    grep -B 2 -A 15 "CONVENTION:" "$LOG_FILE" > "$CONV_FILE"
    echo "[hook] Convention extracted: $CONV_FILE"
fi

# Update index MOC
python .claude/hooks/update_moc.py

# Commit perubahan
git add .knowledge/ .claude/sessions/
git commit -m "[auto] knowledge update $(date +%Y-%m-%d)" || true

6.4 Auto-lint dan Validasi

Skrip auto-lint memastikan knowledge base tetap rapi:

# .claude/hooks/auto_lint.py
import os, re, sys

ROOT = ".knowledge"
ISSUES = []

def check_broken_links(filepath):
    """Cek apakah semua [[wiki links]] mengarah ke file yang ada"""
    with open(filepath) as f:
        content = f.read()
    links = re.findall(r'\[\[([^\]]+)\]\]', content)
    for link in links:
        target = link if link.endswith(".md") else link + ".md"
        if not os.path.exists(os.path.join(ROOT, target)):
            ISSUES.append(f"Broken link: {filepath} → [[{target}]]")

def check_orphan_files():
    """Cari file yang tidak punya incoming links"""
    all_links = set()
    all_files = set()
    for root, dirs, files in os.walk(ROOT):
        for f in files:
            if f.endswith(".md"):
                path = os.path.relpath(os.path.join(root, f), ROOT)
                all_files.add(path)
                with open(os.path.join(root, f)) as fh:
                    links = re.findall(r'\[\[([^\]]+)\]\]', fh.read())
                for link in links:
                    target = link if link.endswith(".md") else link + ".md"
                    all_links.add(target)
    orphans = all_files - all_links
    for o in sorted(orphans):
        if not o.startswith("_"):
            ISSUES.append(f"Orphan file (no incoming links): {o}")

def check_tag_consistency():
    """Cek apakah semua file punya minimal 1 tag"""
    for root, dirs, files in os.walk(ROOT):
        for f in files:
            if f.endswith(".md") and f != "_index.md":
                path = os.path.join(root, f)
                with open(path) as fh:
                    first_line = fh.readline()
                if not first_line.startswith("#tag:"):
                    rel = os.path.relpath(path, ROOT)
                    ISSUES.append(f"Missing tags: {rel}")

def check_duplicates():
    """Deteksi konten duplikat"""
    content_map = {}
    for root, dirs, files in os.walk(ROOT):
        for f in files:
            if f.endswith(".md"):
                path = os.path.join(root, f)
                with open(path) as fh:
                    content = fh.read(500)  # first 500 chars
                if content in content_map:
                    ISSUES.append(f"Duplicate content: {content_map[content]} ≈ {path}")
                else:
                    content_map[content] = path

if __name__ == "__main__":
    for root, dirs, files in os.walk(ROOT):
        for f in files:
            if f.endswith(".md"):
                check_broken_links(os.path.join(root, f))
    check_orphan_files()
    check_tag_consistency()
    check_duplicates()

    if ISSUES:
        print(f"Found {len(ISSUES)} issues:", file=sys.stderr)
        for issue in ISSUES:
            print(f"  - {issue}", file=sys.stderr)
        sys.exit(1)
    else:
        print("Knowledge base lint passed!")

6.5 Auto-Update MOC

# update_moc.py — Otomatis update _index.md
import os, re
ROOT = ".knowledge"

sections = {}
for root, dirs, files in os.walk(ROOT):
    for f in files:
        if f.endswith(".md") and not f.startswith("_"):
            path = os.path.relpath(os.path.join(root, f), ROOT)
            section = os.path.dirname(path) or "general"
            with open(os.path.join(root, f)) as fh:
                first_line = fh.readline()
            title = re.sub(r'^#\s*', '', first_line).strip()
            sections.setdefault(section, []).append((path, title))

with open(os.path.join(ROOT, "_index.md"), "w") as f:
    f.write("# Knowledge Base Index\n")
    f.write("# Auto-generated — do not edit manually\n\n")
    for section in sorted(sections):
        f.write(f"## {section.title()}\n")
        for path, title in sorted(sections[section]):
            f.write(f"- [{title}]({path})\n")
        f.write("\n")
print("MOC updated: .knowledge/_index.md")

6.6 Biaya dan ROI Level 5

6.7 Kelemahan Level 5

7.1 Mengapa Obsidian?

Obsidian adalah aplikasi note-taking berbasis Markdown yang telah menjadi de facto standard untuk Second Brain manusia. Keunggulannya untuk integrasi AI:

• Local-first — semua file .md lokal, bisa dibaca Claude Code
• Wiki links — format [[double bracket]] native, langsung kompatibel dengan Level 4
• Graph view — visualisasi pengetahuan yang bisa dibaca manusia
• Plugins — ekosistem plugin yang memungkinkan kustomisasi
• Git-friendly — vault Obsidian adalah folder biasa, bisa di-version control

7.2 Struktur Compound Vault

Compound vault adalah vault yang berisi dua lapis pengetahuan: satu untuk manusia, satu untuk AI:

obsidian-vault/
├── .obsidian/              # Konfigurasi Obsidian (jangan disentuh AI)
├── inbox/                  # Tangkapan cepat (fleeting notes)
│   └── 2026-06-22-idea.md
├── projects/              # Catatan project (manusia + AI)
│   ├── _index.md
│   └── project-x/
│       ├── architecture.md
│       └── decisions.md
├── reference/             # Referensi teknis (dibaca AI)
│   ├── _index.md
│   ├── api-docs/
│   └── patterns/
├── daily/                 # Daily notes (hanya manusia)
│   └── 2026-06-22.md
├── meta/                  # Metadata untuk AI (tags, MOC)
│   ├── moc-auth.md
│   └── moc-frontend.md
└── CLAUDE.md               # Symlink atau copy ke project

7.3 Integrasi Obsidian ↔ Claude Code

Cara menghubungkan vault Obsidian dengan Claude Code:

# Opsi 1: Symlink — vault terpisah, referensi di project
$ ln -s ~/obsidian-vault/reference project/.knowledge
$ ln -s ~/obsidian-vault/CLAUDE.md project/CLAUDE.md

# Opsi 2: Vault sebagai git submodule
$ git submodule add ~/obsidian-vault .knowledge
$ git commit -m "add obsidian vault as knowledge base"

# Opsi 3: Direct — vault = project
# (Jika project Anda kecil, jadikan vault sebagai root)
$ cd ~/obsidian-vault
$ code .  # atau claude .

7.4 Plugin untuk Integrasi

Beberapa plugin Obsidian yang berguna untuk ekosistem AI:

7.5 Contoh Sesi AI dengan Vault

Skenario: Developer ingin Claude Code mengakses keputusan arsitektur yang ditulis di Obsidian.

# Developer:
"Berdasarkan ADR yang kita tulis di vault, bagaimana cara implementasi event sourcing?"

# Claude Code (dengan instruksi L4 + vault):

# 1. Cari di .knowledge/reference/adr/
rg "event sourcing" .knowledge/reference/adr/ -C 5

# 2. Dapatkan ADR dengan wiki links
cat .knowledge/reference/adr/005-event-sourcing.md

# 3. Traverse link ke dokumen terkait
python wikilink_graph.py "reference/adr/005-event-sourcing.md"

# 4. Baca patterns yang direferensikan
cat .knowledge/reference/patterns/cqrs.md

7.6 Best Practices

• Pisahkan manusia dan AI — folder daily/ dan inbox/ untuk manusia, reference/ dan meta/ untuk AI
• Gunakan frontmatter YAML — ---\ntags: [ai, architecture]\n--- untuk metadata terstruktur
• CLAUDE.md di vault root — instruksi global untuk semua project
• Auto-commit vault — pastikan Claude Code selalu punya versi terbaru
• Jangan edit file AI dari Obsidian — file auto-generated bisa overwrite

8.1 Apa Itu Harness Flow?

Harness Flow adalah siklus kerja terstruktur yang mengatur bagaimana AI coding agent bekerja: mulai dari planning (memahami konteks), working (menulis kode dengan guidance), reviewing (memvalidasi output), hingga releasing (mengintegrasikan hasil). Ini adalah operating system untuk sesi AI Anda — memastikan setiap interaksi produktif, konsisten, dan terukur.

8.2 Siklus Plan → Work → Review → Release

8.3 Tahap 1: Plan

Setiap sesi dimulai dengan fase perencanaan. AI harus membaca konteks sebelum menulis kode:

## [HARNESS] Plan Phase — Wajib sebelum write
# 1. Baca CLAUDE.md untuk konvensi project
# 2. Baca .knowledge/_index.md untuk navigasi
# 3. Cari dokumen relevan dengan rg atau BM25
# 4. Eksplorasi struktur file terkait
# 5. Rencanakan solusi dalam 3-5 langkah
# 6. Presentasikan rencana ke user untuk approval

8.4 Tahap 2: Work

Fase eksekusi dengan guardrails yang ketat:

## [HARNESS] Work Phase — Guardrails
# - Ikuti coding conventions dari CLAUDE.md
# - Gunakan pattern yang sudah terdokumentasi
# - Tambahkan komentar untuk logika kompleks
# - Jangan ubah file yang tidak relevan
# - Tandai ADR baru dengan prefix "ADR:"
# - Tandai pattern baru dengan prefix "PATTERN:"

8.5 Tahap 3: Review

Validasi otomatis sebelum kode dianggap selesai:

## [HARNESS] Review Phase — Auto-validation
# Wajib dijalankan setelah work phase:
# 1. Lint: npx eslint . (atau setara)
# 2. Type check: npx tsc --noEmit
# 3. Test: npm test (unit yang relevan)
# 4. Knowledge lint: python .claude/hooks/auto_lint.py
# 5. Jika ada error, perbaiki sebelum lanjut

8.6 Tahap 4: Release

Finalisasi sesi dengan capture knowledge:

## [HARNESS] Release Phase — Knowledge Capture
# Setelah semua kode OK:
# 1. Commit dengan pesan deskriptif
# 2. Jika ada ADR baru → extract ke .knowledge/adr/
# 3. Jika ada pattern baru → extract ke .knowledge/patterns/
# 4. Update MOC jika diperlukan
# 5. Push ke remote

8.7 Contoh Harness dalam Aksi

Prompt pengguna: "Tambah fitur reset password"

# === PLAN ===
# Baca konteks:
$ cat CLAUDE.md | head -30
$ rg "auth" .knowledge/auth/ -C 3
$ rg "password" .knowledge/auth/ -C 3
$ ls -la src/auth/

# Output rencana:
"Plan: Membuat reset password flow:
1. Buat route POST /api/auth/reset-password
2. Buat service method di AuthService
3. Kirim email via NotificationService
4. Validasi token dengan JWT
Setuju? (y/n)"

# === WORK ===
# Menulis kode sesuai rencana + konvensi
# Tandai ADR: "ADR: Password reset menggunakan JWT with 15min expiry"

# === REVIEW ===
$ npx eslint src/auth/
$ npx tsc --noEmit
$ npm test -- --testPathPattern=reset-password

# === RELEASE ===
$ git add -A
$ git commit -m "feat: add reset password flow"

8.8 Guardrails dan Boundaries

Guardrails adalah batasan yang mencegah AI melakukan hal-hal yang tidak diinginkan:

9.1 Ekosistem Repositori Second Brain

Komunitas open source telah menghasilkan beberapa repositori luar biasa yang menerapkan konsep yang kita bahas. Bab ini membahas tiga ekosistem utama yang membentuk GitHub Ponytail Ecosystem — dinamai dari kreator utamanya yang menggunakan nama "ponytail" sebagai penanda.

9.2 coleam00 / second-brain-skills

Repositori coleam00/second-brain-skills adalah salah satu implementasi Second Brain paling komprehensif untuk Claude Code. Fitur utama:

• Skill-based architecture — setiap pengetahuan adalah "skill" yang bisa di-load on-demand
• MCP integration — Model Context Protocol untuk komunikasi terstruktur
• Multi-agent support — skills bisa digunakan oleh berbagai agent AI
• Versioned skills — setiap skill punya changelog sendiri

# Struktur repositori coleam00/second-brain-skills
second-brain-skills/
├── skills/
│   ├── typescript/
│   │   ├── conventions.md
│   │   ├── patterns.md
│   │   └── index.json
│   ├── react/
│   │   ├── component-patterns.md
│   │   ├── state-management.md
│   │   └── hooks.md
│   └── database/
│       ├── prisma.md
│       ├── postgresql.md
│       └── migrations.md
├── mcp/
│   ├── skill-server.ts      # MCP server untuk load skills
│   └── skill-client.ts      # Client untuk query skills
├── CLAUDE.md                # Global instructions
└── README.md

9.3 Ars Contexta

Ars Contexta (Latin: "seni mengkontekskan") adalah framework untuk manajemen konteks AI. Ia menyediakan sistem yang memungkinkan agen AI mengelola konteks secara dinamis:

• Context layering — konteks global → project → task → session
• Context compression — ringkas konteks lama tanpa kehilangan informasi esensial
• Context priority — konteks paling relevan di-load pertama
• Context expiry — konteks basi otomatis dibuang

# Contoh Ars Contexta — konteks berlapis
ars-contexta/
├── layers/
│   ├── 00-global/           # Berlaku untuk semua project
│   │   └── preferences.md
│   ├── 01-project/          # Spesifik per project
│   │   ├── CLAUDE.md
│   │   └── stack.md
│   ├── 02-domain/           # Spesifik per domain
│   │   ├── auth-context.md
│   │   └── billing-context.md
│   └── 03-task/             # Spesifik per task
│       └── current-task.md
├── compress/
│   └── compressor.py        # Ringkas konteks lama
├── priority/
│   └── scorer.py            # Skor prioritas konteks
└── CLAUDE.md

9.4 Obsidian Second Brain

Repositori obsidian-second-brain adalah template vault Obsidian yang sudah dikonfigurasi untuk Second Brain. Cocok digunakan bersama Claude Code dengan struktur compound vault:

• Pre-built MOC — Maps of Content untuk berbagai topik teknis
• ADR templates — Template Architecture Decision Records
• Daily note automation — Daily notes dengan auto-tagging
• Git integration — Auto-commit + sync dengan Claude Code
• Graph presets — Filter graph view untuk AI-accessible notes

9.5 Perbandingan Ketiga Ekosistem

9.6 Cara Memilih dan Menggunakan

Rekomendasi berdasarkan kebutuhan:

• Single developer, ingin cepat → obsidian-second-brain + Level 1-2
• Tim kecil, butuh standarisasi → second-brain-skills + MCP
• Tim besar, konteks kompleks → Ars Contexta + Level 4-5
• Semua ekosistem → Kombinasikan: vault dari obsidian-second-brain, skills dari coleam00, konteks dari Ars Contexta

9.7 Instalasi Cepat Ekosistem

# 1. Clone Second Brain Skills
$ git clone https://github.com/coleam00/second-brain-skills.git
$ cd second-brain-skills
$ npm install
$ npx tsx mcp/skill-server.ts &

# 2. Setup Ars Contexta
$ git clone https://github.com/ars-contexta/ars-contexta.git
$ cd ars-contexta
$ python setup.py install

# 3. Setup Obsidian vault
$ git clone https://github.com/obsidian-second-brain/template.git
$ ln -s $(pwd)/template/.knowledge /project/.knowledge

# 4. CLAUDE.md global
$ cp template/CLAUDE.md /project/CLAUDE.md

3.7 MOC Nesting dan Hierarchy

Untuk knowledge base yang besar, MOC bisa di-nesting. MOC utama di root, MOC sub-topik di setiap folder:

.knowledge/
├── _index.md                # MOC Level 0: semua topik
├── auth/
│   ├── _moc.md              # MOC Level 1: sub-topik auth
│   ├── login-flow.md
│   ├── oauth.md
│   └── rbac.md
├── database/
│   ├── _moc.md              # MOC Level 1: sub-topik database
│   ├── prisma-schema.md
│   ├── migrations.md
│   └── query-optimization.md
└── frontend/
    ├── _moc.md
    ├── component-architecture.md
    ├── state-management.md
    └── testing.md

Isi _index.md (MOC Level 0):

# Knowledge Base Index
#tag:index #tag:moc

## Auth
MOC: auth/_moc.md — login, OAuth, RBAC, sessions

## Database
MOC: database/_moc.md — Prisma, migrations, optimization

## Frontend
MOC: frontend/_moc.md — components, state, testing

3.8 MOC Generator Otomatis

Skrip untuk generate MOC dari struktur folder:

# generate_moc.py — Auto-generate MOC dari folder
import os, re

ROOT = ".knowledge"

def generate_moc_for(folder):
    """Generate _moc.md untuk folder tertentu"""
    files = []
    for f in sorted(os.listdir(folder)):
        if f.endswith(".md") and not f.startswith("_"):
            path = os.path.join(folder, f)
            with open(path) as fh:
                first = fh.readline().strip()
            title = re.sub(r'^#\s*', '', first)
            files.append((f, title))

    if not files:
        return

    folder_name = os.path.basename(folder)
    moc_path = os.path.join(folder, "_moc.md")
    with open(moc_path, "w") as f:
        f.write(f"# MOC: {folder_name.title()}\n")
        f.write("# Auto-generated — do not edit manually\n\n")
        for filename, title in files:
            f.write(f"- [{title}]({filename})\n")
    print(f"MOC generated: {moc_path}")

# Generate untuk semua subfolder
for item in os.listdir(ROOT):
    folder = os.path.join(ROOT, item)
    if os.path.isdir(folder):
        generate_moc_for(folder)

# Generate main index
generate_moc_for(ROOT)

4.12 Perbandingan BM25 vs Embedding

Banyak yang bertanya: mengapa BM25 dan bukan embedding vektor (seperti OpenAI embeddings atau sentence-transformers)? Berikut perbandingan objektif:

Kapan pakai BM25: Knowledge base <10K dokumen, budget $0, butuh cepat dan predictable.

Kapan pakai Embedding: >10K dokumen, perlu sinonim dan semantic understanding tingkat lanjut, budget tersedia.

Untuk Level 3, BM25 sudah lebih dari cukup. Jika perlu embedding, itu masuk ke Level 3+ (upgrade).

7.7 Obsidian Templates untuk AI

Template yang dioptimalkan untuk dibaca AI:

ADR template:

---
tags: [adr, ai-readable]
date: {{date}}
status: proposed
---
# ADR: {{title}}
#tag:adr

## Context
Mengapa keputusan ini perlu diambil?

## Decision
Keputusan yang diambil.

## Consequences
Apa dampak dari keputusan ini?

## Related
- [[related-decision-1]]
- [[related-pattern]]

Daily note dengan auto-tagging — penting untuk AI agar bisa menyaring daily notes yang relevan:

# {{date}}
#tag:daily

## Technical Notes
_Knowledge yang perlu di-capture ke vault_

## Decisions
- **ADR:** _keputusan singkat_

## Follow-up
- [ ] _Tambahkan ke knowledge base_

7.8 Compound Vault Workflow

Workflow harian dengan compound vault:

1. Pagi: Buka Obsidian, baca daily note → lihat rencana hari ini
2. Coding: Claude Code membaca .knowledge/reference/ untuk konteks
3. Capture: Selama coding, tandai ADR/PATTERN di komentar kode
4. Sore: Claude Code hook otomatis extract ADR ke vault
5. Review: Buka Obsidian, review ADR auto-generated, tambahkan konteks manusia
6. Update: Obsidian Git auto-commit vault → knowledge terbaru untuk besok

8.10 Harness Metrics dan Monitoring

Untuk mengukur efektivitas harness flow, lacak metrik berikut:

8.11 Error Recovery dalam Harness

Ketika review phase menemukan error, harness harus memiliki protokol recovery:

## [HARNESS] Error Recovery Protocol
# Ketika review phase gagal:
# 1. Catat error yang ditemukan
# 2. Kembali ke work phase
# 3. Perbaiki error SATU PER SATU
# 4. Review ulang
# 5. Jika gagal 3x → tanya user

MAX_RETRIES=3
retry=0
while [ $retry -lt $MAX_RETRIES ]; do
    if run_review; then
        break
    fi
    retry=$((retry + 1))
    echo "Review failed (attempt $retry/$MAX_RETRIES)"
    fix_errors
done

9.10 Komunitas dan Kontribusi

Ekosistem Ponytail berkembang karena komunitas. Cara berkontribusi:

• coleam00/second-brain-skills — Tambahkan skill baru untuk stack Anda
• Ars Contexta — Kontribusi context compressor untuk bahasa baru
• obsidian-second-brain — Template vault untuk domain spesifik
• Dokumentasi — Tutorial, studi kasus, best practices

9.11 Future Directions: MCP dan Tools 2025+

Ekosistem Second Brain untuk AI berkembang cepat. Tren yang perlu diikuti:

• MCP (Model Context Protocol) — Standarisasi komunikasi AI-knowledge base
• Tools 2025 — Anthropic tools ecosystem untuk knowledge retrieval native
• Agent-to-agent communication — Second Brain yang dishare antar agent
• Real-time sync — Kolaborasi manusia-AI real-time di vault yang sama
• Multimodal knowledge — Gambar, diagram, suara sebagai first-class citizens

10.1 Decision Tree

Setelah membaca sembilan bab, Anda mungkin bertanya: Level berapa yang harus saya gunakan? Jawabannya tergantung pada konteks Anda. Berikut decision tree yang akan membantu:

10.2 Tabel Rekomendasi Cepat

10.3 Matriks Cost vs Benefit

10.4 Rekomendasi Akhir

1. Mulai dari L1 — butuh 5 menit. Tidak ada alasan untuk tidak memulainya.
2. Upgrade ke L2 ketika .knowledge/ Anda memiliki >10 file dan Anda mulai bingung navigasi.
3. Upgrade ke L3 ketika grep mulai mengembalikan terlalu banyak hasil noise.
4. Upgrade ke L4 ketika Anda punya >50 file dan sering cross-reference.
5. Upgrade ke L5 ketika Anda lelah meng-update knowledge base manual.
6. Integrasi Obsidian kapan pun — vault untuk manusia dan AI adalah investasi jangka panjang.
7. Ekosistem Ponytail ketika tim Anda >5 orang dan butuh standarisasi.

Golden rule: Setiap level adalah investasi. Investasikan level berikutnya hanya ketika level saat ini sudah terasa sakit. Jangan over-engineer Second Brain Anda.

Kita telah menempuh perjalanan panjang: dari CLAUDE.md yang sederhana hingga autonomous consolidation yang kompleks. Dari grep hingga knowledge graph. Dari file markdown hingga ekosistem GitHub Ponytail.

Inti dari semua ini sederhana: AI tidak perlu menjadi pelupa. Dengan investasi waktu yang minimal — 5 menit untuk Level 1 — Anda bisa mengubah agen AI dari asisten yang amnesia menjadi mitra yang mengingat setiap keputusan, setiap preferensi, setiap pola yang pernah Anda ajarkan.

Yang paling menarik: semua ini gratis. Tidak ada SaaS yang perlu dibayar. Tidak ada API key. Hanya file teks, grep, Python, dan git. Ini adalah demokratisasi memori AI.

Beberapa prinsip yang semoga membekas:

1. Mulai kecil — L1 cukup untuk 80% kebutuhan
2. Konsistensi > kompleksitas — MOC yang dirawat lebih baik dari graph yang terbengkalai
3. Ukur ROI — jika Level 3 menghemat $1.000/bulan, investasi 2 jam setup adalah no-brainer
4. Manusia + AI — Second Brain terbaik adalah yang melayani manusia dan AI secara simultan
5. Berkembang bertahap — setiap level dibangun di atas level sebelumnya

Selamat membangun Second Brain. Semoga AI Anda tidak pernah lupa lagi.

— Sainskerta, 2026

# mcp-knowledge-server.ts — MCP server untuk knowledge base
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { execSync } from "child_process";
import { readFileSync, existsSync } from "fs";
import { join } from "path";

const KNOWLEDGE_DIR = process.env.KNOWLEDGE_DIR || ".knowledge";

const server = new Server(
  { name: "knowledge-server", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "search_knowledge",
    description: "Search knowledge base dengan semantic search",
    inputSchema: {
      type: "object",
      properties: {
        query: { type: "string" },
        top_k: { type: "number", default: 5 },
      },
    },
  }],
}));

server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "search_knowledge") {
    const { query, top_k = 5 } = request.params.arguments;
    const result = execSync(
      `python bm25_search.py "${query}" --top ${top_k} --path ${KNOWLEDGE_DIR}`,
      { encoding: "utf-8" }
    );
    return { content: [{ type: "text", text: result }] };
  }
  throw new Error("Tool not found");
});

const transport = new StdioServerTransport();
await server.connect(transport);

#!/bin/bash
# claude-harness.sh — Harness Flow untuk Claude Code
set -e

MODE=${1:-"plan"}  # plan | work | review | release
PROJECT_ROOT=$(pwd)

case $MODE in
  plan)
    echo "=== PLAN PHASE ==="
    cat CLAUDE.md 2>/dev/null || echo "No CLAUDE.md found"
    rg -r "TODO|FIXME" --type md .knowledge/ 2>/dev/null || true
    ;;
  work)
    echo "=== WORK PHASE ==="
    echo "Writing code with guardrails active"
    ;;
  review)
    echo "=== REVIEW PHASE ==="
    if [ -f package.json ]; then
      npx eslint . --quiet || true
      npx tsc --noEmit 2>/dev/null || true
    fi
    python .claude/hooks/auto_lint.py 2>/dev/null || true
    ;;
  release)
    echo "=== RELEASE PHASE ==="
    bash .claude/hooks/post-session.sh 2>/dev/null || true
    git add -A
    git diff --cached --quiet || git commit -m "feat: auto-commit [harness]"
    ;;
esac