robust-first
Survive first. Be correct later.
When & Why to Use This Skill
This Claude skill implements the 'Robust-First' computing principle, prioritizing system survivability and continuous operation over immediate perfect correctness. It provides a framework for building fault-tolerant AI agents that can handle errors gracefully, perform local self-repairs, and maintain functionality in unreliable environments, effectively preventing system crashes and ensuring long-term resilience.
Use Cases
- Automated Error Recovery: Instead of halting when encountering a malformed configuration or corrupted file, the system automatically loads the last known good state or uses reasonable defaults to continue operation.
- Graceful Degradation: In resource-constrained environments or during partial system failures, the agent prioritizes mission-critical tasks and disables non-essential features to remain functional.
- Self-Healing State Management: Automatically reconciling data inconsistencies between different sources (e.g., database records vs. session logs) without requiring manual developer intervention.
- Resilient Tool Integration: Enhancing agent reliability by implementing 'best-effort' parsing and fallback logic when external APIs or tools return unexpected or malformed data.
- Anti-Fragile Learning: Capturing logs of repairs and errors to evolve system schemas and logic, making the system stronger and more prepared for future failures.
| name | robust-first |
|---|---|
| description | "Survive first. Be correct later." |
| license | MIT |
| tier | 1 |
| related | [moollm, self-repair, postel, coherence-engine, honest-forget] |
| tags | [moollm, survival, resilience, graceful, degradation] |
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