FDE-os

An operating system for becoming — and staying — a Forward Deployed Engineer (FDE): the embedded builder who scopes, ships, and operates production-grade agentic systems inside the customer's environment, not just in demos.

▶ Try the live agentic webapp → wjlgatech.github.io/FDE-os

No login, no code. Walk through three doors — the Course, the Toolkit (now with a Playground running three skills client-side, drift-gated against the Python sources), and the Community, where an in-page Delta guide (a real LLM, grounded so it never bluffs) answers your questions and turns a deployment war-story into a one-click field note. Static frontend on GitHub Pages, backed by a free shared-key model proxy on Vercel — runs at ~$0.

⚙ Install the toolkit as a Claude Code plugin

/plugin marketplace add wjlgatech/FDE-os
/plugin install fde-os@fde-os

The eleven skills + two composition workflows + the fde-os MCP server (eleven callable tools), in one command. Details: docs/PLUGIN.md. Same skills also run on Codex and Hermes (one skills/ tree, thin per-runtime manifests) — docs/RUNTIMES.md.

FDE-os has three objectives:

1. A JD-validated, personalizable course. A multi-mastery-level curriculum that upskills a person toward FDE roles, validated by one question: given a job description, does this course train the person well enough to land that job?
2. Cross-agent FDE tooling. Skills, plugins, dynamic workflows, and hooks for AI coding agents — Claude, Codex, Hermes, OpenClaw — authored once and run across runtimes.
3. A field-practice feedback flywheel. Real engineers run the Objective-2 tooling inside real engagements; the tooling auto-journals their real use cases, struggles, and problem-solving (privacy-redacted at capture); that field signal feeds back to improve Objectives 1 and 2.

Status

Stage 0 shipped (the production foundation). A reviewed six-stage roadmap drives the build: docs/plans/2026-06-20-001-feat-fde-os-staged-roadmap-plan.md (Delta-content-first; each post ships a Field Kit + a war-story prompt, so writing the series builds the toolkit and seeds the community).

What's live now:

• skills/knowledgefy — local-first, offline, deterministic: a prose research vault → a navigable knowledge spine (graph.json + self-contained file:// HTML). No engine, no network.
• skills/true-scorer — the TRUE 0–3 rubric as a runnable publish gate (total ≥ 10 AND every letter ≥ 2). No Delta post ships un-scored.
• skills/field-kit-generator — scaffolds + lints a Delta Field Kit to convention (the Field Kit menu, names-its-source, marks-RISKS); delegates skill synthesis to skillfy. Tooling for Stage 2 — the content (posts 2–4) stays gated on Stage-2 traction.
• skills/rag-eval-harness — offline, deterministic RAG/agent eval: retrieval metrics (precision@k, recall@k, MRR, hit-rate) + a grounding/hallucination proxy + citation coverage, with a CI-able pass/fail gate. Built for the CVS prep's deepened eval cluster; reusable anywhere.
• skills/fde-mcp-server — a runnable, stdlib Claude MCP server (stdio JSON-RPC) exposing FDE-os's skills as MCP tools. A real "1+ Claude MCP integrations" example; fork it for your own.
• skills/criteria-scorer — score any artifact against binary pass/fail criteria (word count, required regex, forbidden buzzwords, has-a-number, has-a-citation) → 0–1 + a gate. The general third scorer alongside true-scorer and rag-eval-harness.
• skills/eval-loop — the self-improving loop primitive: score artifact versions, keep the winner, revert regressions, append a run-log (Round │ Change │ Score │ Verdict). Git is the memory.
• skills/invisible-workflow-mapper — reconstruct an org's decision workflow from partial signals (before the client can articulate it): adoption-readiness score + inferred archetype + its adoption traps + the oblique probes to ask next, gated. Deepens the delta-discovery-protocol kit — because the biggest deployment failures are workflow failures, not model failures.
• skills/jd-compiler — a JD is the input. Compile real job descriptions (Google · Reflection · CVS) into structured FDE competency knowledge + a cross-company demand matrix, then grow the knowledge base with it: knowledge/jd-competency-spine.* (built via knowledgefy from the compiled knowledge/vault/jd-competencies/) — the demand signal, unlocked from prose.
• skills/fde-mcp-server — a dependency-free MCP server exposing 11 tools (true_score, rag_eval, criteria_score, eval_loop, invisible_workflow_map, jd_compile, doc_gate, hub_find, snowflake_plan, snowflake_readiness, snowflake_catalog) to any MCP host.
• skills/doc-understanding — the moat a real engagement named: messy enterprise docs (DOCX with merged tables + track-changes, XLSX with shared strings + merged ranges) → one canonical structured representation + a parse-quality gate (coverage · structure · fidelity; NO-GO on empty parses or unresolved revisions) — because Output Quality ≤ Input Representation Quality. Pure stdlib, offline.
• snowflake-os/ — the curriculum layer for Snowflake: learn.snowflake.com (58 courses, 12 exams, 12 role journeys, 5 tracks) compiled into a provenance-pinned knowledge base, plus the /snowflake-os super tool over it — search the catalogue, plan the shortest costed path to a role or exam, and GO/NO-GO someone's readiness on verified evidence (a badge counts; a screenshot scores zero). Snowflake's own agentic tooling operates on the warehouse; nothing operated on the curriculum. Six Snowflake-Labs repos are registered as SHA-pinned satellites, two quarantined on licence grounds. Offline, stdlib-only, 10 integrity checks in CI. See snowflake-os/README.md and the navigable spine at knowledge/snowflake-catalog.html.
• workflows/snowflake-enablement — the staffing verdict: knowledge-base integrity AND readiness → STAFF / NOT-YET, where a NOT-YET always ships the shortest path to yes.
• workflows/engagement-readiness — the first composition workflow: chains invisible-workflow-mapper (adopted?) AND rag-eval-harness (works?) into one GO / NO-GO gate. Skills are blocks; workflows chain them.
• course/prep/tools/coding-drill-kit — eval-as-gate pointed at a human: write the six interview templates from memory (no AI, bare editor), drill.py check scores them against real unit cases and logs every round; plus a 12-criterion design-round self-score for criteria-scorer. Built for the Google FDE loop case study.
• knowledge/fde-spine.* — the canonical FDE knowledge spine built from the research vault (12 concepts across all 7 research threads, 39 evidence nodes, 51 edges).
• CI — tests.yml runs every skill's test suite + the Field Kit convention lint on each push/PR; freshness.yml (scripts/check_freshness.py) keeps external references honest (fails only on dead links; bot-walls are warnings).
• Live landing page → https://wjlgatech.github.io/FDE-os/ — the Delta community door, served from index.html via GitHub Pages. This is the URL Post #1's first-comment link points at. Styled in the same Anthropic-style design system as the README infographics — warm ivory paper, charcoal ink, a single clay accent (#CC785C), Newsreader serif display + Hanken Grotesk body.
• Owned-hub wiring + metrics (Stage 1 infra) — index.html captures signups: set KIT_FORM_ID or FORMSPREE_ID for automated capture (no client-side secret; GDPR/unsubscribe baseline), and until then a signup routes to OWNER_EMAIL via the visitor's mail app (no lead dropped). The funnel
  • Gate A / Gate B thresholds live in flywheel/metrics.md.

The discovery artifact that started it all — a ranked, critiqued ideation document (12 directions across 6 axes) — is at ➡️ docs/ideation/2026-06-17-fde-os-ideation.html.

Architecture

Ten offline, tested skills over a CI + git foundation — knowledge → eval gates → packaging, each layer feeding the next. Full system design: ARCHITECTURE.md.

Delta — the content flywheel

Delta is FDE-os's public content layer: a blog/essay series ("The Last Mile") that ignites the three objectives rather than being a fourth. Articles win attention → the Course builds skill → the Toolkit gives leverage → the Community retains people and generates the next field stories → which become the next articles.

Every post is two tiers and must be TRUE:

• Transferable — a mental model a human can re-teach (feeds Objective 1, the course)
• Reusable for agents — ships a forkable Field Kit asset (feeds Objective 2, the tooling)
• Understandable — a sharp 15-year-old follows it (concrete-first)
• Experience-able — a sub-10-min "try this" that produces conviction (feeds Objective 3, the flywheel)

Because each article ships a Field Kit, writing the series builds the toolkit — content production is product production.

Delta artifacts (in this repo)

File	What it is
FDE-research-synthesis.md	The cited research vault (7 threads: labs, Palantir origin, YC, analysts, the debate, tooling, community)
Delta-01-field-manual.md	Post #1 — long-form TRUE article (scored 12/12): The Delta Loop
field-kits/delta-discovery-protocol/SKILL.md	Field Kit #1 — a forkable agent skill that runs FDE-style discovery
Delta-01-linkedin.md	Post #1 viral feed-post ("Signal") version
Delta-TRUE-article-spec.md	The TRUE article template + Field Kit menu + 0–3 eval rubric
Delta-viral-playbook.md	Hook templates, post skeleton, stat bank, do/don't
Delta-community-strategy.md	Hub-and-spoke community topology + participation ladder
index.html	The landing page — "one field, three doors." All three cards link out: Course → course.html, Toolkit → toolkit.html, Community → contribute.html.
course.html	Door 01 · Learn — the FDE curriculum hub: the six-cluster competency map, the JD-validated prep curricula, the readiness scorecard, the RAG-eval lesson, the agentic-solution-architect tool (each links to source).
toolkit.html	Door 02 · Build — the open-stack hub: the seven offline CI-gated skills + the Delta Discovery Protocol field kit + the MCP server, each with a "fork →" link.
playground.html	The toolkit, runnable in the browser — three skills client-side (jd-compiler, true-scorer, workflow-mapper quick-read), no login, nothing leaves the page. Their rules load from assets/toolkit-brain.json, generated from the Python sources by scripts/export_brain.py and drift-gated in CI (tests/test_brain_export.py) — the web version cannot silently diverge from the tested CLIs.
contribute.html	Door 03 · Community — the agentic contributor page — a no-login, no-code page where non-technical visitors chat with a knowledge-grounded "Delta guide" (refuses rather than bluffs) and turn a war-story into a structured field note posted as a one-click GitHub issue. Static (GitHub Pages), Anthropic-styled. The guide now answers via a deployed shared-key proxy (proxy/delta-guide/, live on Vercel) so every visitor gets a real grounded model — or bring your own free key via ⚡ Power mode (stays in your browser).
proxy/delta-guide/	Deployable Vercel function backing the guide with a shared free LLM + fallback chain (NIM→Groq→Gemini), origin allow-list, and token caps. Holds the key server-side so the static page never does.

References

• ai-engineering-from-scratch — the blueprint for how to build a curriculum-as-repo (lesson tree, Build-It/Use-It spine, every lesson ships a reusable artifact, generated site, CI invariants).
• Interview Kickstart FDE program — domain content reference (the 23-week FDE curriculum).
• Google Cloud Forward Deployed Engineer (GenAI) — a target-outcome job description the course validates against.
• Reflection AI — Forward Deployed Engineer — a second JD target, with a worked dual-tier prep curriculum (course/prep/reflection-ai-fde-prep.md): every competency ships human knowledge and a forkable agent tool.
• CVS Health — Agentic AI Engineer — a third JD target (prep), with one cluster deepened into a full RAG-evaluation lesson + the runnable rag-eval-harness skill.
• wjlgatech/data-architecture — the cloud/data track (medallion lakehouse, governance, FHIR case studies) and a plugin-of-skills packaging reference.

Repository structure

Path	What it is
Delta-*.md, FDE-research-synthesis.md	Content artifacts + the cited research vault (the spine's input)
field-kits/	Forkable Field Kits — one per Delta post (the "R" in TRUE)
skills/	The ten FDE-os-native agent skills (SKILL.md + scripts/ + tests/ each) — built only where existing skills leave a gap
knowledge/	Generated knowledge spine (fde-spine.graph.json + .html)
flywheel/	Objective-3 infra + content-production runbook/metrics (mostly Stage 1–3)
docs/field-notes/	The flywheel's journal — real engagements distilled into transferable lessons (separating deep structure from domain surface) that feed Objectives 1 & 2
course/	Objective-1 JD-validated course. target-jds/ = JD validation targets; prep/ = worked dual-tier prep curricula (human knowledge + agent tools). The full Stage-4 course engine is still gated.
scripts/	Repo tooling (check_freshness.py)
docs/plans/, docs/ideation/	The roadmap plan and the originating ideation doc
docs/research/	External methodology/landscape sources + our critical evaluations (separate from the FDE-domain vault)

What's next

Where are we right now? → STATUS.md — the one-glance done / blocked / next board. (The roadmap plan holds the decisions and stays immutable; CHANGELOG.md is the full build log; STATUS.md is the glance. Progress lives in git, never as checkboxes in the plan.)

In short: Stage 0 (foundation) is shipped and most of Stage 1's code is in. Stage 1 — Prove the Loop now needs the go-live ops (publish Post #1, wire the Kit form) before Gate A can be read. Stages 3–5 are gated on Stage-2 traction (Gate B) — see the roadmap plan's "Stage Gates & Kill Signals".