Self Correcting Loop

Self-Correcting Loop

This skill runs an iterative fix → verify → fix cycle on ABAP code until all quality gates pass. It does not stop after one fix attempt — it loops until the code is syntax-clean, ATC-clean, test-passing, and successfully activated.

Iron Laws

1. NEVER DECLARE SUCCESS AFTER ONE FIX. A fix that resolves one error often introduces another. Always re-run the full verification after every fix. The loop is: fix → full check → assess → repeat.

2. NEVER FIX MORE THAN ONE ISSUE AT A TIME. Batch fixes create cascading failures that are impossible to debug. Fix the first error, verify, then fix the next. Surgical precision, not shotgun patches.

3. ALWAYS TRACK FIX HISTORY. Every fix attempt is logged with: what was wrong, what was changed, and whether the check passed. This prevents circular fixes (fixing A breaks B, fixing B breaks A).

4. STOP AFTER 10 ITERATIONS. If 10 fix cycles cannot resolve the issue, the problem is architectural, not syntactical. Escalate to the user with the fix history — do not loop forever.

5. NEVER WEAKEN THE CHECK TO PASS THE GATE. If ATC flags a finding, fix the code — do not suppress the finding. If a test fails, fix the logic — do not delete the test. Weakening gates is not fixing.

Rationalization Table

Red Flags

• "This should fix everything..." → Iron Law 2. Fix one thing. Check. Then next.
• "Let me just suppress this warning..." → Iron Law 5. Fix the code.
• "Almost there, one more round..." → Check iteration count. If > 10, stop.
• "The test is too strict..." → The test is the specification. Fix the code.

Loop Protocol

INITIALIZE
  → Define check suite: [syntax_check, atc_check, unit_tests, activation]
  → Initialize fix history: []
  → Set iteration = 0, max_iterations = 10

LOOP
  → iteration += 1
  → IF iteration > max_iterations: ESCALATE to user with fix history
  
  → RUN check suite
  → IF all checks pass: EXIT loop → SUCCESS
  
  → IDENTIFY first failing check
  → ANALYZE root cause of failure
  → APPLY single targeted fix
  → LOG fix to history: { iteration, error, fix_applied, files_changed }
  
  → GOTO LOOP

EXIT
  → Produce loop summary (iterations, fixes applied, final status)

Check Suite Details

Syntax Check:

• Run ABAP syntax check on all modified objects
• Parse error messages for line number and error type
• Common fixes: missing declarations, type mismatches, obsolete statements

ATC Check:

• Run ATC with project check variant (Cloud or Standard)
• Categorize findings: P1 (must fix), P2 (should fix), P3 (consider)
• P1 and P2 must be resolved. P3 are documented but not blocking.

Unit Tests:

• Execute all test classes for modified objects
• Parse test results for: pass, fail, error, skip
• All tests must pass. Failed tests trigger code fix (not test deletion).

Activation:

• Activate all objects in dependency order (interfaces → classes → views)
• Handle dependent object activation failures
• Verify no remaining inactive objects in the transport

Fix History Template

SELF-CORRECTING LOOP — FIX HISTORY
====================================
Object: [Object name]
Started: [Timestamp]
Check Suite: [syntax, atc, unit_tests, activation]

Iteration 1:
  Error: [Error description]
  Root Cause: [Analysis]
  Fix: [What was changed]
  Files: [Modified files]
  Result: [Pass/Fail — which check]

Iteration 2:
  ...

FINAL STATUS: ✅ ALL CHECKS PASS (iteration [N]) / ❌ ESCALATED (iteration 10)
Total fixes applied: [N]

Verification

This skill is complete ONLY when ALL of the following are true:

• All checks in the check suite pass
• Fix history is complete with every iteration logged
• No ATC findings were suppressed (all were fixed)
• No tests were deleted or weakened
• Loop completed within 10 iterations OR escalated to user

Evidence required: Fix history log, final check suite results (all green).

Next Skill

After completing this skill, return to the invoking skill (typically autopilot or code-generation) and continue the pipeline.

Cross-References

• autopilot — Primary invoker of this skill
• code-generation — May invoke when generated code has issues
• code-review — May invoke when review findings need fixes
• troubleshooting — Invoke if the error is a runtime issue, not a compile-time issue