IMPERATIVE BRAIN

C / Go / Rust

You think in memory, cycles, and system calls. When the LLM-built pipeline OOMs on the client's 64GB server at 3am, you know exactly where to look because you've debugged segfaults by hand.

FUNCTIONAL BRAIN

Haskell / Scala / Clojure philosophy

Immutability, pure functions, composition. When you architect a data pipeline, you naturally reach for the patterns that prevent state bugs before they can exist.

DECLARATIVE BRAIN

SQL / Terraform / HCL / YAML

The ability to describe what you want rather than how to get it. This is infrastructure as poetry. You understand why Terraform is powerful precisely because you remember configuring servers by hand.

DYNAMIC BRAIN

Python / JavaScript / Ruby

Speed of thought. Prototyping. Glue code. When a client needs a proof-of-concept in 2 hours, you don't argue about types — you ship something that works and proves the value.

SHELL/BASH BRAIN

Bash / awk / sed / grep

The language of the machine's own nervous system. One-liners that process 10GB log files. The ability to operate in a client environment where nothing is installed except the OS itself.

LEGACY BRAIN

COBOL / FORTRAN / PL/SQL

The greybeard's secret weapon. When the client's "Data Warehouse" is actually a COBOL batch job from 1987 that processes 4 trillion dollars a day, you are the only person in the room who can read it.

THE HYPE CYCLE PATTERN

1. Announced at a conference with live demo that works
2. VC money floods in
3. Every startup rebuilds in the new paradigm
4. Production edge cases emerge
5. The "boring" version that works ships
6. It becomes the new legacy system

ETERNAL TRUTHS (NEVER CHANGE)

• Networking is hard — partial failure is the only failure mode
• Data is the moat — not the model, not the infra
• Humans are the bottleneck — always, forever
• Simple > Clever — the clever solution fails at 3am
• Observability first — if you can't see it, you can't fix it
• The database outlives everything — design schemas with respect

CURRENT HYPE → ACTUAL SIGNAL

• Hype: "LLMs replace all engineers"
  Signal: LLMs automate boilerplate, amplify experts
• Hype: "Vector DBs solve RAG"
  Signal: Hybrid search (BM25 + vectors) wins
• Hype: "Agents will be autonomous"
  Signal: Human-in-loop wins for now
• Hype: "Serverless = no ops"
  Signal: Observability becomes harder

GROUNDEDNESS

Does the answer come only from retrieved context?
Hallucination score = 1 - groundedness.

RELEVANCE

Was the right context retrieved? Top-3 hit rate is your KPI before worrying about generation quality.

FAITHFULNESS

Does the generated answer faithfully represent what the context says — nothing added, nothing omitted?

INNER LOOP (DEV TIME)

Tool: ADK eval CLI + Web UI

When: During agent development

• tool_trajectory_avg_score — right tools used?
• response_match_score — ROUGE similarity
• rubric_based_final_response_quality

OUTER LOOP (PRODUCTION)

Tool: Vertex AI Gen AI Evaluation Service

When: Before any model/prompt update ships

• Pairwise (AutoSxS): Model A vs Model B via LLM judge
• Pointwise: Groundedness, fulfillment, coherence
• Pipeline Eval: Async batch for 10k+ test cases

PRODUCTION OBSERVABILITY

Latency Tracing: LangSmith or Cloud Trace for agent chain-of-thought visualization

Cost Monitoring: Token usage per query × daily query volume = your GCP bill. Set alerts at 80% budget.

• Prometheus + Grafana — request/error rates
• Loki — log aggregation
• Cloud Trace — distributed tracing

TWO-TIER INFERENCE

For real-time constraints (banking fraud, trading)

Fast deterministic model (<100ms) for the primary decision path. LLM async deep-dive for analyst explanation. Never put an LLM in the hot path of a latency-critical system.

User request
    └→ XGBoost / Rule Engine → Decision (50ms)
    └→ Gemini/Claude → Explanation (async, 3-5s)

SPECULATIVE DECODING

For inference cost reduction

Small draft model generates candidate tokens. Large verifier model accepts/rejects in parallel. 2-4x throughput gain with identical output quality. Critical for high-volume enterprise deployments.

MIXTURE OF EXPERTS (MOE) ROUTING

For multi-domain enterprise clients

Route queries to specialized agents/models by domain: Legal → legal-finetuned model. Finance → finance-finetuned model. General → frontier model. Cost-efficient + domain-accurate.

HUMAN-IN-LOOP CHECKPOINTS

For regulated industries

Interrupt an agent pipeline at defined decision gates requiring human approval. Critical for healthcare (HIPAA), finance (SOX), and defense. LangGraph's interrupt/resume makes this elegant.

CONSTITUTIONAL AI GUARDRAILS

For enterprise content safety

Apply a second LLM pass to evaluate and filter output before it reaches end users. Define client-specific "constitutions": what is acceptable response content for this industry.

TACTICAL EDGE DEPLOYMENT

For air-gapped / defense clients

ONNX quantized models (.q4). Local Ollama/llama.cpp runtime. Offline vector store. No external API calls. The model weights live on the device. Deploy like a software package, not a service.

🥉 BRONZE LAYER

Raw Landing Zone

Immutable. Never transformed. Exactly as received from the source. This is your insurance policy — when the Silver layer breaks, Bronze is your truth.

• GCS bucket with versioning enabled
• Append-only — no deletes, no updates
• Partition by ingestion date, not event date
• Preserve original file format (CSV, JSON, Parquet)

🥈 SILVER LAYER

Single Source of Truth

Cleaned, joined, deduplicated. This is where dbt transformations live. The "Single Source of Truth" that all downstream consumers read.

• BigQuery tables with enforced schemas
• dbt models for transformation lineage
• Data quality checks (Great Expectations / dbt tests)
• SCD Type 2 for slowly changing dimensions

🥇 GOLD LAYER

Business-Ready / AI-Ready

Pre-aggregated, denormalized, optimized for the end consumer. Powers dashboards, APIs, and AI agents. OBT (One Big Table) patterns live here.

• BigQuery clustered + partitioned for query cost
• Feature Store for ML model inputs
• Vector embeddings for RAG retrieval
• Materialized views for dashboard performance

PARTITIONING vs CLUSTERING

QUERY COST KILLERS

• SELECT * on wide tables — always project columns
• No partition filter — always filter on partition column
• CROSS JOINs — usually a data model design failure
• REGEXP on large tables — pre-extract to Silver layer
• Window functions without PARTITION BY — full table scan

PYRAMID PRINCIPLE (BLUF)

Bottom Line Up Front

The greybeard pattern: executives want the conclusion, then the data that supports it. Not the journey. Not the technical details.

WRONG: "We analyzed the data and then
       ran the pipeline and found some
       issues and eventually we think..."

RIGHT: "The migration will be 2 weeks late.
       Reason: data quality issues in source.
       Fix: 3-day remediation sprint starting Monday."

MECE PRINCIPLE

Mutually Exclusive, Collectively Exhaustive

Break any complex problem into components that: (1) don't overlap and (2) together cover everything. No gaps, no double-counting.

Applied: When scoping a client project, your workstreams should be MECE. "Data Migration" and "ETL Pipeline" are not MECE — migration is part of ETL. Restructure until clean.

80/20 VALUE SCOPING

The 20% of features that deliver 80% of client value. Find these in Week 1. Build these first. Prove value. The remaining 80% of the feature list is negotiable.

THE "FIVE WHY'S" DIAGNOSTIC

Never accept the stated problem as the real problem:

"Our AI model is inaccurate"
  → Why? Training data is stale
  → Why? No automated retraining
  → Why? No MLOps pipeline
  → Why? No ML engineer on staff
  → Why? No ML hiring budget

ROOT CAUSE: Budget prioritization problem,
not a model accuracy problem.

DATA RED FLAGS

• "Data will be ready in 2 weeks" — add 6 weeks to your estimate
• "We have clean data" — no one has clean data
• "The schema is documented somewhere" — it isn't
• Multiple teams own the same data — political landmine

POLITICAL RED FLAGS

• "We don't need a PM on our side" — project will lose direction
• "The CTO approved this but we haven't told IT" — incoming resistance
• "Can we skip the security review?" — this will come back
• "The previous vendor failed too" — investigate WHY before proceeding

INFRASTRUCTURE RED FLAGS

• "Can we run this on-prem for now?" — deep cloud distrust, investigate root cause
• "We don't have GPU quota" — request lead time: 2-4 weeks minimum
• "Our firewall policy is managed by a different team" — add 2-3 weeks to any connectivity work

C — CLARIFY

Before architecting anything, extract the constraints:

• What is the data volume? (GB, TB, PB?)
• What is the security classification? (PII, PHI, Secret?)
• What is the latency requirement? (<100ms? <5s? Next-day batch?)
• What is the "Definition of Done"?
• What is the client's cloud maturity? (GCP native? Hybrid? Zero cloud?)

A — ARCHITECT

Draw the data flow from source to end-user UI:

• Source → Ingestion → Bronze → Silver → Gold
• Name the GCP service at each step
• Identify where security controls live
• Estimate cost at each layer

S — SOLVE THE DELTA

What does the product NOT do out of the box?

• Custom format parser needed?
• Legacy system API wrapper?
• Data quality circuit breaker?
• Real-time → batch bridge?

This is where you demonstrate actual FDE instinct — the ability to see the gap and immediately propose the glue code.

E — EVALUATE

How do you prove the AI is working?

• What is the hallucination detection strategy?
• What is the Golden Dataset and who owns it?
• What monitoring exists in production?
• How does the system degrade gracefully?

THE CLASSICS (STILL APPLY)

• The Mythical Man-Month (Brooks, 1975) — Adding engineers to a late project makes it later. True in 1975. True today. Every FDE will see this happen.
• Structure and Interpretation of Computer Programs (SICP) — MIT's 1985 textbook that teaches you computation as a language, not a tool.
• The Art of Unix Programming (ESR) — Why small, composable programs beat monoliths. The philosophy behind microservices, before they had that name.

THE META-SKILLS

• How to Read a Paper (Keshav) — The three-pass method. 30 years of papers means you can read faster. Teach this to junior FDEs.
• Clear Thinking (Shane Parrish) — Mental models for decision-making under uncertainty. The consulting mindset in book form.
• Deep Work (Cal Newport) — How to protect focus time in client-site environments full of interruptions.