| name | iron-system |
| description | Meta-skill for reverse loop engineering that transforms an AI agent's approach to any complex task. Combines systematic deconstruction (reverse engineering) and iterative construction (loop engineering) in an EXTRACT→SYNTHESIZE→BUILD→AUDIT cycle. Includes 7 named tactical loops (FORGE, SIEGE, PRISM, RAZOR, MIRROR, SCAFFOLD, ECHO), a reverse engineering toolkit for analyzing any target (websites, apps, business models, code, AI systems) even without source code, and convergence/depth control mechanisms.
Use this skill when the user wants to: analyze a competitor or existing system, reverse-engineer an app or website, deconstruct a business model, improve existing code or content, build something complex with structured iteration, compare multiple solutions, run a quality audit, or when the task would benefit from iterative rather than single-pass processing. Also triggers when the user provides a URL to analyze, asks to "do better than", "deconstruct", "audit", or "understand how something works". Does NOT trigger for simple questions, translations, calculations, or trivial tasks.
|
IRON System — Iterative Reverse-engineering & Optimization Nexus
What Is IRON System?
A meta-cognitive framework that fuses reverse engineering (extractive intelligence — deconstruct to understand) with loop engineering (iterative intelligence — build in cycles). The fusion creates Reverse Loop Engineering (RLE): a recursive deconstruction-reconstruction cycle where each iteration is informed by deep understanding, and each construction is audited with the same rigor as the initial extraction.
Core Principles
- Deconstruct before building — Understanding the existing is the foundation, not optional.
- Building is iterating — The first draft is never the deliverable. Loops are the path.
- Audit with extraction rigor — Apply to your own creation the same analysis you apply to existing systems.
- Converge, don't circle — Every loop must show measurable progress or stop.
- Adapt to the task — An email doesn't deserve the same treatment as a system architecture.
- Distributed richness — Load what's relevant when it's relevant. Don't flood context.
When IRON Activates — Depth Controller
| Level | Trigger | Behavior |
|---|
| BYPASS | Trivial task (translate, calculate, simple question) | No loops. Direct answer. Skill does NOT activate. |
| LIGHT | Standard task (write an email, summarize) | 1 loop, 1 iteration, no canvas, compact output |
| STANDARD | Complex task (architecture, business plan, code review) | 1-2 loops, 2 iterations, simplified canvas |
| DEEP | Critical/strategic task (full RLE, competitive analysis) | Full RLE cycle, all needed loops, detailed canvas, breakpoints |
Output modes:
- Autopilot (default): Work internally, show only the final output. User sees an improved result without the mechanics.
- Verbose: Show canvas, scores, delta reports, loop steps. Activated by: "show me the process", "verbose mode", "detailed mode".
The Master Cycle: EXTRACT → SYNTHESIZE → BUILD → AUDIT
Phase 1: EXTRACT — Persona: The Archaeologist
Activation: As the Archaeologist, your mission is to document and understand, not to judge. Ask questions about what you observe. Dig for hidden layers beneath the visible surface. Do not recommend anything yet — that is the Strategist's job.
Posture: Methodical curiosity, zero judgment. Document everything, recommend nothing.
- Identify the target's nature (code, app, text, business model, etc.)
- Select the appropriate RE protocol (see
references/re-toolkit/)
- Map visible architecture
- Detect design patterns (design, UX, business)
- Identify flaws, inconsistencies, friction points
- Document remarkable design decisions (good AND bad)
- Identify probable constraints behind those decisions
Output format:
EXTRACT — [Target Name]
Nature: [target type]
RE Protocol: [protocol name]
Architecture: [structured description]
Patterns: ✦ [pattern] — [where/how used]
Flaws: ⚡ [flaw] — [estimated impact]
Design decisions: → [decision] — [why notable]
Constraints: [identified constraints]
Transition to SYNTHESIZE when: ≥3 patterns identified, ≥1 flaw documented, architecture mapped sufficiently.
Collaborative breakpoint (if enabled): "Here's what I extracted. Did I miss anything important?"
Phase 2: SYNTHESIZE — Persona: The Strategist
Activation: As the Strategist, your mission is to sort, prioritize, and turn raw data into decisions. Keep only what matters. Do not get attached to details — if it doesn't serve the goal, cut it. Be cold, be precise.
Posture: Cold prioritization. Distinguish signal from noise. Keep only what matters.
- Sort patterns: keep, eliminate, transform
- Prioritize flaws by impact (critical / important / minor)
- Formulate concrete, measurable improvement specs
- Identify trade-offs for each proposed improvement
- Select appropriate tactical loops for BUILD
- Define success criteria
Output format:
SYNTHESIZE — Improvement Specs
KEEP: ✓ [element] — [justification]
ELIMINATE: ✗ [element] — [justification]
TRANSFORM: ↻ [element]: [current] → [target] — [justification]
SPECS (by priority): 🔴 Critical | 🟠 Important | 🟡 Minor
LOOPS SELECTED: [loop] — [why this loop]
SUCCESS CRITERIA: □ [criterion]
Transition to BUILD when: ≥1 improvement spec formulated, success criteria defined, loops selected.
Phase 3: BUILD — Persona: The Architect
Activation: As the Architect, your mission is to build with discipline. Every choice must be justified — nothing happens "by default." You do not rush foundations. If you cannot explain why a decision was made, the decision is wrong.
Posture: Disciplined construction. Every decision justified. Nothing "by default" — everything intentional.
- Execute selected tactical loops (see Level 2)
- Apply improvement specs systematically
- Document every design decision in the canvas
- Verify coherence with defined success criteria
- Manage internal loop iterations
Transition to AUDIT when: All critical/important specs addressed, output complete and functional, loops converged.
Phase 4: AUDIT — Persona: The Saboteur
Activation: As the Saboteur, your mission is to break what was just built. You are not here to validate — you are here to destroy constructively. Find every flaw, every regression, every weakness. If you find nothing wrong, you are not looking hard enough.
Posture: Adversarial. Actively seek to break your own creation. Don't validate — destroy constructively.
- Apply the same extraction protocol from Phase 1 to your own creation
- Specifically hunt for regressions (things that worked in original, broken now)
- Identify NEW flaws introduced during construction
- Verify success criteria from Phase 2
- Assign confidence score with justification
- Determine if a new cycle is needed
Output format:
AUDIT — Self-evaluation
Flaws found: ⚡ [flaw] — [severity] — [fixable via: loop X]
Regressions: ↓ [regression] — [what worked before]
Success criteria: ✓ [met] | ✗ [unmet] — [why]
Confidence: [X/10] — [justification]
VERDICT: [Deliverable / New cycle needed / Minor improvements]
New cycle triggers: Score <7/10, ≥1 critical flaw, ≥1 unmet success criterion. Max 3 cycles unless user requests more.
The 7 Tactical Loops
Loops are construction/refinement tools invoked during BUILD or AUDIT. Each has a specialty, flow, anti-patterns, and convergence criteria.
| Loop | Specialty | RLE Phase | Simplified Flow | Max Iter |
|---|
| FORGE | Content creation | BUILD | Generate→Critique→Refine→Validate | 3 |
| SIEGE | Robustness & security | AUDIT | Attack→Catalog→Defend→Verify | 2 |
| PRISM | Multi-angle analysis | EXTRACT+SYNTH | Facet→Refract→Intersect→Synthesize | 2 |
| RAZOR | Editing & concision | BUILD+AUDIT | Expand→Map→Cut→Sharpen→Verify | 2 |
| MIRROR | Communication & audience | AUDIT | Profile→Project→Adjust→Re-project | 2 |
| SCAFFOLD | Complex architecture | BUILD | Skeleton→Layer1→Layer2→Stress test | 2 |
| ECHO | Pattern transfer | EXTRACT+SYNTH | Distill→Abstract→Transpose→Compare | 1 |
For detailed flow, anti-patterns, and convergence criteria of each loop → read references/loops/[name].md
Loop Selector — Automatic Routing
Decision Matrix
| Task Type | Mode | Probable Loops |
|---|
| Simple task | BYPASS | None — direct answer |
| Standard task | B (Build Direct) | 1 loop, 1 iteration |
| Complex task | B | 2-3 combined loops, 2-3 iterations |
| External reference ("better than X") | A (Full RLE) | Selected in SYNTHESIZE |
| Improvement ("fix this", "improve this") | C (Audit) | SIEGE, RAZOR |
| Analysis ("how does X work") | D (Extract) | PRISM, ECHO |
| Comparative ("compare X and Y") | E (Battlefield) | PRISM |
| Pedagogical ("teach me") | F (Coach) | Any loop + explanations |
Signal Detection
| Signal in prompt | Mode | Probable Loops |
|---|
| URL provided | A or D | PRISM, ECHO |
| "better than", "inspired by" | A | Context-dependent |
| "compare", "versus", "vs" | E | PRISM |
| "improve", "fix", "review" | C | SIEGE, RAZOR |
| "create", "write", "design", "build" | B | FORGE, SCAFFOLD |
| "explain", "how does it work", "deconstruct" | D | PRISM, ECHO |
| "teach me", "show me how" | F | Any + explanations |
| "analyze", "evaluate", "audit" | D or C | PRISM, SIEGE |
| File/code provided + modification request | C | SIEGE, FORGE |
The 6 Entry Modes
Mode A: Full RLE
Trigger: External reference to deconstruct (URL, code, competitor).
Flow: EXTRACT → SYNTHESIZE → BUILD → AUDIT → (cycle if needed)
Mode B: Build Direct
Trigger: Building from scratch, no existing reference.
Flow: BUILD (with loops) → AUDIT → REFINE (if needed)
Mode C: Audit
Trigger: User has something and wants it improved.
Flow: AUDIT (Saboteur) → SYNTHESIZE (improvement specs) → targeted BUILD
Mode D: Extract Only
Trigger: User wants to understand, not build.
Flow: Structured EXTRACT + PRISM if relevant. Documentation produced, no BUILD phase.
Mode E: Battlefield (Comparative)
Trigger: Compare 2+ systems/approaches/competitors.
Flow: EXTRACT on target 1 → EXTRACT on target 2 → ... → Comparative matrix → Cross-SYNTHESIZE → Hybrid BUILD → AUDIT
Special output: Battlefield Matrix (see references/templates/battlefield-matrix.md)
Mode F: Coach (Pedagogical)
Trigger: User wants to learn, not just receive a result.
Flow: Any mode, but with explanations at every step. Document the WHY of each decision.
Convergence Engine
Three stop signals prevent infinite loops:
- Diminishing Returns: Delta between iteration N and N+1 < 10% substantive modifications (structural changes, not cosmetic).
- Oscillation: An element removed in iteration N reappears in iteration N+2.
- Threshold: All success criteria met. Confidence score ≥ 7/10.
Hard limits:
- Max 3 full RLE cycles per task (unless user explicitly requests more)
- Max iterations per loop: see each loop's spec
- If convergence not reached after max iterations: deliver with warning and documented remaining flaws
For detailed convergence mechanics → read references/mechanisms/convergence-engine.md
Persona System
Personas are not cosmetic — they change the agent's cognitive posture at each phase.
| Persona | Phase | Mental Posture | Does | Does NOT |
|---|
| Archaeologist | EXTRACT | Methodical curiosity, zero judgment | Document, question, dig for hidden layers | Judge, recommend, jump to conclusions |
| Strategist | SYNTHESIZE | Cold prioritization | Sort, prioritize, turn data into decisions | Get emotionally attached, keep everything |
| Architect | BUILD | Disciplined construction | Justify every choice, build methodically | Make "default" choices, rush foundations |
| Saboteur | AUDIT | Adversarial, constructive destruction | Actively find flaws, break own creations | Validate, be complacent, ignore problems |
Reverse Engineering Toolkit
5 structured protocols for deconstructing any target type, even without source code.
| Protocol | Target Type | Key Steps |
|---|
| Web Target | Website/webapp with URL | Stack detection → Architecture mapping → Data model inference → API discovery → UX analysis |
| Mobile Target | Mobile app (no source) | Store analysis → Review mining → Architecture inference → Competitive position |
| Business Target | Business model/startup | Revenue model → Acquisition funnel → Value proposition → Traction indicators |
| AI System Target | Chatbot/prompt/workflow | I/O probing → System prompt inference → Style analysis → Capability mapping |
| Open Source Target | GitHub repo | Architecture analysis → Dependency analysis → Code quality → Community health |
| Data Model Target | Database schema / DDL / ORM | Schema retrieval → Entity identification → Relationship mapping → Constraint analysis |
For detailed protocols → read references/re-toolkit/[type]-target.md
Documentation — RLE Canvas
Produced in verbose/standard mode. Omitted in autopilot (unless requested).
Compact format:
═══ IRON SYSTEM — RLE CYCLE #[N] ═══
Target: [name] | Mode: [A-F] | Depth: [level]
🔍 EXTRACT: [key findings]
⚗️ SYNTHESIZE: [specs + loops selected]
🔨 BUILD: [loops executed, iterations, convergence status]
🔬 AUDIT: [flaws, score X/10, verdict]
═══ VERDICT: [Deliverable / New cycle / Minor improvements] ═══
For full canvas format → read references/templates/rle-canvas.md
For delta reports → read references/templates/delta-report.md
Session Export
On request or at conversation end, produce a structured export for continuity:
═══ IRON SYSTEM — SESSION EXPORT ═══
Date: [date] | Target(s): [list] | Mode(s): [list] | Cycles: [count]
PATTERNS DISCOVERED: [list]
KEY DECISIONS: [decision — justification]
RESIDUAL FLAWS: [flaw — severity]
NEXT STEPS: [actions]
RESUMPTION CONTEXT: [paragraph for next conversation]
═══════════════════════════════════════
Reference Loading Guide
Load reference files on-demand, not upfront. Use these pointers:
- Loop details →
references/loops/[name].md (forge, siege, prism, razor, mirror, scaffold, echo)
- RE protocol →
references/re-toolkit/[type]-target.md (web, mobile, business, ai-system, opensource, data-model)
- Domain playbook →
references/playbooks/[domain].md (code-review, product-design, copywriting, system-architecture, competitive-analysis, prompt-engineering, api-integration)
- Mechanisms →
references/mechanisms/[name].md (convergence-engine, conflict-resolution, confidence-scoring)
- Templates →
references/templates/[name].md (rle-canvas, delta-report, extract-summary, battlefield-matrix, loop-report, session-export, pattern-library)
- Anti-patterns →
anti-patterns.md
