This is still software engineering

AI engineering isn't a break from software engineering — it's software engineering with new materials. Two classic disciplines map onto this stack: SOLID (the fit is analogical, but the discipline transfers) and the SDLC (which your outer loop already is).

SOLID, translated to agent architecture

Principle In agent systems Rung
Single Responsibility One skill, subagent, or tool does one job. Keep loop-control logic separate from tool logic. L1 · L6
Open / Closed The harness is open to new tools and skills, closed to modification of the core loop — add capability without rewriting control flow. L3 · L6
Liskov Substitution Any subagent behind the tool interface is swappable; a model or provider can be substituted without breaking callers. L6
Interface Segregation Narrow, focused tool schemas over god-tools — an agent shouldn't depend on a bloated interface it mostly ignores. L1
Dependency Inversion Depend on abstractions — a model / tool / retrieval interface — not a specific vendor implementation. L1 · L3

The honest caveat

SOLID is a set of class-level OOP principles; its mapping onto agent architecture is analogical, not literal. But the underlying discipline — single responsibility, substitutability behind interfaces, depending on abstractions — is exactly what keeps a growing agent system from ossifying. Treat it as a design compass, not a rulebook.

The SDLC, made AI-native

Classic phase AI-native equivalent Rung
Requirements The spec — behavior contract, acceptance criteria, constraint budget. L7
Design Architecture — model/prompt foundation, harness, loop topology, composition. L1–L3 · L6
Implementation Building the loop and harness, plus the knowledge layer if the system needs it. L2–L4
Testing Evaluation — offline evals, adversarial, safety. Probabilistic outputs make testing distributional, not pass/fail unit tests. L5
Deployment Serving and ship — the body that exposes the harness over the wire. L5
Maintenance Observability + revise-spec — continuous, and a far tighter loop than classic ops. L5 · L7

The punchline

The outer lifecycle loop — spec → build → eval → ship → observe → revise — is the SDLC, compressed and made continuous. The load-bearing difference is evaluation: classic testing assumes deterministic behavior, so it can't certify a probabilistic system. Evals are how the SDLC survives non-determinism.

Bottom-up was how you learned. Top-down is how you work.

SPEC → BUILD → EVAL → SHIP → OBSERVE → REVISE SPEC ↻

The whole ladder exists to be internalized and then run in reverse. Once the primitives are muscle memory, you stop assembling from the bottom and start governing from the spec. That inversion — from builder to spec-driven operator — is the actual definition of expert in this stack. Everything below L7 is the apprenticeship for it.

┌─ LIFECYCLE LOOP · SLOW · SDD GOVERNS ──────────────────┐
│  ┌─ DEV LOOP · DOZENS/DAY ─────────────────────────┐   │
│  │  ┌─ RUNTIME LOOP · SECONDS · THIS IS L2 ─────┐  │   │
│  │  │  observe → decide → act → terminate       │  │   │
│  │  └───────────────────────────────────────────┘  │   │
│  │                                                 │   │
│  │  you tuning prompt & harness                    │   │
│  └─────────────────────────────────────────────────┘   │
│                                                        │
│  spec → build → eval → ship → observe → revise spec ↻  │
└────────────────────────────────────────────────────────┘

Three loops, three timescales

  • Runtime loop — the agent cycling at inference. Seconds per turn. This is L2.
  • Dev loop — you tuning prompt and harness. Dozens of times a day.
  • Lifecycle loop — spec → build → eval → ship → observe → revise. SDD governs this one.

Two threads run the whole climb

  • Termination is fractal. The stop-condition problem from L2 recurs at every altitude — each subagent, the orchestrator, every loop.
  • Confidence runs to the token. Token entropy → confidence → termination. Foundations are the control plane, not trivia.

The expert's day — one turn of the outer loop

  1. Start at the spec. Behavior contract, acceptance criteria, eval targets — before a line of implementation.
  2. Build the smallest thing that satisfies it. Core before conditional. One loop before a swarm.
  3. Measure against the spec. The eval suite derives from the same document the build does.
  4. Ship, then watch production. Traces, cost, latency, online evals, real feedback.
  5. Revise the spec from signal — and close the loop without breaking it.