✓ Human-authored analysis; AI used for formatting and proofreading.
The landscape
In the span of eighteen months, AI-assisted development went from "autocomplete for code" to "agents that build entire applications while you sleep." The architecture underneath is not complete.
The industry converged on a dominant frame: Agent = Model + Harness. The model generates. Everything else such as filesystem, sandbox, memory, context management, tools, skills, prompt engineering, loop detection is the harness. The harness serves the model. The model is the system.
Around this frame, a landscape of approaches emerged. Each one addresses a real problem. Each one works, partially, temporarily. And each one is a workaround for an architectural element nobody knows is missing because the frame has no vocabulary for elements that don't serve the model.
Here's the map.
Agent Skills
Encoded domain expertise that tells the model which tools to use, how to interpret results, and what reasoning patterns to apply. Meta's Capacity Efficiency team built the most sophisticated version: standardized tool interfaces composed with skills that capture senior engineers' investigation patterns. Same tools power offense (finding optimizations) and defense (catching regressions).
The problem they solve. Models are general-purpose. They don't know that serialization regressions should be investigated by checking recent schema changes, or that endpoint latency regressions should start with GraphQL endpoint profiling. Skills encode "how to look" so the model doesn't waste tokens discovering investigation patterns from scratch every time.
Why they fall short. Skills encode procedural knowledge of how to investigate after something went wrong. They don't encode declarative knowledge of what must be true regardless of whether anything went wrong. "Consult the top GraphQL endpoints for latency regressions" is a recipe. "Serialization functions must not exceed N milliseconds" is a rule the machine enforces before the regression exists. Skills make the model a better investigator. They don't prevent the problems the model investigates.
They're a workaround for. the missing Engine. It is declared intent in the form of specifications the system checks mechanically. Without specifications, you encode expertise as procedures. With specifications, the expertise becomes invariants the machine enforces.
Superpowers and Context Engineering
Techniques for managing the model's context window to maximize output quality. Includes: static per-repo onboarding docs (AGENTS.md, CLAUDE.md), on-demand compressed context, sub-agents that take vertical slices and build research documents, compaction strategies that summarize and restart in fresh windows. Dex's RPI protocol (Research → Plan → Implement) is the most disciplined version — staying in the "smart zone" of the context window by intentionally compacting between phases.
The problem they solve. Models degrade past roughly 40% of the context window. Too many tools, too much injected context, too much conversation history and the quality drops. Context engineering is the discipline of putting the right tokens in the window so the model produces better output.
Why they fall short. Context engineering optimizes the input to the model. It doesn't verify the output. A model with perfect context can still generate code that violates architectural boundaries, breaks implicit invariants, or produces output that's locally correct but globally inconsistent. Better input reduces the probability of wrong output. It doesn't verify the output is right. The distinction between "probably right" and "verified correct" is the distinction the approach can't cross.
They're a workaround for. the missing Casing. It is enforced module boundaries and information hiding. If the architecture had mechanical boundaries (Parnas-style modules, hexagonal architecture enforced at build time), agents wouldn't need context engineering to avoid crossing boundaries they can't see. The boundaries would be enforced by the architecture, not by carefully curating the context window.
Self-Verification and Reviewer Agents
The model reviews its own output, or a second model reviews the first. LangChain calls models "exceptional self-improvement machines" and lists self-verification as their top performance improvement. Anthropic's three-agent harness uses a separate evaluator agent with Playwright-driven testing. OpenAI runs reviewer agents in CI checking patches against documentation.
The problem they solve. Unreviewed code ships with defects. When models generate at machine speed, human review can't keep pace with review duration up 441%, zero-review merges up 31%. Some automated quality signal is better than none.
Why they fall short. Huang et al. (ICLR 2024) established that models cannot self-correct reasoning without external feedback where performance can degrade after self-correction. The same blind spots that produced the error evaluate the error as correct. Anthropic acknowledged, their evaluator is "still an LLM that is inclined to be generous towards LLM-generated outputs" and spent "several rounds" tuning the evaluator prompt to be sufficiently skeptical. A type checker doesn't need tuning to be skeptical. It doesn't form opinions. It passes or fails.
They're a workaround for. the missing Control Unit. It is an independent oracle that measures output against declared properties and issues a deterministic verdict. Self-verification substitutes a model's opinion for a mechanical check. The workaround exists because the element (independent, deterministic verification against declared intent) is absent from the architecture.
Loop Engineering and the Ralph Loop
Patterns that keep the model generating over long horizons. The Ralph Loop intercepts the model's attempt to stop, reinjects the prompt in a fresh context, and forces continued generation until a completion goal is met. Loop engineering automates this: agent writes, judge agent reviews, loop continues. The aspiration is autonomous execution "every time you must type 'continue' is a failure of the harness."
The problem they solve. Complex tasks exceed a single context window. The model stops before the work is done. Without a continuation mechanism, the human manually restarts, re-explains context, and loses progress.
Why they fall short. The loop optimizes duration of generation. The problem being solved is "the agent stopped too early." The solution is to force it to keep going. What's not being checked: whether what was generated in the last iteration was correct before starting the next one. If iteration three introduced a subtle architectural mistake, iterations four through twenty build on that mistake. A long-horizon execution loop without an independent verification gate between iterations is a mechanism for generating more wrong output, faster, with more confidence.
They're a workaround for. the missing Engine (no specification to converge toward) and the missing Control Unit (no gate between iterations). With a specification, generation converges toward a declared target instead of running indefinitely. With a verification gate, each iteration is checked before the next one builds on it. Without both, the loop is "generate more and hope it improves."
Prompt Optimization and Agent Memory
Improving model output by improving the prompt: system prompts, few-shot examples, chain-of-thought templates, memory files that persist across sessions, AGENTS.md files that encode project-specific conventions. The goal is to give the model enough context to produce better output without human intervention.
The problem they solve. Models are stateless. Without memory and carefully constructed prompts, each interaction starts from zero. Good prompts produce better output. Project-specific memory reduces the learning curve per session.
Why they fall short. A better prompt produces a better guess. It doesn't produce a verified output. "Generate code that follows our coding conventions" is a prompt. "All public functions must have error handling and all errors must be wrapped with context" is a linter rule. The prompt requests. The rule enforces. The prompt might be followed. The rule is always checked.
They're a workaround for. the missing Engine again. Prompts and memory files are proto-specifications. They have intent in them, but they're ephemeral, ambiguous, and model-interpreted. A specification is durable, precise, versioned, and mechanically checkable. Every prompt-engineering improvement is a better version of a thing that shouldn't be a prompt. It should be a declaration machines enforce.
Friday Slop Cleanup
OpenAI's Ryan Lopopolo described running a billion tokens a day through a fully agent-generated codebase and spending every Friday with 20% of engineering time is spent in manually cleaning up accumulated "AI slop." The team later tried to automate this cleanup with more agents.
The problem it solves. Agent-generated code accumulates. Not all of it belongs. Duplication, unnecessary abstractions, dead code, stylistic inconsistency. The codebase grows without any force pushing the other direction. Someone has to clean it up.
Why it falls short. Manual subtraction one day a week is a human performing a function the architecture should perform continuously. The slop was generated on Monday through Thursday. It accumulated all week. On Friday, a human manually reverses the accumulation. Next week, it accumulates again. The cleanup doesn't prevent the accumulation. It reacts to it.
It's a workaround for. the missing Casing's subtraction discipline. If the architecture included a force that asks "does this belong?" on every generation. Measured against a declared essence of the product, the slop wouldn't accumulate. The subtraction would happen continuously, at generation time, not manually, once a week, after the damage is done.
The pattern underneath
Every approach in the current landscape has the same structure:
| Approach | Real problem | Function it performs manually | Missing element |
|---|---|---|---|
| Agent Skills | Models lack domain expertise | Procedural investigation | Engine (declared invariants) |
| Context Engineering | Model degrades with bad context | Manual boundary management | Casing (enforced boundaries) |
| Self-Verification | Unreviewed code ships defects | Quality opinion from a model | Control Unit (deterministic oracle) |
| Loop Engineering | Tasks exceed one context window | Duration-based continuation | Engine + Control (spec + gate) |
| Prompt Optimization | Stateless models need context | Intent injection per session | Engine (durable specification) |
| Friday Slop Cleanup | Code accumulates without curation | Manual weekly subtraction | Casing (subtraction discipline) |
The pattern: a human or a model manually performs a function that a missing architectural element would perform mechanically. Each workaround works partially, temporarily, expensively. Each one will be replaced by the element it's substituting for.
Why the workarounds don't survive
Three forces are converging on the workarounds simultaneously:
They don't scale with generation speed. Workarounds that depend on human intervention (Friday cleanup, prompt tuning, manual context management, human review of agent output) hit the same wall the Osmani data documents: 4x code for 10% more value, reviews up 441%, 31% merged unread. Generation runs at machine speed. Workarounds run at human speed. The gap widens with every model improvement.
They cost more as models improve. A more powerful model generates more output per token. More output means more to review, more to clean up, more to verify, more context to manage. Every workaround's cost scales with the model's capability. Agentic bloat of ten thousand lines to solve a ten-line problem is a direct consequence of a powerful tool with no subtraction discipline. The inference bill is the monthly invoice for missing elements.
They have a proven mathematical ceiling. Vassilev's NIST proof (June 2026) extended Gödel's incompleteness theorems to AI systems: no finite set of guardrails is universally robust. Self-verification, prompt engineering, reviewer agents. Every approach that wraps the model in a finite set of rules has a formal ceiling. The ceiling can be raised. It cannot be removed. The workarounds are not converging toward a complete solution. They are asymptotically approaching a limit.
What aerospace figured out
NASA's Space Shuttle software flew for 30 years with a near-zero defect rate. Because the architecture was complete. Every function had the right element at the right level:
- Assertions at code level. Mechanical checks that trigger System Exceptions on failure.
- Safety Properties at design level. "Shall not" and "must always" rules enforced as invariants.
- Interface Specifications between modules. ICDs with self-checking logic that rejects violations.
- Invariants at system level. Boundary conditions that trigger immediate response on breach.
No workarounds. No Friday cleanup. No prompt tuning. No "several rounds" of calibrating the evaluator to stop praising mediocre work. Each element was mechanical, deterministic, and enforced. The workarounds were unnecessary because the elements were present.
The current agentic AI landscape is a collection of brilliant engineering teams building elaborate workarounds for elements that aerospace identified and supplied decades ago. The workarounds will be replaced. The subject of this book is what replaces them, why it works, and how to build it before the workarounds' costs exceed the value they protect.
This chapter surveys the landscape as of June 2026. The approaches described are drawn from published sources: LangChain, OpenAI, Meta, Anthropic. The five-element framework referenced throughout: Altshuller's Law of System Completeness (TRIZ), independently confirmed by Beer's Viable System Model and Nalebuff/Brandenburger's Co-opetition.
Top comments (0)