Robust-First Skill | Agent Skills

Robust-First

"Survive first. Be correct later."

What Is It?

Robust-First is Dave Ackley's principle: systems should prioritize survivability over correctness.

A system that crashes when confused is useless. A system that limps along incorrectly but keeps running can be repaired.

The Philosophy

Traditional computing:

IF error THEN crash
"Fail fast and loud"

Robust-first computing:

IF error THEN repair_locally AND continue
"Stay alive and heal"

Core Principles

1. Never Crash

# WRONG
if missing_field:
    raise Error("Field required!")
    
# RIGHT  
if missing_field:
    log_warning("Field missing, using default")
    field = reasonable_default

2. Local Repair

Don't wait for global consistency. Fix what you can, where you are:

# Found inconsistency
character.location: room-A
room-A.occupants: [not including character]

# Local repair
room-A.occupants.append(character)
log: "Repaired: added character to room-A occupants"

3. Degrade Gracefully

When resources are limited, do less but keep working:

# Full capability
- semantic search
- syntax highlighting  
- auto-complete
- error detection

# Degraded (low memory)
- basic search only
- plain text
- manual completion
- errors on save only

4. Redundancy

Important state exists in multiple places:

# Character location recorded in:
- character.yml → location field
- room/ROOM.yml → occupants list
- session-log.md → movement events

# If one is corrupted, recover from others

The Movable Feast Machine

Dave Ackley's Movable Feast Machine (MFM):

Computation spread across unreliable substrate
No global clock, no central control
Elements repair themselves and neighbors
Errors are normal, not exceptional

MOOLLM inherits this:

Files can be corrupted — repair from redundancy
Schemas can drift — reconcile gracefully
Context can overflow — summarize and continue
Tools can fail — retry or work around

Anti-Fragility

Beyond robust — anti-fragile:

| Fragile | Robust | Anti-Fragile | |---------|--------|--------------| | Breaks under stress | Survives stress | Gets stronger from stress | | Crash on error | Handle error | Learn from error | | Rigid schema | Flexible schema | Schema evolves from errors |

When something goes wrong, capture the lesson:

# Error occurred
repair_log:
  - issue: "Character teleported without movement event"
    repair: "Added movement event retroactively"
    lesson: "Always log movements before updating location"
    
# Next time: system knows to check this

MOOLLM Application

Self-Repair Demon

A background process that:

Scans for inconsistencies
Attempts local repairs
Logs what it fixed
Escalates what it couldn't

See: self-repair/

POSTEL for Errors

When encountering malformed input:

Try to parse anyway
Infer missing parts
Flag assumptions
Continue working

See: postel/

Never Delete

Instead of deleting, archive:

Corrupted files → .archive/corrupted/
Old versions → .archive/versions/
Failed attempts → .archive/failed/

Recovery is always possible.

Example: Corrupted Room

# room/ROOM.yml has parse error

Traditional response:
  "Error: Invalid YAML at line 42"
  [System halts]

Robust-first response:
  "Warning: ROOM.yml has syntax error"
  "Attempting recovery..."
  "- Loaded last known good state from git"
  "- Merged recent changes from session-log.md"
  "- Flagged line 42 for manual review"
  [System continues with recovered state]

Dovetails With

Sister Skills

self-repair/ — Checklist-based healing
postel/ — Charitable interpretation

Kernel

kernel/self-healing-protocol.md — Full specification

Protocol Symbols

ROBUST-FIRST   — Survive over correct
NEVER-CRASH    — Always keep running
REPAIR-DEMON   — Background fixer
BEST-EFFORT    — Do what you can
NEVER-DELETE   — Archive, don't destroy

See: PROTOCOLS.yml

Agent Skills: Robust-First

Install this agent skill to your local

Skill Files