Engineering principles

One engineering value system, across very different domains

AI makes building fast. Fast usually means slop. The antidote isn't slower — it's a consistent set of engineering principles applied no matter the domain. I've held to the same five across a production RAG system, a bidirectional SAP-HANA data-warehouse engine, and my agent systems — including the governance framework I deliberately retired when a leaner setup met the same goals. That consistency — more than any single project — is what I mean by thinking in systems.

Reproducible, auditable output beats a faster path you can't reason about.

• — RAG: a rule-based, deterministic ingestion pipeline — no LLM in the data path, so the same source always yields the same chunks.
• — SAP-HANA engine: byte-stable roundtrip tests — the same spec generates identical bytes every run.
• — Agent systems: a kernel with no LLM calls that advances a workflow exactly one transition per invocation.

Architectural rules the code refuses to violate, surfaced as errors — not comments people forget.

• — RAG: compute-once budgets and stage contracts at every stage boundary — violations raise, they don't warn.
• — SAP-HANA engine: enforced read-write symmetry — a new spec field forces type, parser, generator, and roundtrip test in one step.
• — Agent systems: single-shot agent contracts enforced as typed exceptions.

One authoritative representation; everything else is derived, never duplicated.

• — SAP-HANA engine: one shared intermediate representation drives both reading and writing of warehouse objects.
• — RAG: the same enrichment representation is applied to chunks at index time and to queries at search time — one representation on both sides of the embedding match, the retrieval twin of the engine's read-write symmetry.
• — Agent systems: a versioned memory SSOT and a single gateway guardrail — one fix for every client.

You can't improve what you can't measure with confidence — so I build the measurement in.

• — RAG: retrieval evaluation stratified by the dimension that can actually be steered — target page type, which maps to a chunking strategy — deliberately chosen over a query-intent cut that flattered one segment's recall. The honest number read lower.
• — SAP-HANA tooling: golden-master and snapshot tests as the safety line for refactors.
• — Agent systems: model and budget decisions measured, not assumed — a bigger token budget bought no reasoning depth; only a stronger model moved that line.

A system is defined as much by what it deliberately won't do as by what it does.

• — RAG: scope bounded to the knowledge and retrieval layer — generation is a managed model call, stated plainly.
• — SAP-HANA engine: an explicit "what the engine does not do" list — no guessing business logic, no production access.
• — Agent systems: a deliberate "this doesn't raise model capability — don't build a framework you don't need" boundary — enforced against my own work when I retired the framework that crossed it.