Reorganize: Move all skills to skills/ folder

- Created skills/ directory - Moved 272 skills to skills/ subfolder - Kept agents/ at root level - Kept installation scripts and docs at root level Repository structure: - skills/ - All 272 skills from skills.sh - agents/ - Agent definitions - *.sh, *.ps1 - Installation scripts - README.md, etc. - Documentation Co-Authored-By: Claude <noreply@anthropic.com>
2026-01-23 18:05:17 +00:00
parent 2b4e974878
commit b723e2bd7d
4083 changed files with 1056 additions and 1098063 deletions
--- a/skills/autonomous-loop/SKILL.md
+++ b/skills/autonomous-loop/SKILL.md
@@ -0,0 +1,234 @@
+---
+name: autonomous-loop
+description: "Autonomous Loop 'Tackle Until Solved' - Self-referential iteration agent for complex multi-step tasks. Persists work between iterations until completion criteria met."
+---
+
+# Autonomous Loop "Tackle Until Solved"
+
+Self-referential AI iteration agent that persists work and loops until task completion. Inspired by Ralph Loop methodology.
+
+## Philosophy
+
+**Iteration > Perfection.** The loop continuously refines work until success criteria are met. Each iteration sees previous work in files and can improve upon it.
+
+**Failures Are Data.** Test failures, errors, and incomplete implementations inform the next iteration.
+
+**Persistence Wins.** Keep trying until the task is complete. The loop handles retry logic automatically.
+
+## When to Use
+
+**Good for:**
+- Well-defined tasks with clear success criteria
+- Tasks requiring iteration and refinement (getting tests to pass)
+- Greenfield implementations where you can walk away
+- Tasks with automatic verification (tests, linters, build checks)
+- Architecture and system design with validation
+- Multi-step implementations (5+ steps)
+
+**Not good for:**
+- Tasks requiring human judgment or design decisions
+- One-shot operations
+- Tasks with unclear success criteria
+- Production debugging (use targeted debugging instead)
+
+## Usage
+
+```
+/autonomous-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. When all tests pass, output <promise>COMPLETE</promise>."
+```
+
+## How It Works
+
+The autonomous loop creates a self-referential feedback cycle:
+
+1. **Initialize**: Creates task file with success criteria
+2. **Iterate**: Works on task using available tools
+3. **Evaluate**: Checks completion criteria
+4. **Persist**: Saves all work to files (visible next iteration)
+5. **Repeat**: If not complete, loop continues
+
+Each iteration sees:
+- Modified files from previous attempts
+- Git history of changes
+- Test results and error messages
+- Any documentation or notes created
+
+## Completion Detection
+
+The loop exits when **ANY** of these conditions are met:
+
+1. **Completion Promise**: Output `<promise>YOUR_PHRASE</promise>` when criteria are unequivocally true
+2. **Max Iterations**: Reached iteration limit (safety mechanism)
+3. **Manual Stop**: User intervention
+
+**CRITICAL**: Never output a false completion promise. The promise statement must be completely and unequivocally TRUE.
+
+## Prompt Writing Best Practices
+
+### 1. Clear Completion Criteria
+
+**Bad**: "Build a todo API and make it good."
+
+**Good**:
+```markdown
+Build a REST API for todos.
+
+When complete:
+- All CRUD endpoints working (POST, GET, PUT, DELETE)
+- Input validation in place (required fields, data types)
+- Tests passing with >80% coverage
+- README with API documentation
+
+Output: <promise>COMPLETE</promise>
+```
+
+### 2. Incremental Goals
+
+**Bad**: "Create a complete e-commerce platform."
+
+**Good**:
+```markdown
+Build an e-commerce platform in phases:
+Phase 1: User authentication (JWT, tests)
+Phase 2: Product catalog (list/search, tests)
+Phase 3: Shopping cart (add/remove, tests)
+
+Output <promise>COMPLETE</promise> when all phases done.
+```
+
+### 3. Self-Correction Instructions
+
+**Bad**: "Write code for feature X."
+
+**Good**:
+```markdown
+Implement feature X following TDD:
+1. Write failing tests
+2. Implement feature
+3. Run tests
+4. If any fail, debug and fix
+5. Refactor if needed
+6. Repeat until all green
+7. Output: <promise>COMPLETE</promise>
+```
+
+### 4. Always Use Safety Limits
+
+```markdown
+# Use iteration limits as safety net
+Max iterations: 50
+
+# If stuck after reasonable attempts:
+- Document what's blocking progress
+- List what was attempted
+- Suggest alternative approaches
+- Output <promise>BLOCKED</promise> with details
+```
+
+## Loop Behavior
+
+### State Persistence
+
+Work persists between iterations:
+- **Files**: All created/modified files remain
+- **Git History**: Each commit is visible next iteration
+- **State File**: Tracks iteration count and status
+- **Logs**: Full history of all iterations
+
+### Self-Referential Pattern
+
+```
+Iteration 1: "Build API" → Creates files, tests fail
+Iteration 2: "Build API" → Sees files, fixes bugs, tests pass
+Iteration 3: "Build API" → Sees passing tests, adds docs
+Iteration 4: "Build API" → Verifies all criteria, outputs <promise>COMPLETE</promise>
+```
+
+The prompt NEVER changes between iterations. The agent sees its own previous work and iteratively improves.
+
+## Configuration
+
+Environment variables (optional):
+
+```bash
+# Agent selection
+LOOP_AGENT=claude|gemini|auto
+
+# Safety limits
+LOOP_MAX_ITERATIONS=100
+LOOP_MAX_RUNTIME=14400  # 4 hours in seconds
+
+# Verbosity
+LOOP_VERBOSE=true
+```
+
+## Files Created
+
+```
+.loop/
+├── PROMPT.md       # Task with success criteria
+├── config.yml      # Loop configuration
+├── state.json      # Progress tracking (iteration, status)
+└── iterations/
+    ├── 001.md      # First iteration output
+    ├── 002.md      # Second iteration output
+    └── final.md    # Final validated result
+```
+
+## Monitoring Progress
+
+While loop is running:
+```bash
+# Check current iteration
+cat .loop/state.json | jq '.iteration, .status'
+
+# View latest output
+cat .loop/iterations/final.md
+
+# See all history
+ls -la .loop/iterations/
+```
+
+## Example Tasks
+
+**API Development**:
+```
+/autonomous-loop "Build a REST API for user management. Endpoints: create, read, update, delete, list. Add input validation, error handling, and unit tests. Output <promise>ALL_TESTS_PASSING</promise> when coverage >80% and all tests green."
+```
+
+**Feature Implementation**:
+```
+/autonomous-loop "Implement real-time notifications using WebSockets. Requirements: connection management, broadcast messaging, reconnection logic, tests. Output <promise>NOTIFICATIONS_WORKING</promise> when demo succeeds."
+```
+
+**System Design**:
+```
+/autonomous-loop "Design a microservices architecture for e-commerce. Services: auth, products, orders, payments. Include API contracts, data flow diagrams, deployment strategy. Output <promise>DESIGN_COMPLETE</promise> when all services defined with integration points."
+```
+
+## Technical Details
+
+- **Pattern**: Self-referential feedback loop
+- **State**: Stored in `.loop/` directory
+- **Persistence**: File-based (git-friendly)
+- **Completion**: Promise phrase or iteration limit
+- **Inspiration**: Ralph Loop by Geoffrey Huntley
+
+## Stopping the Loop
+
+- **Natural completion**: Output promise phrase when criteria met
+- **Iteration limit**: Set `--max-iterations` for safety
+- **Manual stop**: User can interrupt at any time
+
+## Success Principles
+
+1. **Write Clear Criteria**: Ambiguity causes infinite loops
+2. **Use Safety Limits**: Always set max-iterations
+3. **Testable Goals**: Completion must be verifiable
+4. **Incremental Progress**: Break large tasks into phases
+5. **Trust the Loop**: Let iteration refine the work
+
+## References
+
+- Original technique: https://ghuntley.com/ralph/
+- Philosophy: Persistent iteration despite setbacks