Iterative Reverse-engineering & Optimization Nexus

Stop single-pass prompting. Start iterative reverse-engineering.

The meta-cognitive framework that turns any capable AI agent into a disciplined engineer — with structured deconstruction, named tactical loops, and mandatory self-audit.

Get Started · How It Works · 7 Tactical Loops · Playbooks · Compare

---

⚡ TL;DR

Most AI agents run in single-pass mode: prompt → answer → done. IRON System replaces that with a 4-phase master cycle (EXTRACT → SYNTHESIZE → BUILD → AUDIT), 7 named tactical loops, and 6 reverse-engineering protocols — plus depth control that prevents overkill on trivial tasks.

Drop it in your agent's skill folder. It activates itself on complex tasks. It stays silent on simple ones.

---

🎯 The Problem

Prompt  ─►  Answer  ─►  You reformulate manually  ─►  Repeat
                              (cognitive waste)

Modern AI agents lack:

• ❌ Systematic extraction — competitor analysis is ad-hoc, not protocolized
• ❌ Structured iteration — no methodical return to previous work
• ❌ Convergence signals — improvement attempts loop forever or stop arbitrarily
• ❌ Self-audit rigor — the agent judges its own output softer than it judges yours
• ❌ Shared vocabulary — you can't request a specific type of iteration

💡 The Solution

IRON gives your agent a methodology, a vocabulary, and a set of guardrails:

┌───────────────────────────────────────────────────────────┐
│  LEVEL 3 — INTELLIGENCE MECHANISMS                        │
│  Loop Selector · Convergence Engine · Depth Controller     │
│  Conflict Resolution · Confidence Scoring                  │
├───────────────────────────────────────────────────────────┤
│  LEVEL 2 — 7 TACTICAL LOOPS                                │
│  FORGE · SIEGE · PRISM · RAZOR · MIRROR · SCAFFOLD · ECHO  │
├───────────────────────────────────────────────────────────┤
│  LEVEL 1 — MASTER CYCLE (RLE)                              │
│  EXTRACT ─► SYNTHESIZE ─► BUILD ─► AUDIT                   │
└───────────────────────────────────────────────────────────┘

---

🚀 Quick Start

Drop the skill files into your agent's skill directory. 30 seconds, zero config.

# Clone the repo
git clone https://github.com/william1mufassa/IRON-SYSTEM.git

# Copy into your agent's skill folder (path depends on your platform)
cp IRON-SYSTEM/SKILL.md your-agent/skills/iron-system.md
cp -r IRON-SYSTEM/references your-agent/skills/references/
cp IRON-SYSTEM/anti-patterns.md your-agent/skills/anti-patterns.md

⚠️ Important: Keep the references/ folder name intact — SKILL.md points to it with relative paths.

That's it. Your next complex prompt triggers IRON automatically. Try one:

> Analyze https://stripe.com/pricing and design a better pricing page for a competitor.
> Audit this authentication code and fix the vulnerabilities.
> Compare React, Vue, and Svelte for a real-time dashboard app.
> Deconstruct Uber's business model and identify the moat.

---

🧠 How It Works

The Master Cycle — RLE

Every complex task flows through 4 phases with distinct cognitive postures:

Phase	Persona	Posture	Output
🔍 EXTRACT	The Archaeologist	Methodical curiosity, zero judgment	Patterns, flaws, design decisions
⚗️ SYNTHESIZE	The Strategist	Cold prioritization	Improvement specs by severity
🔨 BUILD	The Architect	Disciplined construction	Justified, tested output
🔬 AUDIT	The Saboteur	Adversarial destruction	Confidence score, remaining flaws

Each phase has strict transition criteria. Each persona actually changes how the agent reasons — the Saboteur hunts for flaws the Archaeologist wouldn't dare name.

---

⚙️ The 7 Tactical Loops

Loops are invoked by BUILD or AUDIT. Each solves a distinct problem class.

Loop	Icon	Specialty	Flow	Max Iter
FORGE	🔨	Content creation	Generate → Critique → Refine → Validate	3
SIEGE	⚔️	Robustness & security	Attack → Catalog → Defend → Verify	2
PRISM	🔺	Multi-angle analysis	Facet → Refract → Intersect → Synthesize	2
RAZOR	✂️	Editing & concision	Expand → Cut → Sharpen → Verify	2
MIRROR	🪞	Audience communication	Profile → Project → Adjust → Re-project	2
SCAFFOLD	🏗️	Complex architecture	Skeleton → Layers → Stress test	2
ECHO	🔊	Pattern transfer	Distill → Abstract → Transpose → Compare	1

Each loop ships with its own anti-patterns, convergence criteria, and iteration cap. See references/loops/ for details.

---

🎛️ 6 Entry Modes

IRON detects the task type and routes to the right mode automatically:

Mode	Trigger	Flow
A — Full RLE	Analyzing an existing system	EXTRACT → SYNTHESIZE → BUILD → AUDIT
B — Build Direct	Creating from scratch	BUILD (loops) → AUDIT → REFINE
C — Audit	Improving existing work	AUDIT → SYNTHESIZE → targeted BUILD
D — Extract Only	Understanding, not building	EXTRACT + PRISM (no BUILD)
E — Battlefield	Comparing 2+ targets	Multi-EXTRACT → Matrix → Hybrid BUILD
F — Coach	Learning the process	Any mode + step-by-step explanations

---

🔬 Reverse Engineering Toolkit

Deconstruct any target — even without source code.

Protocol	Target	Sample Signals Extracted
Web Target	Websites & webapps	Stack, routes, data model, API surface, monetization
Mobile Target	Mobile apps (no source)	Store metadata, review mining, permission → feature inference
Business Target	Business models & startups	Revenue model, acquisition funnel, moat, traction
AI System Target	Chatbots & prompts	I/O probing, system prompt inference, capability mapping
Open Source Target	GitHub repos	Architecture, dependencies, community health, bus factor
Data Model Target	Schemas & DDL	Entities, relationships, constraints, anti-patterns

---

📘 Domain Playbooks

Pre-configured for the workflows people actually use:

• 🛡️ Code Review — SIEGE → FORGE for security, performance, maintainability
• 🎨 Product Design — PRISM → SCAFFOLD → MIRROR for user, business, tech
• ✍️ Copywriting — FORGE → MIRROR → RAZOR for message, audience, tightness
• 🏛️ System Architecture — SCAFFOLD → SIEGE for layered design + stress testing
• ⚔️ Competitive Analysis — Battlefield mode with cross-synthesis
• 🎯 Prompt Engineering — SIEGE → FORGE → MIRROR to audit, rewrite, test
• 🔌 API Integration — PRISM → SCAFFOLD → SIEGE for reliable third-party wiring

---

🎚️ Depth Control

IRON automatically calibrates to task complexity — it doesn't turn "translate hello" into a 3-phase architecture review.

Depth	Task	Behavior
BYPASS	Trivial (translate, calculate)	Direct answer — skill doesn't activate
LIGHT	Standard (write an email)	1 loop, 1 iteration, no canvas
STANDARD	Complex (review code)	1-2 loops, 2 iterations, simplified canvas
DEEP	Critical (payment architecture)	Full RLE, all needed loops, detailed canvas, breakpoints

Autopilot by default (silent work, clean output). Verbose on demand ("show me the process") — you see the canvas, scores, and delta reports.

---

🆚 vs Other Frameworks

Capability	Chain of Thought	Tree of Thought	Reflection	IRON System
Iterative	✗	✗	Basic	Multi-level (3 cycles)
Structured deconstruction	✗	✗	✗	5 RE protocols
Named construction loops	✗	✗	✗	7 tactical loops
Systematic self-audit	✗	✗	Partial	Saboteur persona
Convergence signals	N/A	N/A	✗	3 stop signals
Adaptive depth	✗	✗	✗	4 levels (BYPASS→DEEP)
RE without source code	✗	✗	✗	6 target protocols
Multi-mode routing	✗	✗	✗	6 entry modes
Structured documentation	✗	✗	✗	Canvas + Delta Reports
Conflict resolution	✗	✗	✗	Explicit protocol
Pedagogical mode	✗	✗	✗	Coach mode
Comparative mode	✗	✗	✗	Battlefield mode

CoT, ToT, and Reflection are techniques — one thing done better. IRON is a framework — it organizes how the agent thinks, not just what it thinks. It ships a router, a convergence engine, documentation formats, an external analysis toolkit, roles, and conflict management. A workshop, not a tool.

---

📂 Repository Structure

IRON-SYSTEM/
├── SKILL.md                       # Core — cycle + routing + pointers
├── anti-patterns.md               # Global + per-loop anti-patterns
├── scripts/
│   └── validate_integrity.py      # 81-check integrity validator
├── references/
│   ├── loops/                     # 7 loops, one file each
│   ├── mechanisms/                # Convergence, conflict resolution, scoring
│   ├── re-toolkit/                # 6 RE protocols
│   ├── playbooks/                 # 7 domain guides
│   └── templates/                 # Canvas, delta reports, session export
├── evals/
│   └── evals.json                 # 7 test cases
├── CONTRIBUTING.md
├── LICENSE
└── README.md

---

✅ Integrity Validation

Every reference link, every loop iteration limit, every playbook structure is checked by a single script:

python scripts/validate_integrity.py

Ran 81 checks. 0 failure(s).

Perfect for CI. Prevents regressions when contributors add loops, protocols, or playbooks.

---

🗺️ Roadmap

• v1.0 — Master cycle, 7 loops, 6 modes, 6 RE protocols, 7 playbooks
• Integrity validation script
• Additional RE protocols: Design system, Video/Audio, Legal document
• Additional playbooks: Data Science, Legal, Video Production
• Evaluation harness that automatically runs evals.json against a model
• Pattern Library persistence across sessions
• Community-contributed loops

Have an idea? Open an issue.

---

🤝 Contributing

IRON improves through structured deconstruction — including of itself. Contributions welcome:

• New loops — Identify a recurring iteration pattern? Propose a loop
• New RE protocols — Target types not yet covered
• New playbooks — Domain-specific pre-configurations
• Before/After examples — Real deliverables demonstrating the framework
• Evaluation cases — Additional evals.json entries

See CONTRIBUTING.md for guidelines.

---

📜 License

MIT License — Use it, fork it, improve it, embed it in products. No attribution required (but appreciated).

---

If IRON System changed how you prompt, give it a ⭐ — it helps others find the framework.

Made for anyone who thinks single-pass prompting leaves value on the table.