{"id":"f730e9a2-f088-4954-8311-6c4aaf02e06c","entityType":"agent","slug":"clawhub-skills-aaronjmars-iterative-code-evolution","name":"iterative-code-evolution","canonicalUrl":"https://www.xpersona.co/agent/clawhub-skills-aaronjmars-iterative-code-evolution","canonicalPath":"/agent/clawhub-skills-aaronjmars-iterative-code-evolution","generatedAt":"2026-10-09T11:00:26.071Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"editorial-content","verified":true,"confidence":"high","updatedAt":"2026-04-15T00:45:39.800Z","emptyReason":null},"description":"Systematically improve code through structured analysis-mutation-evaluation loops. Adapted from ALMA (Automated meta-Learning of Memory designs for Agentic systems). Use when iterating on code quality, optimizing implementations, debugging persistent issues, or evolving a design through multiple improvement cycles. Replaces ad-hoc \"try and fix\" with disciplined reflection, variant tracking, and principled selection of what to change next. --- name: iterative-code-evolution description: Systematically improve code through structured analysis-mutation-evaluation loops. Adapted from ALMA (Automated meta-Learning of Memory designs for Agentic systems). Use when iterating on code quality, optimizing implementations, debugging persistent issues, or evolving a design through multiple improvement cycles. Replaces ad-hoc \"try and fix\" with disciplined reflecti","descriptionLabel":"Technical summary","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. Last updated 4/15/2026.","installCommand":"clawhub skill install skills:aaronjmars:iterative-code-evolution","sourceUrl":"https://github.com/openclaw/skills/tree/main/skills/aaronjmars/iterative-code-evolution","homepage":null,"primaryLinks":[{"label":"View on ClawHub","url":"https://github.com/openclaw/skills/tree/main/skills/aaronjmars/iterative-code-evolution","kind":"source"}],"safetyScore":84,"overallRank":62,"popularityScore":50,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"Systematically improve code through structured analysis-mutation-evaluation loops. Adapted from ALMA (Automated meta-Learning of Memory designs for Agentic syst"},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-04-15T00:45:39.800Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"no-adoption-signals","verified":false,"confidence":"low","updatedAt":"2026-04-15T00:45:39.800Z","emptyReason":"No source adoption metrics were available."},"stars":null,"forks":null,"downloads":null,"packageName":null,"latestVersion":null,"tractionLabel":null},"release":{"evidence":{"source":"agent-index","verified":false,"confidence":"medium","updatedAt":"2026-02-25T05:54:46.570Z","emptyReason":null},"lastUpdatedAt":"2026-04-15T00:45:39.800Z","lastCrawledAt":"2026-02-25T05:54:46.570Z","lastIndexedAt":null,"nextCrawlAt":"2026-02-26T05:54:46.570Z","lastVerifiedAt":null,"highlights":[]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install skills:aaronjmars:iterative-code-evolution","setupComplexity":"low","setupSteps":["Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.","Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data."],"contract":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-09T11:00:26.071Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-skills-aaronjmars-iterative-code-evolution/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"high","updatedAt":"2026-04-15T00:45:39.800Z","emptyReason":null},"readme":"---\nname: iterative-code-evolution\ndescription: Systematically improve code through structured analysis-mutation-evaluation loops. Adapted from ALMA (Automated meta-Learning of Memory designs for Agentic systems). Use when iterating on code quality, optimizing implementations, debugging persistent issues, or evolving a design through multiple improvement cycles. Replaces ad-hoc \"try and fix\" with disciplined reflection, variant tracking, and principled selection of what to change next.\n---\n\n# Iterative Code Evolution\n\nA structured methodology for improving code through disciplined reflect → mutate → verify → score cycles, adapted from the ALMA research framework for meta-learning code designs.\n\n## When to Use This Skill\n\n- Iterating on code that isn't working well enough (performance, correctness, design)\n- Optimizing an implementation across multiple rounds of changes\n- Debugging persistent or recurring issues where simple fixes keep failing\n- Evolving a system design through structured experimentation\n- Any task where you've already tried 2+ approaches and need discipline about what to try next\n- Building or improving prompts, pipelines, agents, or any \"program\" that benefits from iterative refinement\n\n## When NOT to Use This Skill\n\n- Simple one-shot code generation (just write it)\n- Mechanical tasks with clear solutions (refactoring, formatting, migrations)\n- When the user has already specified exactly what to change\n\n## Core Concepts\n\n### The Evolution Loop\n\nEvery improvement cycle follows this sequence:\n\n```\n┌─────────────────────────────────────────────────────┐\n│  1. ANALYZE  — structured diagnosis of current code │\n│  2. PLAN     — prioritized, concrete changes        │\n│  3. MUTATE   — implement the changes                │\n│  4. VERIFY   — run it, check for errors             │\n│  5. SCORE    — measure improvement vs. baseline     │\n│  6. ARCHIVE  — log what was tried and what happened │\n│                                                     │\n│  Loop back to 1 with new knowledge                  │\n└─────────────────────────────────────────────────────┘\n```\n\n### The Evolution Log\n\nTrack all iterations in `.evolution/log.json` at the project root. This is the memory that makes each cycle smarter than the last.\n\n```json\n{\n  \"baseline\": {\n    \"description\": \"Initial implementation before evolution began\",\n    \"score\": 0.0,\n    \"timestamp\": \"2025-01-15T10:00:00Z\"\n  },\n  \"variants\": {\n    \"v001\": {\n      \"parent\": \"baseline\",\n      \"description\": \"Added input validation and error handling\",\n      \"changes_made\": [\n        {\n          \"what\": \"Added type checks on all public methods\",\n          \"why\": \"Runtime crashes from malformed input in 3/10 test cases\",\n          \"priority\": \"High\"\n        }\n      ],\n      \"score\": 0.6,\n      \"delta\": \"+0.6 vs parent\",\n      \"timestamp\": \"2025-01-15T10:30:00Z\",\n      \"learned\": \"Input validation was the primary failure mode — most other logic was sound\"\n    },\n    \"v002\": {\n      \"parent\": \"v001\",\n      \"description\": \"Refactored parsing logic to handle edge cases\",\n      \"changes_made\": [\n        {\n          \"what\": \"Rewrote parse_input() to use state machine instead of regex\",\n          \"why\": \"Regex approach failed on nested structures (seen in test cases 7,8)\",\n          \"priority\": \"High\"\n        }\n      ],\n      \"score\": 0.85,\n      \"delta\": \"+0.25 vs parent\",\n      \"timestamp\": \"2025-01-15T11:00:00Z\",\n      \"learned\": \"State machine approach generalizes better than regex for this grammar\"\n    }\n  },\n  \"principles_learned\": [\n    \"Input validation fixes give the biggest early gains\",\n    \"Regex-based parsing breaks on recursive structures — prefer state machines\",\n    \"Small targeted changes score better than large rewrites\"\n  ]\n}\n```\n\n## The Process in Detail\n\n### Phase 1: ANALYZE — Structured Diagnosis\n\nBefore changing anything, perform a structured analysis of the current code and its outputs. This is the most important phase — it prevents wasted mutations.\n\n**Step 1 — Learn from past edits** (skip on first iteration)\n\nReview the evolution log. For each previous change:\n- Did the score improve or degrade?\n- What pattern made it succeed or fail?\n- Extract 2-3 principles to adopt and 2-3 pitfalls to avoid\n\n**Step 2 — Component-level assessment**\n\nFor each meaningful component (function, class, module, pipeline stage), label it:\n\n| Label | Meaning |\n|-------|---------|\n| **Working** | Produces correct output, no issues observed |\n| **Fragile** | Works on happy path but fails on edge cases or specific inputs |\n| **Broken** | Produces wrong output or errors |\n| **Redundant** | Duplicates logic found elsewhere, adds complexity without value |\n| **Missing** | A needed component that doesn't exist yet |\n\nFor each label, write a one-line explanation of *why* — linked to specific test outputs or observed behavior.\n\n**Step 3 — Quality and coherence check**\n\nLook for cross-cutting issues:\n- **Data flow**: Do components pass structured data to each other, or rely on implicit state?\n- **Error handling**: Are errors caught and handled, or silently swallowed?\n- **Duplication**: Is the same logic repeated in multiple places?\n- **Hardcoding**: Are there magic numbers, hardcoded paths, or environment-specific assumptions?\n- **Generalization**: Which parts would work on new inputs vs. which are overfitted to test cases?\n\n**Step 4 — Produce prioritized suggestions**\n\nBased on Steps 1-3, produce concrete changes. Each suggestion must have:\n\n```\n- PRIORITY: High | Medium | Low\n- WHAT: Precise description of the change (code-level, not vague)\n- WHY: Link to a specific observation from Steps 1-3\n- RISK: What could go wrong if this change is made incorrectly\n```\n\n**Rule: Every suggestion must link to an observation.** No \"this might help\" suggestions — only changes grounded in something you actually saw in the code or outputs.\n\n**Rule: Limit to 3 suggestions per cycle.** More than 3 changes at once makes it impossible to attribute improvement or regression to specific changes.\n\n### Phase 2: PLAN — Select What to Change\n\nPick 1-3 suggestions from the analysis. Selection principles:\n\n- **High priority first** — fix broken things before optimizing working things\n- **One theme per cycle** — don't mix unrelated changes (e.g., don't fix parsing AND refactor error handling in the same mutation)\n- **Prefer targeted over sweeping** — a surgical change to one function beats a rewrite of three modules\n- **If stuck, explore** — if the last 2+ cycles showed diminishing returns on the same component, pick a different component to modify (this is the ALMA \"visit penalty\" principle — don't keep grinding on the same thing)\n\n### Phase 3: MUTATE — Implement Changes\n\nWrite the new code. Key discipline:\n\n- **Change only what the plan says.** Resist the urge to \"fix one more thing\" while you're in there.\n- **Preserve interfaces.** Don't change function signatures or return types unless the plan explicitly calls for it.\n- **Comment the rationale.** Add a brief comment near each change referencing the evolution cycle (e.g., `# evo-v003: switched to state machine per edge case failures`)\n\n### Phase 4: VERIFY — Run and Check\n\nExecute the modified code against the same inputs/tests used for scoring.\n\n**If it crashes (up to 3 retries):**\n\nUse the reflection-fix protocol:\n1. Read the full error traceback\n2. Identify the **root cause** (not the symptom)\n3. Fix **only** the root cause — do not make unrelated improvements\n4. Re-run\n\nAfter 3 failed retries, **revert to parent variant** and log the failure:\n```json\n{\n  \"attempted\": \"Description of what was tried\",\n  \"failure_mode\": \"The error that couldn't be resolved\",\n  \"learned\": \"Why this approach doesn't work\"\n}\n```\n\nThis failure data is valuable — it prevents re-attempting the same broken approach.\n\n**If it runs but produces wrong output:**\n\nDon't immediately retry. Go back to Phase 1 (ANALYZE) with the new outputs. The wrong output is diagnostic data.\n\n### Phase 5: SCORE — Measure Improvement\n\nCompare the new variant's performance against its parent (not just the baseline). Scoring depends on context:\n\n| Context | Score Method |\n|---------|-------------|\n| Tests exist | Pass rate: tests_passed / total_tests |\n| Performance optimization | Metric delta (latency, throughput, memory) |\n| Code quality | Weighted checklist (correctness, edge cases, readability) |\n| User feedback | Binary: better/worse/same per the user's judgment |\n| LLM/prompt output quality | Sample outputs graded against criteria |\n\n**Always compute delta vs. parent.** This is how you learn which changes help vs. hurt.\n\n### Phase 6: ARCHIVE — Log and Learn\n\nUpdate `.evolution/log.json`:\n1. Record the new variant with parent, description, changes, score, delta\n2. Write a `learned` field: one sentence about what this cycle taught you\n3. If the score improved, add the underlying principle to `principles_learned`\n4. If the score degraded, add the failure mode to `principles_learned` as a pitfall\n\n## Variant Management\n\n### When to Branch vs. Modify\n\n- **Modify in place** (same file, new version): When the change is clearly incremental (fixing a bug, adding a check, tuning a parameter)\n- **Branch** (copy to a new file): When trying a fundamentally different approach (different algorithm, different architecture, different strategy)\n\nKeep branches in `.evolution/variants/` with descriptive names. The evolution log tracks which is active.\n\n### Selection: Which Variant to Iterate On\n\nIf you have multiple variants, pick the next one to improve using:\n\n```\nscore(variant) = normalized_reward - 0.5 * log(1 + visit_count)\n```\n\nWhere:\n- `normalized_reward` = variant score relative to baseline (0-1 range)\n- `visit_count` = how many times this variant has been selected for iteration\n\nThis balances **exploitation** (iterating on the best variant) with **exploration** (trying variants that haven't been touched recently). It prevents getting stuck in local optima.\n\n## Quick Reference: Analysis Template\n\nWhen performing Phase 1, structure your thinking as:\n\n```markdown\n## Evolution Cycle [N] — Analysis\n\n### Lessons from Previous Cycles\n- Cycle [N-1] changed [X], score went [up/down] by [amount]\n- Principle: [what we learned]\n- Pitfall: [what to avoid]\n\n### Component Assessment\n| Component | Status | Evidence |\n|-----------|--------|----------|\n| function_a() | Working | All test cases pass |\n| function_b() | Fragile | Fails on empty input (test #4) |\n| class_C | Broken | Returns None instead of dict |\n\n### Cross-Cutting Issues\n- [Issue 1 with specific evidence]\n- [Issue 2 with specific evidence]\n\n### Planned Changes (max 3)\n1. **[High]** WHAT: ... | WHY: ... | RISK: ...\n2. **[Medium]** WHAT: ... | WHY: ... | RISK: ...\n```\n\n## Example: Full Evolution Cycle\n\n**Context:** User asks to improve a web scraper that's failing on 40% of target pages.\n\n**Cycle 1 — Analysis:**\n- Component assessment: `parse_html()` is Broken (crashes on pages with no `<article>` tag), `fetch_page()` is Working, `extract_links()` is Fragile (misses relative URLs)\n- Cross-cutting: No error handling — one bad page kills the entire batch\n- Past edits: None (first cycle)\n- Plan: [High] Add fallback selectors in `parse_html()` for pages without `<article>`\n\n**Cycle 1 — Mutate:** Add cascading selector logic: try `<article>`, fall back to `<main>`, fall back to `<body>`.\n\n**Cycle 1 — Verify:** Runs without crashes. \n\n**Cycle 1 — Score:** Pass rate 40% → 72%. Delta: +32%.\n\n**Cycle 1 — Archive:** Learned: \"Most failures were selector misses, not logic errors. Fallback chains are high-value.\"\n\n**Cycle 2 — Analysis:**\n- Lessons: Fallback selectors gave +32%. Principle: handle structural variation before fixing logic.\n- Component assessment: `parse_html()` now Working. `extract_links()` still Fragile — relative URLs not resolved.\n- Plan: [High] Resolve relative URLs using `urljoin` in `extract_links()`\n\n**Cycle 2 — Mutate:** Add base URL resolution.\n\n**Cycle 2 — Score:** 72% → 88%. Delta: +16%.\n\n**Cycle 2 — Archive:** Learned: \"URL resolution was second-biggest failure mode. Always normalize URLs at extraction time.\"\n\n## Key Principles\n\n- **Every change must link to an observation** — no speculative fixes\n- **Max 3 changes per cycle** — attribute improvements accurately\n- **Log everything** — failed attempts are as valuable as successes\n- **Score against parent, not just baseline** — track marginal improvement\n- **Explore when stuck** — if 2+ cycles on the same component show diminishing returns, move to a different component\n- **Revert on 3 failed retries** — don't spiral; log the failure and try a different approach\n- **Principles compound** — the evolution log's `principles_learned` list is the most valuable artifact; it encodes what works for *this specific codebase*\n","readmeExcerpt":"--- name: iterative-code-evolution description: Systematically improve code through structured analysis-mutation-evaluation loops. Adapted from ALMA (Automated meta-Learning of Memory designs for Agentic systems). Use when iterating on code quality, optimizing implementations, debugging persistent issues, or evolving a design through multiple improvement cycles. Replaces ad-hoc \"try and fix\" with disciplined reflecti","codeSnippets":[],"executableExamples":[{"language":"text","snippet":"┌─────────────────────────────────────────────────────┐\n│  1. ANALYZE  — structured diagnosis of current code │\n│  2. PLAN     — prioritized, concrete changes        │\n│  3. MUTATE   — implement the changes                │\n│  4. VERIFY   — run it, check for errors             │\n│  5. SCORE    — measure improvement vs. baseline     │\n│  6. ARCHIVE  — log what was tried and what happened │\n│                                                     │\n│  Loop back to 1 with new knowledge                  │\n└─────────────────────────────────────────────────────┘"},{"language":"json","snippet":"{\n  \"baseline\": {\n    \"description\": \"Initial implementation before evolution began\",\n    \"score\": 0.0,\n    \"timestamp\": \"2025-01-15T10:00:00Z\"\n  },\n  \"variants\": {\n    \"v001\": {\n      \"parent\": \"baseline\",\n      \"description\": \"Added input validation and error handling\",\n      \"changes_made\": [\n        {\n          \"what\": \"Added type checks on all public methods\",\n          \"why\": \"Runtime crashes from malformed input in 3/10 test cases\",\n          \"priority\": \"High\"\n        }\n      ],\n      \"score\": 0.6,\n      \"delta\": \"+0.6 vs parent\",\n      \"timestamp\": \"2025-01-15T10:30:00Z\",\n      \"learned\": \"Input validation was the primary failure mode — most other logic was sound\"\n    },\n    \"v002\": {\n      \"parent\": \"v001\",\n      \"description\": \"Refactored parsing logic to handle edge cases\",\n      \"changes_made\": [\n        {\n          \"what\": \"Rewrote parse_input() to use state machine instead of regex\",\n          \"why\": \"Regex approach failed on nested structures (seen in test cases 7,8)\",\n          \"priority\": \"High\"\n        }\n      ],\n      \"score\": 0.85,\n      \"delta\": \"+0.25 vs parent\",\n      \"timestamp\": \"2025-01-15T11:00:00Z\",\n      \"learned\": \"State machine approach generalizes better than regex for this grammar\"\n    }\n  },\n  \"principles_learned\": [\n    \"Input validation fixes give the biggest early gains\",\n    \"Regex-based parsing breaks on recursive structures — prefer state machines\",\n    \"Small targeted changes score better than large rewrites\"\n  ]\n}"},{"language":"text","snippet":"- PRIORITY: High | Medium | Low\n- WHAT: Precise description of the change (code-level, not vague)\n- WHY: Link to a specific observation from Steps 1-3\n- RISK: What could go wrong if this change is made incorrectly"},{"language":"json","snippet":"{\n  \"attempted\": \"Description of what was tried\",\n  \"failure_mode\": \"The error that couldn't be resolved\",\n  \"learned\": \"Why this approach doesn't work\"\n}"},{"language":"text","snippet":"score(variant) = normalized_reward - 0.5 * log(1 + visit_count)"},{"language":"markdown","snippet":"## Evolution Cycle [N] — Analysis\n\n### Lessons from Previous Cycles\n- Cycle [N-1] changed [X], score went [up/down] by [amount]\n- Principle: [what we learned]\n- Pitfall: [what to avoid]\n\n### Component Assessment\n| Component | Status | Evidence |\n|-----------|--------|----------|\n| function_a() | Working | All test cases pass |\n| function_b() | Fragile | Fails on empty input (test #4) |\n| class_C | Broken | Returns None instead of dict |\n\n### Cross-Cutting Issues\n- [Issue 1 with specific evidence]\n- [Issue 2 with specific evidence]\n\n### Planned Changes (max 3)\n1. **[High]** WHAT: ... | WHY: ... | RISK: ...\n2. **[Medium]** WHAT: ... | WHY: ... | RISK: ..."}],"parameters":{},"dependencies":[],"permissions":[],"extractedFiles":[],"languages":["typescript"],"docsSourceLabel":"CLAWHUB","editorialOverview":"Systematically improve code through structured analysis-mutation-evaluation loops. Adapted from ALMA (Automated meta-Learning of Memory designs for Agentic systems). Use when iterating on code quality, optimizing implementations, debugging persistent issues, or evolving a design through multiple improvement cycles. Replaces ad-hoc \"try and fix\" with disciplined reflection, variant tracking, and principled selection of what to change next. --- name: iterative-code-evolution description: Systematically improve code through structured analysis-mutation-evaluation loops. Adapted from ALMA (Automated meta-Learning of Memory designs for Agentic systems). Use when iterating on code quality, optimizing implementations, debugging persistent issues, or evolving a design through multiple improvement cycles. Replaces ad-hoc \"try and fix\" with disciplined reflecti","editorialQuality":{"score":100,"threshold":65,"status":"ready","wordCount":426,"uniquenessScore":63,"reasons":[]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-04-15T00:45:39.800Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-04-15T00:45:39.800Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-09T11:00:26.071Z","emptyReason":null},"items":[{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-10T18:48:31.762Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}