I built a 120-model mental models framework using… the framework itself.
Meta-recursive product development. Here’s what 22 months of framework-driven building taught me:
🧵👇
Started with a mess:
Wickedness score: 20/30 (Tier 4 problem)
First breakthrough: 6 transformations, not random categories.
P - Perspective
IN - Inversion
CO - Composition
DE - Decomposition
RE - Recursion
SY - Systems
Everything maps to these 6. Always.
Second breakthrough: Base-N scaling.
Base6 = 6 models (core literacy) Base42 = 42 models (wicked problems) Base120 = 120 models (pedagogical ceiling)
Match complexity to problem tier. Don’t over-engineer.
Third breakthrough: Quantitative wickedness scoring.
5 questions, 0-30 points:
Replaced vibes with math.
Fourth breakthrough: AI agents as team members.
Claude = Lead Architect ChatGPT = Validator Windsurf = Executor Cursor = Specialist
SITREP protocol for coordination. 4x parallel execution.
The numbers:
✅ 120/120 models validated ✅ 9.2/10 quality score ✅ 140 chaos tests ✅ 100% pass rate ✅ 1 human + 4 AI agents ✅ 22 months
The meta-recursive proof:
If a framework can build itself, it can build anything at equivalent complexity.
Base120 passed its own test.
What I’d do differently:
The framework is live at hummbl.io
MCP server for Claude Desktop: @hummbl/mcp-server
Full case study: https://github.com/hummbl-dev/mcp-server/blob/main/docs/case-study-01-framework-development.md
What’s your Tier 4 problem? Let’s see if Base120 can crack it.
22 months ago, I had a problem.
Mental models everywhere. Notes, books, scattered insights. No system. No validation. No product.
Today: 120 validated models. 9.2/10 quality score. 140 automated tests. Production deployment.
The twist? I used the framework to build the framework.
Here’s what meta-recursive product development looks like:
Phase 1: Architecture Applied DE3 (Modularization) to create 6 transformation categories. Applied CO8 (Layered Abstraction) to design Base-N scaling. Base42 became the “practical optimum” for wicked problems.
Phase 2: Validation Replaced subjective judgment with a 5-question, 30-point wickedness rubric. Every model got empirically tested against real problems.
Phase 3: Multi-Agent Coordination This is where it got interesting.
I’m a solo founder with a full-time job. Traditional development timeline: 3-5 years.
My solution: Treat AI systems as team members with defined roles.
Military-style SITREP protocol for coordination. Authorization codes for autonomous execution boundaries.
Result: 4x parallel execution. Zero rework from misalignment.
The meta-recursive proof:
If a framework can successfully build itself, it can handle any problem at equivalent complexity.
Base120 passed its own test.
What’s next:
If you’re working on a Tier 4 (wicked) problem—multiple stakeholders, low predictability, high interdependency—I’d love to hear about it.
The framework is free at hummbl.io. DM me if you want to be a case study.
#mentalmodels #frameworks #AI #productdevelopment #solofounder
┌────────────────────────────────────────────────────────────┐
│ │
│ HUMMBL BASE120 │
│ Case Study: Framework-Driven Product Development │
│ │
├────────────────────────────────────────────────────────────┤
│ │
│ THE CHALLENGE │
│ ───────────────── │
│ • Solo founder, competing time demands │
│ • No existing product infrastructure │
│ • Need for empirical validation │
│ • Multi-system AI coordination required │
│ │
│ Wickedness Score: 20/30 (Tier 4) │
│ │
├────────────────────────────────────────────────────────────┤
│ │
│ THE APPROACH │
│ ───────────────── │
│ 6 Transformations: P | IN | CO | DE | RE | SY │
│ │
│ Base-N Scaling: │
│ Base6 (literacy) → Base42 (wicked) → Base120 (complete) │
│ │
│ Multi-Agent Coordination: │
│ Claude + ChatGPT + Windsurf + Cursor │
│ SITREP protocol for parallel execution │
│ │
├────────────────────────────────────────────────────────────┤
│ │
│ THE RESULTS │
│ ───────────────── │
│ │
│ 120/120 9.2/10 140 22 │
│ models quality tests months │
│ validated score passing │
│ │
│ ✓ Meta-recursive validation (framework built itself) │
│ ✓ 4x parallel execution via AI coordination │
│ ✓ Production deployment at hummbl.io │
│ │
├────────────────────────────────────────────────────────────┤
│ │
│ KEY MODELS USED │
│ ───────────────── │
│ DE3 Modularization │ Architecture design │
│ SY18 Telemetry │ Validation methodology │
│ SY20 Systems-of-Systems│ Multi-agent coordination │
│ RE4 Iterative Refinement│ Framework expansion │
│ │
├────────────────────────────────────────────────────────────┤
│ │
│ "If a framework can build itself, │
│ it can build anything at equivalent complexity." │
│ │
│ hummbl.io | @hummbl/mcp-server │
│ │
└────────────────────────────────────────────────────────────┘
“I spent 22 months building a mental models framework. The twist? I used the framework to build itself. Here’s what happened.”
Subject: I used a framework to build itself (here’s what happened)
Hey,
22 months ago I started building HUMMBL—a mental models framework for wicked problems.
The meta part: I used the framework to build the framework.
The challenge:
The approach:
The results:
The meta-recursive proof: if a framework can build itself, it can handle anything at equivalent complexity.
Want to try it?
If you’re working on a wicked problem—multiple stakeholders, low predictability, high complexity—reply and tell me about it. Looking for case study #2 and #3.
– Reuben Chief Engineer, HUMMBL
Title: I built a 120-model mental models framework using the framework itself (18-month retrospective)
Body:
Sharing a case study from building HUMMBL—a systematic mental models framework for complex problem-solving.
The meta-recursive twist: I used the framework’s own models to architect, validate, and deploy it.
Key technical decisions:
6 transformations, not categories: Perspective, Inversion, Composition, Decomposition, Recursion, Systems. Every model maps to exactly one.
Base-N scaling: Base6 for literacy, Base42 for wicked problems, Base120 for pedagogical completeness. Match complexity to problem tier.
Quantitative wickedness scoring: 5-question rubric (variables, stakeholders, predictability, interdependencies, reversibility) replacing subjective tier assignment.
Multi-agent development: Treated Claude, ChatGPT, Windsurf, and Cursor as team members with defined roles. SITREP protocol for coordination. 4x parallel execution.
Results:
Tech stack: React, Cloudflare Workers, D1, TypeScript
Links:
Would love feedback on the framework architecture and multi-agent coordination approach. AMA about the development process.