AI Knowledge Fleet

English | Tiếng Việt

A collection of AI / Agentic AI knowledge, shipped as a single static page (index.html) — no build step, no backend, runs on any static host (GitHub Pages, Netlify, python -m http.server...).

The repo bundles two independent content sets behind one shared reading UI:

1. Loop Engineering Coursebook — an applied coursebook on designing agentic loop systems (EN/VI/ZH).
2. AI Interview Handbook — senior-level AI technical interview questions (VI).

Table of contents

• Why this repo exists
• Quick start
• Contents
  • 1. Loop Engineering Coursebook
  • 2. AI Interview Handbook
• Architecture
• Directory structure
• Adding new content
• Core principles
• Deploying to GitHub Pages
• License

Why this repo exists

Most Agentic AI material out there is scattered prompt snippets or one-off blog posts. This repo packages two reusable, structured formats instead:

• A coursebook that goes from concept (chain vs. loop) to practice (circuit breakers, verification, memory & state, anti-patterns...) instead of just listing prompt tricks.
• A question bank written to a fixed format (senior-level answer → follow-up question → common pitfall) — useful for interview prep or as a candidate-evaluation rubric.

Both are free to read, collect no reader data, and require no sign-in.

Quick start

git clone https://github.com/KhaiTrang1995/ai-knowledge-fleet.git
cd ai-knowledge-fleet
python -m http.server 8000
# open http://localhost:8000

Must be served over a local/static server — opening index.html directly via file:// gets blocked by CORS when it fetches data/posts.json and individual content files.

Inside the app:

• Home tab — everything, with search and tag filters.
• Chapters tab — the 16 coursebook chapters.
• Interviews tab — interview questions (both the 3 originals from the coursebook and the 12 from the AI Interview Handbook).
• EN / VI / ZH buttons (top right) — switch display language.

Contents

1. Loop Engineering Coursebook (EN/VI/ZH)

A 16-chapter coursebook on shifting from "writing a single prompt" to "designing an autonomous, verifier-backed agentic loop system."

#	Chapter
0	Preface
1	The shift to loop engineering
2	The goal loop
3	The interval loop
4	Surfaces & the cost model
5	Verification
6	Loop bodies as skills
7	Parallelism & /batch
8	Hooks & the lifecycle
9	Memory & state
10	Self-improving loops
11	A catalogue of loops
12	Anti-patterns
13	Governance & safety
14	The frontier
App.	A field guide of prompts, skills & subagents

Plus 3 foundational interview questions (available in all 3 languages): Chain vs. Loop, Maker/Checker Separation, Circuit Breakers.

2. AI Interview Handbook (VI)

12 topics, each following the structure: question → senior-level answer → follow-up question → common pitfall. Currently written in Vietnamese only (see note below).

Core technical topics — apply across industries:

• RAG data flow: embedding, retrieve top-K, rerank
• What are guardrails? Which frameworks? Anti-hallucination?
• Enterprise AI vs. personal AI: multi-tenant workspaces
• System design for AI features: API, sequence diagram, use case, SQL
• How to measure AI & AI-product metrics
• Managing LLM cost & time-to-first-token

Industry-specific topics — same core principles, applied per domain:

• Fintech: explainability, model risk, KYC
• Retail/e-commerce: personalization, cold-start, RAG catalog
• Logistics & supply chain: document OCR, forecasting, exception-handling agents
• Manufacturing/engineering: computer vision, CAD understanding
• Healthcare: high-stakes hallucination, mandatory human oversight
• Enterprise SaaS B2B: multi-tenant rollout, admin controls, billing

The handbook is Vietnamese-only by design (written for the Vietnamese job market) — switching the language tab to EN/ZH will only show the 3 original coursebook interview questions.

Architecture

A single root index.html fetches one merged manifest (data/posts.json) and renders everything client-side:

index.html  ──fetch──▶  data/posts.json  (69 posts, merged from 2 modules)
     │                        │
     │                path points into each module's own folder
     ▼                        ▼
renderPost(slug, lang) ──fetch(post.path)──▶ raw content
     │
     ├─ path ends in .html  → coursebook: pre-rendered HTML (incl. static mermaid SVGs)
     │                         → injected into the DOM as-is
     └─ path ends in .md    → interview handbook: Markdown
                               → rendered via markdown-it, [[wikilink]]s resolved,
                                 ```mermaid``` code blocks converted to live diagrams via mermaid.js

No build step, no framework — everything lives in one index.html (Tailwind via CDN + vanilla JS, hash-based routing #/chapter/<slug>/<lang>).

Directory structure

ai-knowledge-fleet/
├── index.html                          ← the only app entry point
├── data/posts.json                     ← merged manifest (generated by _scripts/merge_manifests.py)
├── _scripts/merge_manifests.py         ← merges the two modules' manifests below
├── LICENSE
├── README.md / README.vi.md
│
├── loop-engineering-coursebook/        ← coursebook content source, NO standalone index.html
│   ├── content/{en,vi,zh}/*.html       ← each chapter, per language
│   ├── data/posts.json                 ← this module's own manifest
│   ├── _templates/loop-design.md       ← template for a new chapter
│   ├── _scripts/build_manifest.py      ← scans front-matter, regenerates data/posts.json
│   └── README.md
│
└── ai-interview-handbook/              ← handbook content source, NO standalone index.html
    ├── core/*.md                       ← 6 core technical topics
    ├── industries/*.md                 ← 6 industry-specific topics
    ├── data/posts.json                 ← this module's own manifest
    ├── _templates/topic-template.md    ← template for a new question
    ├── _scripts/build_manifest.py      ← scans front-matter, regenerates data/posts.json
    └── README.md

Adding new content

Add a coursebook chapter:

1. Copy loop-engineering-coursebook/_templates/loop-design.md into content/<lang>/, name it after its slug.
2. Fill in the content and front-matter (title, slug, category: loop, lang, order, summary).
3. python loop-engineering-coursebook/_scripts/build_manifest.py
4. python _scripts/merge_manifests.py (run from repo root)

Add an interview question:

1. Copy ai-interview-handbook/_templates/topic-template.md into core/ or industries/.
2. Fill in front-matter (title, slug, category: core|industry, industry, tags, level, summary) and content following the question → answer → follow-up → pitfall structure.
3. python ai-interview-handbook/_scripts/build_manifest.py
4. python _scripts/merge_manifests.py (run from repo root)

Then open index.html via a local server to verify before committing.

Cross-linking between handbook posts: use [[slug]] syntax inside Markdown content (e.g. [[guardrails-and-safety]]) — the app auto-detects it and turns it into a link.

Core principles

The coursebook content is built around three principles for designing self-looping AI systems:

• Evidence-only — decisions are based on concrete evidence (test coverage, logs, lint errors), never inferred or fabricated.
• Maker-checker separation — an agent never both produces and grades its own output (guards against reward hacking).
• Circuit-breaker — every AI-designed loop ships with an emergency stop (retry limits, timeouts, cost ceilings).

Deploying to GitHub Pages

1. Push the repo to GitHub.
2. Settings → Pages → Source: Deploy from a branch → Branch: main, folder / (root) → Save.
3. After a few minutes, the site is live at https://KhaiTrang1995.github.io/ai-knowledge-fleet/.

A root-level .nojekyll file is already included to disable Jekyll processing (otherwise GitHub Pages would silently drop underscore-prefixed folders like _scripts/ and _templates/).

License

MIT — free to use, modify, and redistribute with attribution.