Agentic Engineering Loops, Harnesses, and the Software Factory (for . .) (Addy Osmani)（Z-Library）

# Agentic Engineering: Loops, Harnesses, and the Software Factory ## 【One-Line Pitch】 A practical field guide for engineers who already use coding agents and want to move from "vibe coding" to disciplined, accountable agentic engineering—covering everything from individual workflow calibration to running a full software factory. If you've ever wondered when to delegate, when to hover, and how to keep quality high when agents write most of the code, this book gives you durable patterns that outlive any specific tool. ## 【Book Arc】 - **Opening (~0%–9%)**: Defines vibe coding (Karpathy's original meaning: disposable, throwaway work) and contrasts it with agentic engineering. Introduces the core problem: agents can write code, but who owns what happens next? Sets up the inner loop (write-run-adjust) versus outer loop (review-integrate-ship-accountability) distinction. - **Early (~9%–28%)**: Establishes the five-zone spectrum from pure vibe coding to "the fleet" of parallel agents, then introduces the Four Pillars—Plan, Direct, Test, Own—as the unglamorous habits that separate reliable agent work from expensive messes. Covers three generations of tools (autocomplete, synchronous agents, autonomous loops) and why they layer rather than replace each other. - **Early (~28%–38%)**: Explores the human side: who benefits and who's at risk, the orchestration tax (more decisions per hour, not fewer), and the seductive trap of approving agent output that "looks right." Introduces the core discipline: match autonomy to what you can verify, per task. - **Middle (~38%–47%)**: Replaces single ladders (Yegge's eight levels, Shapiro's five levels) with a two-axis map: autonomy per agent versus orchestration (how many agents run in parallel). Argues these are independent variables—getting better at one doesn't help the other. - **Middle (~47%–53%)**: Begins detailing the map's stages and the trust gradient, showing how autonomy is earned through stopping conditions and verification, not granted by default. Sets up the rest of the book's chapter-by-chapter pattern coverage. ## 【Key Takeaways】 - **The inner loop got cheap; the outer loop is now the bottleneck** (Early): Writing code and running it takes minutes with agents, so the real work—review, integration, verification, accountability—moved outward. Teams that skip this outer loop pay the bill later, not in week one. - **Five zones, not one binary** (Early): From pure vibe coding (no spec, no review, no tests) through assisted vibe coding, professional work, full agentic engineering, and "the fleet" of parallel agents. The most dangerous failure is sitting in zone 3 while believing you're in zone 4—code looks clean, tests pass, but no real spec exists underneath. - **The Four Pillars compound and fail together** (Early): Plan (write a spec before prompting), Direct (review diffs with senior-PR rigor), Test (the agent that did the work never decides the work is good—use separate verifier agents), Own (keep CI gated with a team that answers for it). Build them in reverse when starting fresh: tests and CI first, then ownership, then intent and direction. - **Autonomy tracks who gets hurt when it's wrong** (Middle): Grant autonomy per task based on blast radius and answerability, not technical difficulty. Large migrations on unlaunched projects get high autonomy (cheap oracles: does it build, does it typecheck); client production gets short loops and no unattended merges because someone must explain what changed months later. - **Ladders hide two independent variables** (Middle): Autonomy per agent (how far one agent goes before needing you) and orchestration (how many agents run at once, who coordinates them) are separate axes. Yegge's and Shapiro's ladders compress both into one line, making "moving up" look like uniform progress when it isn't. - **Diverse review logic beats any single reviewer** (Early): In a comparison across 146 PRs, 93.4% of issues were caught by exactly one of four review tools—none caught all. Two mediocre reviewers with different blind spots outperformed one good one. Cross-model review (one vendor writes, another critiques) surfaces bugs where disagreements hide. - **The orchestration tax is real** (Early): The load moves; it doesn't shrink. More agents mean more diffs, more threads, more decisions per hour—your reach is bounded by your bandwidth, not your agent count. The defense against the "seductive trap" of approving plausible-looking output is structure (tests, gates, second opinions), not willpower. ## 【Reading Tips】 - **Deep-read Chapters 1–2** (the opening ~47%): These establish the conceptual foundation—the five zones, Four Pillars, and two-axis map—that every later chapter builds on. The zone self-assessment and the autonomy/orchestration distinction are worth internalizing before reading further. - **Skim the tool-specific examples**: The author explicitly says products and numbers are illustrations of patterns, not the point. When you see Cursor, Claude Code, or Codex mentioned, focus on the underlying pattern (e.g., "hand-rolled bash loops became loop primitives") rather than the specific tool. - **Watch for the personal near-miss stories**: The competitor-PR incident (nearly pushing code without reading implementations) and the mobile-vs-desktop verification catch are concrete illustrations of the Four Pillars failing and succeeding. These anchor the abstract advice. - **Treat the chapter list as a roadmap**: The table of contents (Chapters 3–18) previews where the book goes: harness anatomy, context engineering, specs, skills, orchestration, subagents, long-running agents, the software factory, loop engineering, quality gates, agent-ready codebases, the orchestration tax, the three debts, and workflow craft. Use it to jump to your pain point. - **Expect tool churn**: The author notes he rewrites tools nearly monthly—the durable patterns compound while products churn. Read for the patterns (specs, verification separation, autonomy calibration) and expect to translate them to whatever tools you use. ## 【Coverage Limits】 This guide covers the available early-release material (Chapters 1–2 and the opening of Chapter 3). The excerpts do not cover the book's later chapters on skills authoring, subagent teams, long-running agents, the software factory operating model, loop engineering, quality gates, agent-ready codebases, the orchestration tax, the three debts, or workflow craft—these are listed in the table of contents but their content is not yet available in this sample. ##