Thinking Frameworks — Extracted April 2026
12 codified thinking patterns extracted from 3 months of building Forge — an autonomous AI operating system. Each framework is a repeatable decision tool. Combined, they form the governance layer of how Jason thinks, builds, and operates.
Use these as: prompts for AI assistants, decision checklists for teams, skill definitions for agent clones, or standalone thinking tools.
First Principle: Not all tasks are equal. Most are noise. Find the 4% that produces 64%.
Before working on anything, ask: "Is this a domino or a tile?" A domino unlocks other tasks when it falls. A tile is unlocked BY other tasks — it's downstream. Always find and push the domino first.
Cascade: Push domino → 3-5 tiles become trivial or irrelevant → time saved compounds → you work on fewer, higher-leverage things → output per hour increases exponentially.
| Without This | With This |
|---|---|
| Work on 10 tasks in priority order | Work on 1 task that eliminates 6 of the 10 |
| Feel productive clearing a backlog | Actually move the needle by pushing what compounds |
First Principle: Never fix at the same level twice. If the fix didn't hold, you're at the wrong abstraction level.
When a problem recurs despite being "fixed," trace UP through abstraction layers. The symptom is at Level 5. The fix is usually at Level 1 or 2. Each level asks "WHY does the level above happen?"
Cascade: Fix at source → entire CLASS of problems eliminated → downstream patches become unnecessary → system gets simpler, not more complex → maintenance cost drops to near zero for that class.
| Level | Example |
|---|---|
| 5 (symptom) | Tasks stuck as "running" in the database |
| 4 (mechanism) | Processes die without updating status |
| 3 (design) | Spawner exits without monitoring the process |
| 2 (input quality) | Tasks are too vague for the agent to execute |
| 1 (the domino) | Decomposer creates tasks without reading the project spec |
First Principle: Every project needs a 5-line anchor that states WHY it exists and WHAT it must achieve. Every agent, every task, every decision references this anchor.
Before any work begins, extract: (1) First Principle — why this exists, (2) The Problem — what pain it solves, (3) Desired Cascade — the 2nd/3rd order effects wanted, (4) Anti-Goals — what it must NOT become, (5) The Test — measurable success criterion.
Cascade: Core Truth written → every builder knows WHY → drift detected instantly (output doesn't match anchor) → corrections are precise (measure against anchor, not opinion) → compound over time as the anchor refines.
First Principle: Decisions are binary, not scored. Don't rate 1-5 on a rubric. Answer 6 yes/no questions.
For any decision to advance, invest, or build:
| # | Check | Outcomes |
|---|---|---|
| 1 | Domino? Does this unlock other things? | YES → advance. NO → deprioritize. UNSURE → surface. |
| 2 | Cascade? Can you trace 3 steps forward? | YES → advance. CAN'T TRACE → surface. |
| 3 | Root cause? Is this the right next step, or is something upstream broken? | CLEAR → advance. BLOCKER → fix upstream first. |
| 4 | Inversion? What breaks if you DON'T do this for 30 days? | NOTHING → deprioritize. THINGS BREAK → advance. |
| 5 | Confidence? Do you have enough info to decide? | YES → advance. NO → surface the specific gap. |
| 6 | Reversible? Can you undo it if wrong? | YES → advance. NO → get approval first. |
First Principle: Every failure is a compound investment. The system MUST get stronger from breaking, not just survive.
| Strike | Response | Output |
|---|---|---|
| 1 | Document + patch + add to wiki | Instance fixed. Class documented. |
| 2 | Trace UP one abstraction level. Fix the SOURCE. | Structural gate. Class prevented. |
| 3 | Full lifecycle redesign on the fix itself. | Architecture change. Class eliminated. |
| 5+ | Circuit breaker. Publish white paper. Ask for help. | Honest admission + 3 angles to try. |
First Principle: If the user can't see it, it doesn't exist. Every build must answer: where does this surface?
Before marking any work "done," answer: (1) WHERE does the user see this? (2) HOW do they find it? (3) WHAT can they DO with it? (4) Would they find it without being told where to look?
Cascade: Everything visible → user trusts the system → user makes faster decisions → feedback loop tightens → system improves faster from better feedback.
First Principle: V1 = dirty and working. V2 = clean and solid. V3 = never. Match effort to stakes.
The first version of anything should be the minimum that proves the concept. Don't write the PRD before you know the idea works. Don't automate before you've done it by hand 3 times.
First Principle: Every action triggers a chain of 2nd-order effects. Never decide based on the immediate outcome alone.
Before any action, trace forward: Step 1 (immediate) → Step 2 (what Step 1 enables) → Step 3 (compound effect). Also trace the INVERSE: what happens if you DON'T do this?
First Principle: Every failure must be OWNED within 30 minutes. Retry, recover, or escalate. No orphans. No idle failures.
Nothing may enter a terminal state (failed, stuck, orphaned) without someone or something owning the next action. The test: can you query for items stuck longer than 30 minutes? The answer must be zero.
First Principle: A factory that produces defective parts doesn't need better inspectors. It needs to fix the machine.
When something fails repeatedly: don't improve the cleanup. Ask "what CREATES the input that fails?" and fix THAT. The fix that makes the previous fix unnecessary is the right fix.
First Principle: There is ALWAYS a solution, but never chase wild geese. Check the simple proof points FIRST.
Before committing resources down a pipeline, validate cheaply at the entry point. If the basics aren't true, the rest doesn't matter. This applies to debugging (check the obvious first), feature builds (validate the assumption), and escalations (confirm the symptom).
First Principle: Don't solve the problem at the level it presents. Extract UP to the level where one action eliminates a CLASS of problems.
"Don't fix the bug — build the system that finds and fixes all bugs." "Don't write content — build the content machine." Every suggestion should pass: "is there a level above this where we solve the whole category?"
The frameworks aren't independent. They form a decision loop:
NEW WORK arrives → Core Truth Anchoring (WHY are we doing this?) → Domino Thinking (is this the RIGHT thing?) → Decision Gate (6 checks — advance/surface/deprioritize?) → Right-Size It (V1 first) → Cascade Mapping (trace 2nd order effects) → Build... → Surface Everything (can the user see it?) → Smoke Test (does it do what Core Truth says?) FAILURE occurs → Antifragile Loop (which strike?) → Abstraction Climbing (am I at the right level?) → Fix at Source (what creates the failing input?) → Meta-Climb (can I eliminate the whole class?) → No Dead Ends (owned within 30 min)
Each framework becomes a skill in an AI assistant. The combination creates a "Jason clone" that thinks the way Jason thinks:
| Situation | Framework(s) to Load |
|---|---|
| "What should I work on?" | Domino Thinking + Decision Gate |
| "This keeps breaking" | Antifragile Loop + Abstraction Climbing + Fix at Source |
| "Should we build this?" | Core Truth + Cascade Mapping + Right-Size It |
| "Something failed" | No Dead Ends + Smoke Test + Antifragile Loop |
| "Is this done?" | Surface Everything + Core Truth (does it match?) |
| "How do we scale this?" | Meta-Climb + Cascade Mapping + Domino Thinking |
Source: Extracted from Forge governance layer — 35 PROB entries, 10+ governance rules, 3 months of building. These frameworks are the codified thinking behind an autonomous AI operating system.
Author: Jason MacDonald | jason@jasondmacdonald.com
Built with: Forge + Claude | April 2026