Day 1 · Synthesis Checkpoint

Reassemble the System from Memory

No new ideas. A retrieval workout, the kind that makes it stick.

Rereading feels like learning; it isn't. What builds durable memory is effortful recall. So everything below is hidden or asked, not told. Try each from memory before you reveal or pick. Struggling here is the point.

1 · Rebuild the stack

Day 1 was one system at six zoom levels. Reconstruct it, for each level, what is the core idea in a sentence? Write it down, then check.

The six-level stack — reconstruct it, then reveal 
DIAL (L1)      one dial set per task; VERIFICATION is the differentiator
HARNESS (L2)   Agent = Model + Harness; most failures are config, not model
FACTORY (L3)   your output is the SYSTEM that makes code; criteria, not steps
CONTEXT (L4)   six types; static vs dynamic; Skills = progressive disclosure
MODES (L5)     conductor (live) vs orchestrator (async); the 80% decides which
ECONOMICS (L6) the dial is a CapEx/OpEx curve; route models; context = $ lever

Each nests inside the one above: the dial is how far a task moves; the harness is the knob; the factory is the line the knob sits in; context is its input; the modes are how you drive it; economics is what it costs.

2 · The second axis

The build stack answers one question. The governance layer answers a different, orthogonal one.

The two axes — name each and what it asks — from memory first

Build dial (vibe → structured → agentic): is the output verified before it ships? Moved rightward by head → artifacts (tests, evals, specs, gates).

Governance axis (Unseen → Observed → Controlled → Autonomous, via VERDICT): while it runs, can we see it, stop it, and own it? Climbed via EXPOSE → BIND → ENFORCE → SELF-GOVERN.

"Production-ready" is the top-right corner of the readiness map. The sneaky-dangerous cell is agentic × Unseen: perfectly tested, nobody knows it's running.

3 · Recall under fire

One question per level, shuffled with governance. Pick before you're sure, retrieval, not recognition.

The one factor that sets a task's place on the build dial:

L1. Tests for the deterministic part, evals for the rest. Not the model, not the prompt.

An agent breaks. The lazy-correct first suspect:

L2. Most agent failures are configuration failures, a missing tool, vague rule, absent guardrail, noisy context.

In the factory model, your primary output is:

L3. You design the line, specs, agents, gates, feedback loops, not each widget.

A rule file billed on every single call is:

L4. Static = always loaded, every token every call. Skills load dynamically via progressive disclosure.

You conduct the 20% (not orchestrate it) because that slice is:

L5. The 20% needs judgment and looks-right failures hide there, so you stay hands-on and let evals guard it.

Agentic engineering trades money like this:

L6. Invest upfront so marginal cost per feature collapses. Vibe coding is the inverse, a loan at high interest.

An agent with great tests but no owner and no kill-switch is:

Two axes. High on the build dial, Level-1 "Unseen" on governance. Production-ready needs both.

The more you orchestrate away from watching, the more you need:

You were the kill-switch and the observer. Walk away and VERDICT's R/E/I pillars must take your place.

4 · Put it together

The whole point of Day 1 is this one reflex. Try it on a fresh case before revealing.

A team vibe-codes an internal agent that emails customers, running nightly, unowned. Place it on both axes and name one move on each. — answer, then reveal

Build dial: far left (vibe), no tests/evals, verification is a glance. One move right: write an evalset for its emails + a CI gate (head → artifacts).

Governance axis: L1 Unseen, nightly, unowned, no kill-switch, touching real customers. The dangerous cell. One move up: BIND, give it a named owner + a validation gate (can't send to real customers without approval), then a kill-switch.

That is the complete reflex: two coordinates, two levers. If you can do this cold on any task, Day 1 has done its job.

What you can now do

Straight from the mission: draw the arc from memory (§1), place any task on both axes and name what shifts it (§4), and read every concept through IC / Team / Organisation. That's the Day-1 success criteria, met.

Day 1 consolidated. ✓ The frame is now yours to build on.

Up next → Day 2, Agent Tools & Interoperability with MCP: how agents actually act on the world. The governance layer gets dense here (Validation, Identity, Cost; the confused-deputy problem).

Revisit: L1 · L2 · L3 · L4 · L5 · L6 · Glossary · Governance Layer · Course home