Calugaru OSField manualsBuilding With Agents

Learn the tools. Own the system.

Five zero-to-operator field manuals for building software, durable knowledge, and trustworthy AI systems.

These are not feature tours. Each guide starts without assumed technical vocabulary, gets progressively more technical, and ends with a capstone you can operate, debug, and prove.

Start with Claude CodeBrowse every guide

The complete path

  1. 01Claude Code10 chapters
  2. 02Codex10 chapters
  3. 03LLM Wiki8 chapters
  4. 04G Brain8 chapters
  5. 05Replit10 chapters

5 complete learning tracks

The guide library

Read a track front to back or use the chapter search to solve the problem in front of you. The order is deliberate: operate coding agents first, build an inspectable knowledge base next, then add reasoning and production discipline.

Manual 0110Chapters

Foundation → Builder → Operator

Claude Code: From First Session to Reliable Engineering

A plain-language, hands-on path from opening a project to operating safe, verifiable agentic workflows.

Learn how Claude Code sees a project, how to give it useful context and bounded authority, how to review and verify changes, and how to scale from one supervised task to repeatable team workflows.

You finish able to:By the end, you can supervise Claude Code as an engineering system: orient it, specify work, constrain access, isolate changes, demand proof, extend it responsibly, and automate only what has earned trust.

Open the manual
Manual 0210Chapters

Foundation → Builder → Operator

Codex: From Request to Verifiable Result

A plain-language operating guide for turning domain expertise into safe, reviewable, evidence-backed work across Codex surfaces.

Learn how Codex works across the app, CLI, IDE, and cloud; how to establish repository truth; how to bound authority; how to coordinate agents and extensions; and how to carry one request all the way to an independently verifiable receipt.

You finish able to:By the end, you can operate Codex as a trustworthy work system: choose the right surface, specify an outcome, teach the project, constrain access, isolate changes, demand proof, extend responsibly, and automate only after the workflow earns it.

Open the manual
Manual 038Chapters

Foundation → Builder → Operator

Build Your Own LLM Wiki

Turn scattered chats and documents into an inspectable knowledge system that compounds.

A source-first field guide to durable Markdown, explicit schemas, safe ingestion, cited retrieval, knowledge graphs, maintenance, and multi-agent access. You begin with folders and files, then progressively build the machinery that makes the wiki useful and trustworthy.

You finish able to:You will build a local-first wiki that preserves originals, turns sources into linked knowledge, answers questions with citations and honest gaps, survives agent mistakes, and leaves a receipt for every important change.

Open the manual
Manual 048Chapters

Foundation → Builder → Operator

Build a GBrain-Style Knowledge Engine

Build a personal answer system that returns proof, names what it does not know, and improves without rewriting your beliefs in secret.

A practical guide inspired by Garry Tan's GBrain product ideas and the answer-plus-proof-plus-gaps pattern. You will model a personal knowledge graph, attach claims to sources, build hybrid retrieval, add safe consolidation, enforce user boundaries, and evaluate whether the system deserves trust.

You finish able to:You will leave with an answer engine that can retrieve across files and a graph, cite its evidence, expose freshness and uncertainty, consolidate carefully, enforce access, and produce receipts that make every important conclusion auditable.

Open the manual
Manual 0510Chapters

Foundation → Builder → Operator

Build and Operate with Replit

From a plain-language idea to a real, recoverable production app.

A zero-to-operator field guide for nontechnical builders. Learn how Replit projects, Agent, Plan Mode, background Tasks, Canvas, code, databases, identity, replit.md, Skills, MCP, testing, Automations, publishing, monitoring, and cost fit together—and finish with evidence that the system works.

You finish able to:You will leave able to scope, build, inspect, secure, test, publish, and operate a useful Replit application without treating either Agent output or a polished Preview as proof by itself.

Open the manual

LLM Wiki

The inspectable memory layer

Preserve sources, maintain readable knowledge, connect pages, and retrieve evidence without trapping truth inside a model or vendor.

G Brain

The answer-and-reasoning layer

Add typed relationships, hybrid retrieval, proof, freshness, gaps, and careful consolidation above durable sources. Build the wiki foundation first.

01

Understand

Plain-language mental models before commands, configuration, or architecture.

02

Practice

A bounded lab in every chapter that produces something real and inspectable.

03

Recover

Failure modes teach you how to diagnose the system when the happy path breaks.

04

Prove

Artifacts and receipt checks make completion visible to you and another person.

Search across the curriculum

Find the lesson you need.

Learning stage

46 of 46 chapters

  1. Claude Code01Know What You Are OperatingInstall Claude Code, choose the right surface, and complete a first supervised loop without confusing the assistant, the repository, or the running application.Foundation14 min lesson + 45 min lab
  2. Claude Code02Orient to an Existing ProjectTurn an unfamiliar repository into a usable system map before allowing an agent to implement changes.Foundation16 min lesson + 45 min lab
  3. Claude Code03Turn Intent Into a Build SpecificationTranslate business judgment into a bounded task packet Claude Code can implement and verify without guessing at the important decisions.Foundation18 min lesson + 60 min lab
  4. Claude Code04Make Project Context DurableUse CLAUDE.md, rules, skills, and memory deliberately so each session begins with useful truth instead of an ever-growing instruction dump.Builder18 min lesson + 45 min lab
  5. Claude Code05Bound Permissions and the SandboxReplace approval fatigue with an explicit authority model that combines permission rules, execution modes, sandbox boundaries, and human judgment.Builder18 min lesson + 60 min lab
  6. Claude Code06Make Changes With Git and WorktreesUse Git history, branches, diffs, checkpoints, and worktrees to keep agent-generated changes inspectable, isolated, and recoverable.Builder18 min lesson + 60 min lab
  7. Claude Code07Debug and Verify the ResultUse Claude Code to reproduce failures, test hypotheses, and close the loop with evidence instead of accepting a plausible patch.Builder18 min lesson + 60 min lab
  8. Claude Code08Extend With MCP, Skills, and HooksChoose the right extension mechanism for external tools, reusable knowledge, and deterministic automation without turning every capability into permanent context or authority.Operator20 min lesson + project lab
  9. Claude Code09Delegate and Run Work in ParallelUse subagents, parallel sessions, agent teams, and worktree isolation only when task boundaries and integration ownership make concurrency safer and faster.Operator20 min lesson + project lab
  10. Claude Code10Operate in CI and Ship the CapstoneTurn one proven interactive workflow into bounded automation with machine-readable output, CI controls, operating receipts, and a clear path back to human review.Operator22 min lesson + capstone
  11. Codex01Start From Zero and Choose the Right SurfaceStart even if you do not have a project yet: learn the terminal, create or open a tiny Git project, choose the right Codex surface, recover from common setup failures, and finish one verified task.Foundation36 min lesson + lab
  12. Codex02Turn Intent Into Verifiable WorkTranslate domain expertise into a task contract, establish current repository truth, and give Codex a finish line it can prove rather than guess.Foundation42 min lesson + lab
  13. Codex03Configure Codex and Teach It the ProjectUnderstand Codex configuration precedence, deliberately choose one permission system, write durable repository guidance, and place each recurring behavior in the smallest control surface that matches its scope.Foundation44 min lesson + lab
  14. Codex04Bound Authority With Sandbox and ApprovalsGive Codex enough access to finish the work while protecting unrelated files, credentials, external systems, and irreversible actions.Foundation40 min lesson + lab
  15. Codex05Make the Change and Prove ItMove from a scoped plan to a narrow implementation, then prove the result with code checks and the real user flow instead of stopping at a confident summary.Builder48 min lesson + lab
  16. Codex06Work Across Environments and WorktreesKeep source, runtime, preview, production, local work, cloud work, branches, and parallel checkouts separate enough that every change lands where you intend.Builder46 min lesson + lab
  17. Codex07Delegate With SubagentsSplit a complex objective into independent lanes, give each agent a bounded contract, and integrate evidence without multiplying confusion.Builder43 min lesson + lab
  18. Codex08Build the Extension StackTurn repeated expertise into skills, distribute broader capabilities through plugins, connect live systems with MCP, and enforce deterministic boundaries with hooks.Operator52 min lesson + lab
  19. Codex09Automate, Embed, and Run Long Work SafelyTurn a trusted workflow into non-interactive, scheduled, SDK-driven, app-server, or long-running work with idempotence, checkpoints, bounded authority, and receipts for success and failure.Operator49 min lesson + lab
  20. Codex10Capstone: From Command to ReceiptUse the complete Codex operating system to turn one real business request into a scoped, safe, tested, reviewable, and independently verifiable result.Operator65 min lesson + capstone lab
  21. LLM Wiki01Knowledge That Outlives the ChatUnderstand what an LLM Wiki is, what it is not, and why readable files are the foundation of trustworthy AI memory.Foundation26 min lesson + lab
  22. LLM Wiki02Design a Vault Humans Can ReadCreate a file and schema system that stays understandable before any automation exists.Foundation32 min lesson + lab
  23. LLM Wiki03Capture Sources Without Losing ProofPreserve originals, context, permissions, and the line between quotation and inference.Foundation36 min lesson + lab
  24. LLM Wiki04Build the Ingestion PipelineTurn source material into proposed linked pages through a pipeline you can test one stage at a time.Builder45 min lesson + lab
  25. LLM Wiki05Retrieval That Can Show Its WorkRetrieve evidence first, synthesize second, and report uncertainty instead of hiding it.Builder49 min lesson + lab
  26. LLM Wiki06Link, Lint, and ConsolidateKeep the wiki coherent by treating links, duplicates, contradictions, and staleness as maintainable state.Builder44 min lesson + lab
  27. LLM Wiki07Connect Agents Without Surrendering ControlLet Claude, Codex, and other tools share the wiki through narrow interfaces, policy, and reviewable writes.Operator47 min lesson + lab
  28. LLM Wiki08Operate, Evaluate, and RecoverMake the wiki dependable with evaluations, quality metrics, backups, migrations, incident procedures, and visible trust.Operator53 min lesson + lab
  29. G Brain01From Chatbot to Answer EngineUnderstand the product shape: answer, proof, gaps, freshness, and a next verification step.Foundation27 min lesson + lab
  30. G Brain02Model the Personal Knowledge GraphRepresent people, projects, claims, sources, and time with relationships precise enough to reason over.Foundation36 min lesson + lab
  31. G Brain03Engineer Trust, Provenance, and UncertaintyTurn evidence quality, conflict, freshness, and missing knowledge into visible system state.Foundation38 min lesson + lab
  32. G Brain04Build a Self-Wiring Ingestion FlowCapture durable pages and turn explicit links into a typed graph while keeping model suggestions outside canonical truth until reviewed.Builder47 min lesson + lab
  33. G Brain05Retrieve, Traverse, and SynthesizeBuild the answer path that combines filters, lexical search, embeddings, graph expansion, and bounded synthesis.Builder51 min lesson + lab
  34. G Brain06Build the Dream and Consolidation CycleLet the system improve in the background while preserving evidence, approvals, and rollback.Builder48 min lesson + lab
  35. G Brain07Secure and Operate a Multi-User BrainEnforce isolation, least privilege, local-first options, observability, and recovery before inviting real users.Operator54 min lesson + lab
  36. G Brain08Evaluate Trust and Ship the ProductMeasure retrieval, graph value, citation support, gap honesty, freshness, security, and operator usability before calling the brain reliable.Operator58 min lesson + lab
  37. Replit01Map the Replit SystemKnow what Replit is changing, where your work lives, and why a working Preview is not yet a published product.Foundation18 min lesson + 60 min lab
  38. Replit02Build Your First Agent AppTurn one real decision into a small working app without asking Agent to invent the product for you.Foundation16 min lesson + 45 min lab
  39. Replit03Plan Before You BuildUse Plan Mode to turn a fuzzy idea into decisions, boundaries, risks, and a build sequence without changing code.Foundation22 min lesson + 90 min lab
  40. Replit04Read the Project EditorUnderstand files, commands, processes, logs, and previews well enough to inspect an app before asking Agent to fix it.Builder18 min lesson + 60 min lab
  41. Replit05Design on the CanvasUse Canvas to decide hierarchy, states, and responsive behavior before expensive implementation work hardens the wrong idea.Builder22 min lesson + 75 min lab
  42. Replit06Understand Web-App AnatomySee a web app as a set of contracts among interface, server, data, identity, integrations, and evidence.Builder18 min lesson + 75 min lab
  43. Replit07Model and Protect Real DataMove from temporary demo state to a managed database without losing track of ownership, migrations, or recovery.Builder20 min lesson + 90 min lab
  44. Replit08Add Identity, Secrets, and IntegrationsConnect real users and external services while keeping credentials out of code and authorization on the server.Operator24 min lesson + 120 min lab
  45. Replit09Test, Debug, and RecoverBuild a layered safety net with checkpoints, Git, GitHub, browser tests, and practiced rollback instead of hoping each prompt works.Operator34 min lesson + 120 min lab
  46. Replit10Publish and Operate the AppRelease a secure app on the right publishing model, connect its domain, watch its health and cost, and respond when reality changes.Operator26 min lesson + capstone
Home
Book
Blog
Calugaru Labs
GitHub
LinkedIn
Email
Theme