# The AI4SE Layered Technology Model: Effectiveness as the Foundation, Harmony as the Cross-Cut

This article distills the training deck Layered Software Engineering Technology in the AI4SE Era: Effectiveness & Harmony, aimed at engineering managers, architects, and Champions who need to build organizational consensus on AI4SE methodology.

Roger Pressman, in Software Engineering: A Practitioner’s Approach, describes software engineering as four stacked layers of technology: Quality Focus → Process → Methods → Tools. This layered logic still holds in the AI4SE era — quality is still the foundation, process is still the glue, and tools still can’t fly solo — but three key evolutions are needed to support co-creative delivery by “human + Agent + Harness.”

A one-line definition:

AI4SE software engineering = governable co-creative delivery achieved on an Effectiveness foundation, with Harmony cross-cutting the human-machine division of labor, through upgraded Process / Methods / Tools.

---

Why Revisit Pressman

AI has changed interfaces, workflows, and how organizations collaborate, yet many teams still follow the path of “buy IDE plugins → expect ROI.” Pressman’s model is worth revisiting because it separates value trade-offs, process discipline, method systems, and tooling mechanisms into distinct layers — exactly the “engineering grammar” that organizations are most missing once AI amplifies output.

The Original Pressman Model

The classic model stacks bottom-up: the base layer is Quality Focus, followed by Process, Methods, and Tools. Each layer supports the one above it in a one-way dependency — without a quality culture, process becomes formalism; without process as glue, methods and tools each fight their own battles.

What Still Holds vs. What’s No Longer Enough

Still holds	Why it matters more in the AI4SE era
Quality is the foundation	AI amplifies output — and defects along with it; without verification and review, rising change volume only creates more chaos
Process is the glue	End-to-end success depends on the closed loop of “spec → context → execute → verify → measure,” not IDE autocomplete
Tools can’t fly solo	Buying an AI IDE without changing process rarely produces organization-level ROI (DORA: AI is an amplifier)

No longer enough	AI4SE reality
The base layer contains only Quality	Teams face dual pressure to be both “fast” and “correct”
Tools drawn as the smallest layer	Agents have become co-executors, not a nice-to-have add-on
No collaboration dimension	It must be explicit who explores, who generates, who accepts, and who is accountable
Methods assumed to be for humans only	Must accommodate methodology families like Harness, SDD, and Agentic Engineering
Strictly one-way dependency	Metrics, incidents, and reviews should feed back into Spec, Rules, and Process

---

The AI4SE Evolved Model

The three evolutions can be compressed into a single structural diagram:

[FOUNDATION] Effectiveness Focus = Quality + Efficiency
[CROSS-CUT] Harmony (Human <-> Agent) = roles, boundaries, handoffs, accountability, approval
[THREE LAYERS] Process -> Methods -> Tools (structure unchanged, meaning upgraded)

Effectiveness Focus: Quality + Efficiency

The foundation expands from a single Quality Focus into an Effectiveness Focus, made of two components:

Component	Definition	Includes
Quality	Doing it right, doing it stably	Correctness, maintainability, verifiability, auditability, Trust (safety and security)
Efficiency	Producing outcomes without waste	Flow efficiency, small batches, throughput, Value (effective for the business)

Worth repeating from the training deck:

• Efficiency is not “fast” — it’s producing effective outcomes without waste. Being fast but wrong is not Efficiency.
• Quality and Efficiency exist in tension; the foundation is a culture of value trade-offs — how much quality you’re willing to sacrifice for speed, and how much efficiency cost you’re willing to pay to guarantee quality.

---

Harmony: The Human-Machine Collaboration Contract

Harmony is not a fifth layer in the stack — it’s a cross-cutting collaboration contract that runs through Process / Methods / Tools. It doesn’t answer “can humans and AI get along,” but instead codifies roles, responsibilities, and handoffs into a system.

A Five-Dimension Collaboration Framework

Dimension	Meaning
Roles	Planner / Generator / Evaluator — who plans, who generates, who independently accepts
Boundaries	Which actions the Agent may take autonomously, which require Human-in-the-loop
Handoffs	Spec, Plan, Diff, Test Log — the evidence exchanged between human and machine
Accountability	Merge, release, security — the human always bears responsibility
Approval	Permissions, sandboxes, hooks, audit logs

The Supervision Spectrum: HITL / HOTL / HOOL

Harmony’s “boundaries” dimension shows up at runtime as a supervision spectrum — routed by the risk of the action, rather than applying a single mode everywhere:

Mode	Meaning	When to use
Human-in-the-loop (HITL)	Agent proposes → blocks → human approves before execution	Irreversible, compliance-sensitive, high-risk actions (merges, releases, deleting data)
Human-on-the-loop (HOTL)	Agent executes autonomously; human supervises and can override	High-frequency, reversible actions (exploration, drafts, running tests)
Human-out-of-the-loop (HOOL)	Fully autonomous within policy + monitoring/audit	Templated, low-risk paths with strong gating

Accountability always sits with the human; the Loop mode can vary by action.

Draws on Sheridan’s supervisory control theory, the human oversight requirements in the NIST AI RMF, and industry practice on layering HITL vs. HOTL.

Process × Loop Default Routing

Aligning Process steps with Loop modes is the key to moving Harmony from principle to daily practice:

Step	Primary role	Loop	Key point
Research	Human + Agent	HOTL	Exploratory drafts, human supervises direction
Plan	Human-led	HITL	Spec / Plan sign-off
Execute	Agent	HOTL	Small sandboxed steps; escalate to HITL for high risk
Review	Independent Evaluator	HITL	Agent cannot self-evaluate
Ship	Human accountable	HITL	Merge / release

This is consistent with the closed-loop governance described in Inner / Middle / Outer Loop and Loop Engineering — the Loop mode is Harmony’s working vocabulary at runtime.

---

A Deep Dive Into the Three Layers

The structure is still Process → Methods → Tools, but the default executor shifts from “human + tools” to “human + Agent + Harness.”

The Process Layer: An Auditable Human-Machine Loop

It upgrades from a sequence of human activities into an auditable human-machine collaboration loop:

Research -> Plan -> Execute -> Review -> Ship
(Extensible: Policy & Routing -> Archive, Measure, Improve)

The core question: What must a human approve, and what can be handed to the Agent to run automatically?

Harmony checklist for the Process layer: which step must a human approve? Which step can the Agent handle autonomously? Typical mechanisms include review gates, ship gates, and HITL/HOTL routing.

The Methods Layer: A Family Tree of Methodologies

The Methods layer is a container; Methodology is the individual school or system within it. The AI4SE era needs to accommodate new methodology families alongside traditional engineering discipline:

Methodology	What it solves	Typical artifacts / practices
Agentic Engineering	How to make the Agent an engineering participant	Commands, Skills, Subagents, closed workflow loops
Harness Engineering	How to steer the model and constrain Agent behavior	AGENTS.md, Rules, Hooks, Permissions, Eval
SDD (Spec-Driven Development)	Where specs come from, how they change, how they’re accepted	OpenSpec, proposal/design/tasks, delta specs
Loop Engineering	How to turn Agent work into a governable closed loop	Inner / Middle / Outer Loop
Traditional methods	Human engineering discipline	TDD, refactoring, design patterns, code review

The relationship: Methodology sets the discipline; Tools provide the mechanism. Avoid mechanically chaining OpenSpec, Superpowers, gstack, and similar tools without a clear division of labor — the Methods layer needs to make explicit who owns “spec / discipline / delivery.”

Harmony checklist for the Methods layer: which methodologies are human-led? Which can be encapsulated for the Agent? Typical mechanisms include independent review, spec sign-off, and separation of Planner/Generator/Evaluator roles.

The Tools Layer: Tools for Humans + a Runtime for Agents

The Tools layer expands from CASE-style assistance into tools for humans plus a runtime for Agents:

• IDE, CI/CD, Agent CLI, MCP, browser automation
• Permissions, context, state, evaluation (Eval)
• Humans configure the tools; Agents act within them

The core question: What can the Agent see, what can it change, and how does it stop when it fails?

Harmony checklist for the Tools layer: how do you turn the division of labor into system behavior? Typical mechanisms include permissions, approvals, audit logs, sandboxes, and tool allowlists.

---

The Harmony Implementation Checklist

Aligning the Harmony five dimensions with the three-layer stack and Loop modes produces an actionable implementation checklist:

Layer	Question Harmony answers	Loop mode	Typical mechanism
Process	Which step must a human approve?	HITL / HOTL routing	Review gates, ship gates
Methods	What’s human-led vs. encapsulated for the Agent?	Independent Evaluator	Spec sign-off, role separation
Tools	How is this codified into system behavior?	Approval + audit	Permissions, sandboxes, hooks

---

Comparison With the Original Pressman Model

Pressman original	AI4SE evolved version
A quality focus	Effectiveness Focus (Quality + Efficiency)
(none)	Harmony cross-cut (Human <-> Agent)
Process	Same name, upgraded to an auditable human-machine loop
Methods	Same name, extended with the AI4SE methodology family
Tools	Same name, includes the Agent runtime and Harness mechanisms

---

Common Anti-Patterns

Anti-pattern	Symptom	Response
Tools flying solo	Only buying Copilot/Cursor without changing review or testing	Realign value trade-offs from the Effectiveness foundation
Formalized process	Sprint/PR process exists, but no quality metrics	Quality includes Trust — requires verification evidence
Agent self-review as “done”	The same Agent that generated the work declares it complete	Harmony: an independent Evaluator
HITL theater	Every step is “approved,” but the human has no real judgment power	Real gates + action + reasoning
HITL overuse	Even reading a file requires human approval	Route by action to HOTL
Stacking methodologies	Mechanically chaining OpenSpec + Superpowers + gstack	Methods layer division: spec / discipline / delivery
Chasing local speed	Individuals get faster while system-wide MTTR worsens	Efficiency includes Value — look at end-to-end metrics

---

Relationship to the Pilot Transformation Framework

This model provides the methodological foundation for organization-level AI4SE pilots. The Three Loops model (Inner / Harness / Outer Loop) in AI4SE Pilot Transformation for Mid-to-Large R&D Organizations echoes this article’s Process × Loop routing: when designing a pilot, use Effectiveness to align value trade-offs, use Harmony to define the human-machine division of labor, and then select and implement across the Process / Methods / Tools layers.

---

References

• Roger Pressman, Software Engineering: A Practitioner’s Approach — Layered Technology
• Google DORA 2025 — AI as amplifier
• NIST AI Risk Management Framework — human oversight
• Sheridan, Telerobotics, Automation, and Human Supervisory Control (1992)
• neurals: Human-in-the-loop vs on-the-loop
• Elementum: HITL for agentic AI