You can’t manage an engineer you can’t predict. Without enforceable conventions, Claude reverts to its training distribution, an average of every codebase on the internet, bad code and all. GAIA’s codebase is what you actually want Claude matching. With GAIA, Claude writes code that follows best practices on day one, and can’t ship code that doesn’t.

How GAIA makes Claude trustworthy

• •Coding principles. GAIA’s coding rules embed Karpathy’s four coding principles (Think Before Coding, Simplicity First, Surgical Changes, Goal-Driven Execution), plus two of GAIA’s own: Always Use TDD and Always Verify Your Work.
• •Best practices baked in. Rules encode the conventions directly instead of hoping Claude infers them from whatever’s already in the repo.
• •Guardrails against technical debt. Rules block debt-accumulating patterns from being written in the first place: untyped exports, untested components, hardcoded strings, a11y gaps.
• •Consistently clean code. 20+ ESLint plugins, strict TypeScript, and Prettier enforce style and correctness on every file Claude touches. No negotiation, no drift.
• •Test-driven development. The bundled tdd skill runs a red-green-refactor loop with tests before code, tailored for Vitest, React Testing Library, Storybook composeStory, and MSW.
• •Code-review audit before every merge. A Claude subagent scans the branch diff for security, performance, code smells, and antipatterns, then blocks the merge until the issues are fixed and committed.
• •Quality gate before commit. Typecheck, lint, tests, and build must all pass. Not "mostly clean", actually clean.

Context bloat isn’t just CLAUDE.md sprawl. Instructions get dropped into global memory, forgotten, and accumulate into redundancies and conflicts, an invisible cost that compounds every session. GAIA keeps token usage minimal by design.

How GAIA keeps Claude token-efficient

• •Rules are scoped to activate only when needed. Claude loads the ones that match what it’s editing, nothing else.
• •Obsidian wiki, fetched on demand. Project knowledge lives as focused, linked Markdown pages. Claude opens the one page it needs ("How does dark mode wire through?") instead of preloading the whole manual.
• •Wiki behavior tailored to GAIA. Session hooks keep Obsidian’s workflow (ingest cadence, cache discipline, link hygiene) aligned with the project’s conventions.
• •Periodic knowledge audit. Sweeps memory, wiki, and autoloaded files for duplication, conflicts, and stale instructions before they start costing tokens.
• •Session continuity. /handoff and /pickup replace re-briefing Claude from scratch at every session start.

With an Obsidian wiki, Claude understands what you are actually building, not just the code in front of it. Product features, user flows, design rationale, business decisions, architecture, and dependencies all live as focused markdown pages committed to git, not chat history, not machine-local memory.

GAIA ships with the claude-obsidian integration wired up. The vault structure, the ingestion commands, and the maintenance skills are configured before you write your first page.

On top of the integration, GAIA layers project-specific commands and hooks that turn the wiki into a self-maintaining knowledge base. Duplicates, conflicts, and stale information get pruned, so the vault stays clean as the project grows.

Token costs do not balloon as the wiki gets richer. Claude only reads the specific information a task needs, so a project with 1,000 pages of context is no more expensive to work in than one with 10.

Why Obsidian? A local markdown vault means the project’s knowledge persists, compounds, and stays yours, not held in a vendor’s database or trapped in chat history.

Domain isolation is mandatory. Technical, branding, and business knowledge are kept siloed, and Claude does not cross-load between them unless a task genuinely spans more than one.

A Karpathy-style CLAUDE.md is wiki-first, don’t-preload, lazy-fetch. It tells Claude where to look, not to load everything upfront. See Karpathy’s original for the philosophy.

GAIA ships with coding rules that only load when Claude is writing code. The first four come from Karpathy’s CLAUDE.md:

• •Think Before Coding - Surface assumptions, push back on complexity, ask when unclear.
• •Simplicity First - Write the minimum code that solves the problem, no speculative abstractions.
• •Surgical Changes - Touch only what is needed; match existing style; leave unbroken things alone.
• •Goal-Driven Execution - Define verifiable success criteria before starting; loop until verified.

GAIA adds two more principles on top of these:

• •Always Use TDD - Vitest for units, Playwright for user flows, tests before code.
• •Always Verify Your Work - Run the quality gate process; fix all warnings and errors before reporting done.

GAIA’s variant also adds three wiki habits on top of Karpathy’s framing. Domain isolation means technical work fetches only from wiki/app/, brand work from its own domain. wiki/hot.md auto-load is a 200-word recent-context cache loaded at every session start to surface work-in-progress. Memory discipline keeps machine-local memory for personal preferences only. Durable knowledge lives in the wiki or .claude/rules/.

Three concrete benefits

• •Tokens saved. Lazy-fetch only the pages Claude needs. Adding 20 more wiki pages does not bloat every session, since they are not loaded unless asked.
• •Context stays focused. Domain isolation prevents unrelated information from leaking into the context window. Technical questions get technical answers only.
• •The pattern scales. Whether you are building a 2-person startup or a 100-person team, the wiki-first discipline keeps sessions lean and predictable.