/data

Own the analytical plane, not the served substrate

data treats data as a product — distinct from backend (data as application state) and ai (data as model context). It owns the event contract and tracking plan, data contracts and schema evolution, ingestion and movement, transformation and modeling, the metrics/semantic layer and BI, data quality and testing, lineage and observability, governance/PII/retention, experiment measurement validity, and platform/cost choices — the analytical and governed data plane, peer of frontend and backend. It references the substrates and outcomes that plane serves rather than re-deriving or overriding them: backend serves the OLTP store, ai decides retrieval behavior, product names the outcomes, growth designs the experiment.

Implement inside the decision. When compatible upstream artifacts are supplied — a solution-architecture doc, an NFR budget, a threat model, a handoff.yaml — data builds against them. When they don't exist (a standalone run), it says so explicitly rather than inventing a data-classification decision or threat model to fill the gap.

The faceted router

SKILL.md is a router, not a script. Every request selects the smallest sufficient route: one primary job — the ten below — combined with at most one base surface that reshapes how the job applies to the data-plane shape, plus the additive regulated overlay when GDPR/CCPA/HIPAA/SOC2 applies. Read the selected references completely; load two or three at most, never the whole pack. Ten jobs and five surfaces compose across data-plane shapes without ever reading all sixteen references at once.

The ten primary jobs

Each job is one reference, read fully only when its route is selected — grounded in named canon, producing a running pipeline/contract plus the decision record behind it. This is the whole surface, not a headline slice.

Full router table & invariants: SKILL.md.

Five surface overlays

One base surface, at most, reshapes every job for the data-plane shape — the same quality job is bounded differently on a single product's event stream than on a central platform serving many teams. The regulated overlay is additive — it stacks on top of whichever base you picked, never replaces it — and carries a distinct teal identity throughout this page.

The quality-and-testing flagship

Most of the field treats data quality as a dashboard someone checks after the fact; here trust is a gate. Five independent tools (Great Expectations, Soda, Elementary, Deequ, OpenMetadata) plus two lineage/catalog systems converged on nearly the same check buckets without coordinating — that convergence is the evidence the taxonomy below is complete enough to build a check plan from, not one vendor's opinion.

schema:      structural drift       # col add/remove/type
freshness:   staleness lag          # cheapest at source/staging
volume:      row-count anomaly
completeness: null-rate
uniqueness:  duplicates             # PK floor: unique + not_null
validity:    domain / set
statistical: distributional drift   # unknown unknowns
referential: cross-table / pair
custom:      business-rule SQL
+ PR-diff:   blast-radius review    # before merge, never after
+ PII:       recognizer → anonymizer # governance-pii-and-retention.md

What makes this different

Two stances set data apart from the tool-comparison guides and single-topic write-ups: it subtracts the buzzword where the field only renames the same primitive, and it treats the churning warehouse/tool/license layer as a first-class, date-stamped concern rather than frozen trivia.

The universal invariants

These rules govern every route, whichever references it loads — the behavioral spine, condensed.

• Contract-firstEvery dataset and event ships with an explicit schema, version, and evolution rule. Producers owe backward-compatible, notified evolution; consumers owe explicit requirements. The durable primitive under the "data contracts" brand is write-audit-publish + quality checks — teach the discipline, not the buzzword.
• Trust is a gate, not a dashboard ⭐Untested data is broken data. Floor: every PK gets unique+not_null. Validate at ingestion and quarantine violations — never silently drop or accept. Rule tests catch known unknowns; only anomaly baselines catch unknown unknowns — you need both.
• Small-data-firstDefault to a single node (DuckDB/Postgres) until measured pain; a distributed system must beat one laptop thread (COST) before its complexity is justified. Streaming needs a genuine sub-minute or event-driven requirement, not "it feels real-time."
• Narrow the DAG, widen the tablesStaging is 1:1 with sources, view-materialized, no joins; marts are wide and denormalized; materialization is a ladder (view → table → incremental) climbed only on measured bottlenecks.
• One metric, one definitionThe semantic layer has exactly one job: a single authoritative definition per metric, consumed by every tool and agent. Two tools computing "revenue" differently is a failed layer.
• Governance at the platform layerPII masking is enforced in the warehouse — app-layer redaction is bypassed by any query. Erasure honors Art.17 exceptions via tombstone + scheduled hard-delete. Consent gates collection, and "denied" is tested, not assumed.
• No experiment read before SRMAssignment is deterministic and salted; monitoring is peek-safe (confidence sequences/mSPRT) or pre-registered. A surprising result is investigated before it is believed (Twyman's Law).
• Retrieval-first / anti-stalenessTool versions, warehouse prices, spec revisions, and licenses churn quarterly. Every volatile fact is date-stamped with a re-verify pointer; read the LICENSE file, never a repo's API license field. Carry volatile_facts into the handoff.
• Subtract the buzzwordThe field debates abstractions more than it implements them. Name the durable primitive under each brand — mesh → ownership; contracts → write-audit-publish; modern data stack → a database and some SQL — and recommend the primitive.
• Distinguish facts, decisions, assumptions & proposalsPreserve upstream decisions and user constraints, or flag the conflict explicitly; prefer repository and artifact evidence over generic defaults; state unknowns as TBD rather than inventing a value.

What a pass produces

data's deliverable is a working data asset plus the decision record behind it, closed on a trust gate that was run, not asserted. A full pass emits up to four kinds of artifact — the working asset, its contract + tests, its lineage/telemetry, and the fillable checklists in assets/ — plus the machine-readable handoff.yaml companion when downstream work is expected. Each records the decision and options, the trade-off accepted (including what was removed), and — for any version/price/license fact — the date it was verified and how to re-verify it.

The handoff seams

data consumes architecture's artifacts upstream — data-classification decisions, NFR budgets, build-vs-buy on ingestion/warehouse — and, when downstream work is expected, emits a compact handoff.yaml beside the working asset: a routing index into it, never a copy. The clearest seam to name explicitly is the three-way retrieval seam shared with ai and backend around a RAG system.

The RAG three-way seam

Retrieval behavior (chunking, fusion, rerank, retrieval eval) is ai's. The vector store as served infrastructure (deployment, connection pooling, backup, uptime) is backend/operate's. The vector store and LLM traces as governed datasets — the ingestion pipeline, source-of-truth lineage, PII classification, access control on what gets indexed, and the trace/token warehouse — is data's.

The general handoff

skill: data
status: complete
objective: ""   # only required field
artifacts_created: [tracking-plan,
  data-contract, pipeline-config, dq-suite]
decisions: · assumptions: · constraints:
volatile_facts: [tool, price, license +
  date + re-verify pointer]
recommended_next: frontend · backend
  · ai · quality · operate · growth

Six distinct consumers, not one. Each is a consumer, not a co-author — data ships the contract, pipeline, and DQ suite; it does not write UI instrumentation, own the operational store, design retrieval behavior, run the independent compliance audit, own the monitoring dashboard, or design the experiment. Only objective is required; every other field may be empty. Never silently invoke a sibling skill; name it in recommended_next.

Start here

Install once. It's a plain SKILL.md router — no flags, no config, no scripts — so it activates on natural-language phrasing ("write a data contract," "add DQ tests with a PK floor," "pick a sync strategy," "govern this PII field," "check SRM before trusting this experiment") rather than a fixed command.

The same install runs on any Agent Skills host. Codex installs to ${CODEX_HOME:-$HOME/.codex}/skills and triggers with $data; agents remains a separate cross-agent installation target.