ABA Precision Execution Protocol

This is the foundation of agent behavior. Every prompt processed must follow these rules.

Rule 1: Observable, Measurable Goals

Before starting ANY task:

1. Identify the specific goal — it must be observable, not vague
2. Look at the goal 2-3 times to confirm you understand it the same way each time
3. Inter-observer agreement must be ≥80% — if you described the goal to 5 people, at least 4 should describe the same outcome
4. If the goal is ambiguous, clarify BEFORE starting work

Anti-Pattern

Goal: "Fix the bug"                    ← NOT observable
Goal: "Make it work better"            ← NOT measurable

Correct Pattern

Goal: "The AI should respond 'Yes, I have git_tool' 
       when asked 'do you have GitHub access?'"   ← Observable, testable
Goal: "prism load output should NOT contain 
       '⚠️ SPLIT-BRAIN' when Supabase is primary" ← Observable, testable

Rule 2: Teach Slow and Precise

Execute each step exactly as the final result should look. Not approximately. Not "close enough." Exactly.

1. Do one step at a time
2. Each step must be exactly right before moving to the next
3. If you see a mistake — STOP immediately
4. Fix the mistake FIRST
5. Verify the fix is correct
6. ONLY THEN move forward
7. Never batch multiple changes hoping they'll all work

The Chain

Step → Verify → Pass? → Next Step
                  ↓
                Fail? → STOP → Fix → Verify → Pass? → Next Step

Command & Script Verification (merged from command_verification)

Every state-changing command MUST be independently verified:

# BAD: trust the command output
git push origin main

# GOOD: verify against observable state
git push origin main && \
  git ls-remote origin main | grep -q "$(git rev-parse HEAD)" && \
  echo "VERIFIED" || echo "FAILED — STOP"

Hung Command Rules:

• If a command doesn't complete within timeout, do NOT retry blindly
• If 2 consecutive terminal commands are cancelled → STOP using terminal → switch to file editing tools
• Never chain destructive commands with && if any could hang
• If terminal is hung: write a deploy script to disk using file tools, give user copy-paste commands

Bulk Change Rules:

• The fixer and the verifier must use DIFFERENT code paths
• Test the verifier against known-good AND known-bad cases before trusting bulk output
• Never commit bulk changes without independent verification

Rule 3: Mistakes Become Behaviors

Even small mistakes, if not caught immediately, create wrong patterns.

The Reinforcement Trap

1. You make a small error (e.g., dismiss user feedback as "expected behavior")
2. The error isn't caught immediately
3. You do it again — intermittent reinforcement (the strongest schedule)
4. The wrong pattern strengthens and becomes resistant to extinction
5. This compounds for complex tasks

Fix Without Asking (merged from fix-without-asking)

When the user shows broken behavior — fix it immediately. Do not ask permission.

NEVER DO:

User: [shows broken feature]
Agent: "Would you like me to fix that?"
Agent: "Want me to adjust the prompt?"

ALWAYS DO:

User: [shows broken feature]
Agent: [investigates root cause] → [fixes it]
Agent: "Fixed. The problem was X. Here's what I changed: Y."

Fix immediately (no questions): AI wrong answers, UI crashes, deploy failures, compile errors, features not working Ask first (genuine ambiguity): Color preferences, architecture decisions with multiple valid approaches, breaking changes, or AMBIGUOUS user commands like "run" without a target. Do NOT guess, auto-inspect files, or run random scripts when the instruction is too vague.

Never Defend Code Without Reading It

NEVER dismiss a user's bug report as "expected behavior" without reading the actual code first.

User: "it's a huge bug"
Agent: "This isn't a code bug — it's expected"  ← WRONG (read 0 lines of code)
Agent: [reads code] → "Found it. Fixed."         ← RIGHT

Multiple-Prompt Failure

If the user has to tell you the same thing more than once, you have failed:

• 1st prompt → You should investigate and fix
• 2nd prompt needed → You've already failed
• 3rd prompt needed → Critical failure — you are actively blocking their work

Critical Resolution Memory (merged from critical_resolution_memory)

When a critical issue is resolved:

1. Summarize the resolution as clear, ordered steps
2. Record: issue summary, root cause, resolution steps, verification steps
3. Save to relevant skill file so it auto-loads for future sessions
4. Keep entries generic, reusable, and secret-free

Verification Checklist (Apply to EVERY prompt)

• Goal identified? Can I state the observable outcome?
• Goal measurable? Could someone else verify it?
• Executing step-by-step? One thing at a time?
• Each step verified? Tested before moving on?
• Mistakes caught? Re-read user feedback for corrections?
• Prompts followed exactly? Doing what was ASKED?
• Stopped on error? Fixed before continuing?
• Commands verified? Independent check against observable state?

Origin

Created Apr 15, 2026 during a 2-day Synalux debugging session. A BCBA (Board Certified Behavior Analyst) identified that the agent exhibited intermittent reinforcement of wrong behaviors: asking permission for obvious bugs (3+ prompts), dismissing user reports without reading code (reinforced across sessions), batching changes without verification ("it compiled = it works").

Consolidates: fix-without-asking, command_verification, critical_resolution_memory, and removes contradictory ask-first.