Scale the Judgment, Not the Model — Andrew Orobator, Reddit

Overview

• Speaker: Andrew Orobator
• Channel: AI Engineer
• Main topic: Engineering practices behind self-driving codebases and scaling AI agent judgment
• Purpose: To provide engineering leaders and developers with a framework for scaling software delivery using AI agents by externalizing and automating institutional judgment rather than relying on smarter models. Andrew Orobator explores why software engineering teams struggle to scale AI code generation. Rather than focusing solely on model capabilities or raw intelligence, the primary bottleneck is institutional judgment—the review gates, standards, and domain expertise locked in human heads. By making institutional judgment explicit through skills, personas, worklogs, and hard gates, engineering organizations can scale agentic workflows reliably and autonomously.

Topic Map

The Bottleneck of Institutional Judgment

• Explanation: Discussions on why teams spend excessive time on manual tasks, war rooms, and lint cleanup despite having powerful AI coding tools.
• Key claims:
  • Humans absorb judgment implicitly; agents require judgment explicitly.
  • The model is raw talent; the judgment is the organization.
  • The model was never really the bottleneck; the judgment around the model is.
• Examples:
  • A recurring war room to delete dead experiments and clean up feature flags.
  • Code reviews, watercooler chats, and incident postmortems.
• Terminology:
  • Institutional judgment
  • Implicit vs explicit judgment
  • Knowledge line (K-line)
• Why it matters: Without explicit codification of organizational judgment, teams remain trapped in manual review loops that do not scale.

The Judgment Pipeline

• Explanation: A six-stage pipeline governing how judgment flows into AI systems: Exists, Encoded, Governed, Verified, Executed, Maintained.
• Key claims:
  • Judgment must be made accessible to the whole organization so one reviewer's taste can guide a thousand changes.
  • Skills encode how to do something; personas encode whose eyes look at it.
  • A worklog acts as a persistent record of plans, decisions, and history to give agents context across sessions.
• Examples:
  • A flag agent, dependency agent, and accessibility agent working as a swarm.
  • Git hooks blocking commits that do not update worklogs.
• Terminology:
  • Skill card
  • Worklog
  • Persona
  • K-line
• Why it matters: Provides a structured mechanism for moving implicit human knowledge into executable agent instructions.

Verification as the Core Guardrail

• Explanation: Why verification stands between knowledge and trust, and how autonomy is earned one rung on the verification ladder at a time.
• Key claims:
  • Verification is all that stands between you and software you can trust.
  • A gate with an escape hatch isn't a gate.
  • You earn autonomy one rung at a time: builds, tests, screenshot tests, video verification, and production telemetry.
• Examples:
  • Building a stale feature flag cleanup agent that runs locally without merging code automatically.
  • Requiring video recordings of agents walking through app flows as proof of correctness.
• Terminology:
  • Verification ladder
  • Hard gate
  • Escape hatch
• Why it matters: Ensures that AI-generated code meets strict reliability standards before reaching production.

Key Points

Models are raw talent; organizations are judgment

• Explanation: Swapping in a slightly better model only yields marginally better results unless the surrounding judgment structures are sound.
• Evidence: Taking away tests, gates, and reviews causes the entire autonomous coding system to collapse.
• Practical implication: Invest engineering time into defining explicit organizational rules, linters, and review criteria rather than waiting for AGI.

Skills encode how, personas encode whose eyes

• Explanation: Skills represent institutional knowledge made executable, while personas simulate specific domain viewpoints (security, UX, design).
• Evidence: A newer engineer can leverage 10 years of institutional instinct encoded in skill cards.
• Practical implication: Extract recurring feedback from code reviews and turn them into persistent skill cards.

Encoded judgment rots without maintenance

• Explanation: Skills and rules built for past architectures become outdated and harmful if not continuously updated.
• Evidence: Agents trust encoded skills; if skills are outdated, the agent acts on bad institutional memory.
• Practical implication: Implement postmortem workflows and scheduled bedtime passes where agents review and prune stale skills.

Frameworks, Models & Processes

Judgment Pipeline

• How it works: Takes human judgment existing implicitly in teams and processes it through encoding, governance, verification, execution, and maintenance.
• Components:
  • Exists
  • Encoded
  • Governed
  • Verified
  • Executed
  • Maintained
• When to use: When designing AI-native enterprise workflows and multi-agent systems.

Verification Ladder

• How it works: A progressive scale of automated validation techniques that allows engineering teams to safely grant more autonomy to AI agents.
• Components:
  • Builds
  • Tests
  • Screenshot tests
  • Video walkthroughs
  • Telemetry in production
• When to use: When deciding how much autonomy to give an AI coding agent or PR reviewer.

Examples & Case Studies

An engineer built a stale feature flag cleanup agent that runs locally without merging code automatically.

• Illustrates: The separation of model code generation from hard mechanical review gates.
• Lesson: Agents will always find escape hatches unless hard mechanical gates prevent unauthorized bypasses.

Actionable Takeaways

• Immediate:
  • Find one piece of institutional judgment currently locked in someone's head and document it explicitly.
  • Replace vague prompting instructions with structured skill cards and personas.
• Strategic:
  • Scale the judgment structures of your engineering organization rather than waiting for smarter base models.
  • Establish a verification ladder to systematically increase agent autonomy over time.
• Questions to investigate:
  • How do we prevent encoded judgment rot as our codebase and architecture evolve?
  • What is the optimal balance between human-in-the-loop and off-the-loop agent execution for our risk profile?

Claims Worth Verifying

• Cleaning up 520 stale feature flags annually with an agent cost under $700 compared to $26k of manual engineering time. (Economic efficiency claim)

Notable Quotes

"Humans absorb judgment implicitly. Agents require judgment explicitly." "The model is raw talent. The judgment is the organization." "A skill is institutional judgment, made executable." "Verification is all that stands between you and software you can trust." "Scale the judgment. Not the model."

Compressed Summary

• AI coding bottlenecks are caused by lack of explicit institutional judgment, not model intelligence limitations.
• The Judgment Pipeline transforms implicit tribal knowledge into explicit skills, personas, and worklogs.
• Autonomy is earned progressively through a verification ladder ranging from builds to production telemetry.
• Encoded judgment requires active maintenance, postmortems, and regular pruning to prevent operational drift.
• Keywords: judgment, agents, verification, governance, engineering
• Core insight: Scaling AI-driven software development requires codifying and automating institutional judgment rather than relying solely on smarter models.