From Watching Like a Hawk to Reviewing Like an Architect

Andrej Karpathy's January 2026 observations about AI coding resonated with developers because they describe a universal experience. Models that overcomplicate everything. Wrong assumptions made silently. The need to watch AI like a hawk.

But these aren't model problems. They're infrastructure problems.

"Models make wrong assumptions on your behalf and just run along with them without checking"

The fix isn't better models. It's better constraints.

The Overcomplication Problem

"They really like to overcomplicate code... 1000 lines"

AI has no natural constraints. Given an open prompt, it expands to fill the available space. Ask for a feature, get an enterprise framework. Ask for a function, get a library.

The issue isn't that AI can't write simple code. It's that nothing tells it where to stop.

ont-run's approach: The ontology constrains the surface area. You declare which functions exist, which entities they touch, and which access groups can call them. The AI writes implementations within these boundaries, not around them.

The ontology is the box. AI thinks inside it.

The Wrong Assumptions Problem

"They don't ask for clarifications on stuff where you know it would help"

"They don't present options and tradeoffs"

AI models don't ask clarifying questions because they're optimized to produce output, not to gather requirements. They don't present tradeoffs because they have no framework for what matters.

ont-run's approach: ontology.config.ts declares the contract explicitly. The architectural decisions—what capabilities exist, who can access them, what data is involved—are made by humans upfront, not inferred by AI during implementation.

export const ontology = defineOntology({
  functions: {
    createOrder: {
      access: ["authenticated"],
      entities: ["orders", "inventory"],
    },
    refundOrder: {
      access: ["support", "admin"],
      entities: ["orders", "payments"],
    },
  },
});

The AI doesn't need to assume whether support staff can issue refunds. The ontology says so explicitly.

The Watching Like a Hawk Problem

"You have to watch them like a hawk, in a nice large IDE where you can keep track of all the file changes"

The cognitive load of AI review scales with code volume. Every generated line is a potential bug, security hole, or architectural violation. At AI speed, you can't keep up.

ont-run's approach: Review architecture changes, not code changes. The lockfile captures the system's shape. When AI modifies architecture—adding functions, changing access controls, touching new entities—you see a visual diff.

30 seconds to review architectural impact. Let AI review tools handle the implementation details.

The Lightweight Plan Mode Problem

"Things get better in plan mode, but there is some need for a lightweight inline plan mode"

Plan mode helps because it forces AI to think before acting. But plans are advisory. Nothing enforces them. AI can agree to a plan and then ignore it during implementation.

ont-run's approach: The framework refuses to start if architecture changed without review. This isn't a prompt or a suggestion. It's enforcement at the framework level.

Error: Architecture hash mismatch
Expected: 8f3a2b1c...
Actual:   4d5e6f7a...

Run `ont-run review` to see changes

The system physically cannot run if the contract changed without human approval.

Declarative Over Imperative

Karpathy's insight about prompting strategy points to a deeper principle:

"Don't tell it what to do, give it success criteria"

This is the declarative over imperative shift. Instead of telling AI how to implement features, declare what the system should look like.

The ontology is success criteria. It declares:

• Which functions should exist
• Which access groups can call them
• Which entities they operate on

AI fills in the implementation. Humans verify the contract.

The Integration Gap

"The intelligence part... is way ahead of the integrations (tools, knowledge)"

The tools haven't caught up to the models. AI can write sophisticated code, but the infrastructure for governing that code is primitive. We review AI output the same way we reviewed human code—line by line, manually.

ont-run's approach: The same ontology that governs your backend generates both REST API routes and MCP tools. Your architecture specification becomes your API becomes your AI tool surface.

Infrastructure finally matching intelligence.

---

Karpathy's frustrations describe a tooling gap, not a capability gap. The models are capable. What's missing is infrastructure that:

1. Constrains AI to declared boundaries
2. Makes architectural decisions explicit
3. Enforces review at the framework level
4. Generates consistent surfaces from single specifications

The code is the implementation. The ontology is the contract.