Loom go

<p align="left"> <a href="https://www.npmjs.com/package/loom-go" target="_blank"><img src="https://img.shields.io/npm/v/loom-go?color=blue" alt="npm version"></a> <a href="https://github.com/zankkas/loom-go/blob/main/LICENSE" target="_blank"><img src="https://img.shields.io/badge/License-MIT-%233fb950?labelColor=32383f" alt="License"></a> <a href="https://nodejs.org" target="_blank"><img src="https://img.shields.io/badge/Node.js-18%2B-339933?labelColor=32383f&logo=node.js&logoColor=339933" alt="Node.js"></a> <a href="https://github.com/zankkas/loom-go/releases/latest" target="_blank"><img src="https://img.shields.io/badge/Claude_Desktop-one--click_install-d97757?labelColor=32383f&logo=anthropic&logoColor=white" alt="Claude Desktop"></a> </p>

Think it through. 🧵

---

There is a thing you have been carrying. You know you need to think it through, but every time you sit down to do it, you end up somewhere else. Not because you are avoiding it. Because you do not know where to start.

You open Claude. Claude answers. That is not the same as thinking.

Loom is different. You say loom go. It reads where you are, clear problem, tangled feeling, or something in between, and it starts from there. No setup. No prompting. Just: bring what you have.

---

💬 How it works

When you are ready, say:

"loom go"

That is the entry point.

If your problem is formed, one thing, one decision, a question you can name, Loom asks which framework you want and gets to work.

If your problem is messy, multiple threads, contradictions, a feeling you cannot quite name, Loom listens first. It reflects back what it hears underneath, surfaces the assumption you did not notice you were making, and checks: is that what is actually going on? Once you are oriented, you choose how to proceed.

If you have only got a fragment, a half-sentence, a mood, Loom asks one question. Just one. Then it listens.

Whatever state you are in, that is the starting point.

---

🧠 The thinking frameworks

Once you are oriented, Loom routes you into structured reasoning. Two frameworks ship with every install.

---

First principles

For when you need to challenge what you think you know.

A five-stage process grounded in Aristotelian decomposition, the Feynman method, and the CIA Key Assumptions Check. It does not let you skip to conclusions.

1. Define — what is really going on, and what would a good outcome actually look like?
2. Surface assumptions — what are you taking for granted? How sure are you, really?
3. Challenge — which assumptions are physics, which are hard constraints, and which are just habit?
4. Extract first principles — what do you know to be true, no matter who is in the room?
5. Reconstruct — build from what is real. Hand back what requires a human call.

Each stage is a prompt. You respond. The next stage builds on what you said. By the end, you know what you actually think, and why.

---

Sequential thinking

For when you need to move through a problem one step at a time.

An open-ended reasoning chain. Each thought builds on the previous. You follow the thread wherever it leads. Five steps by default; you close it when you have reached your conclusion.

Good for problems where you do not know the shape of the answer yet. Less structure than first principles, more room to discover.

---

🧭 Meet me where I am

This is the design principle behind everything.

Most tools assume you arrive ready. You have a well-formed question, you type it, you get an answer. That works when you already know what you are asking.

Loom was built for the other case. When the problem is still fuzzy. When what you have is a feeling, a tension, a set of competing threads. When asking the question clearly is the hard part.

The job of loom go is to read that state and respond to it, not to the ideal version of it. If you are clear, it moves fast. If you are not, it slows down and helps you find the problem before trying to solve it.

The entry point is always the same. What happens next depends entirely on where you are.

---

✨ What is coming

First principles and sequential are the foundation. More frameworks are in design:

• Pre-mortem: picture it six months from now and it failed. Work backwards to find out why. Fix it before it happens.
• Inversion: instead of asking how to succeed, ask how you would guarantee failure. Then make sure you are not doing any of those things.
• Steelman: take the argument you are about to dismiss. Build the strongest possible version of it. Then decide if you still disagree.

---

⚙️ Installation

npx loom-go install

Detects Claude Desktop, Cursor, or both, and writes the config entry. Restart your client. Loom is live.

---

One-click install (Claude Desktop)

1. Download loom-go-0.1.0.mcpb from the releases page
2. Double-click the file
3. Restart Claude Desktop

---

Manual config

{
  "mcpServers": {
    "loom": {
      "command": "npx",
      "args": ["-y", "loom-go"]
    }
  }
}

Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json Cursor: ~/.cursor/mcp.json

<details> <summary><b>Troubleshooting</b></summary>

npx not found: Ensure Node.js 18+ is installed: node --version

Tools not appearing after install: Restart your MCP client fully — quit and reopen, not just reload.

Config not detected: Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json Cursor: ~/.cursor/mcp.json

</details>

---

🤝 Contributing

The framework library is where Loom grows. If you have a thinking methodology that holds up under real use, open an issue before building. The stage prompts in first-principles.ts and sequential.ts are the instruction layer; good prompt work here has outsized impact.

Client compatibility notes and bug reports are always welcome.

Before touching a module, read the relevant spec in docs/specs/.

---

MIT License

Built by someone who got tired of avoiding hard problems and went through them instead.