An agent skill that turns vague consultations into reframed questions, unexpected perspectives, strategy candidates, honest evaluation, and one validation fork.
Most AI answers optimize for giving a useful response immediately.
Insight Compiler optimizes for moving the frame first.
It shows the ordinary answer, then deliberately pushes beyond it through domain lenses, discovery operators, a dense hint bank, strategy candidates, honest evaluation, and one validation fork whose outcomes are pre-committed.
Insight Compiler does not try to give you more answers. It tries to change the question you should be solving.
The same question, asked twice — once to a plain assistant, once with Insight Compiler enabled.
I published Insight Compiler, but no one seems to be visiting the repository.
I also feel that even when people do visit, it may be difficult to understand
because there aren't any concrete examples yet. What should I do?
The ordinary answer accepted the question as asked and optimized the repository. Insight Compiler rejected the premise: "no one visits" and "it's hard to understand" are two different bottlenecks, and repository traffic may not be the right success metric at all for a skill that runs inside someone else's agent.
| Ordinary answer | Insight Compiler |
|---|---|
| Improve the README | Decide who it is for, first |
| Add 3-5 demos | Produce one complete example that lands with one person |
| Announce on social media | Distribute the output itself as the content |
| Grow visitor count | Create the first repeat user |
The full transcript is long. The length is part of what the skill does, so it lives in a separate file instead of the top of this page.
Insight Compiler is a thinking workflow for open-ended questions, product ideas, business strategy, writing angles, important decisions, and personal dilemmas.
It is not designed to produce the shortest possible answer. It is designed to change how the question is seen before committing to a direction.
The output normally includes:
- an executive read for fast orientation
- the surface question and the deeper question
- a compact baseline of what an ordinary AI would say
- selected perspectives from distant domains
- discovery operators that deform the problem
- a dense hint bank
- 2-3 strategy candidates traced back to specific hints
- an honest evaluation of those candidates
- one hidden assumption
- one validation fork with pre-committed judgment updates
General AI answers often converge on plausible advice:
- narrow the target
- differentiate
- build an MVP
- talk to users
- test demand
Those answers are often reasonable, but they rarely move the user's frame.
Insight Compiler makes the ordinary answer visible first, then uses it as the ground to rise above. The goal is not more advice. The goal is a better map of the problem.
This repository includes two skills.
| Version | Persistent memory | Best for | Writes local file |
|---|---|---|---|
InsightCompiler |
No | One-shot deep consultation | No |
InsightCompilerPersonal |
Yes | Repeated consultations with personalization | Yes |
The standard version. It runs the full thinking loop without persistent memory:
- intent discovery
- ordinary-answer baseline
- domain lenses
- discovery operators
- hint bank
- strategy candidates
- strategy evaluation
- validation fork
Use this if you want a strong one-shot thinking partner without personalization across sessions.
The personalized version. It runs the same loop, but also maintains a local thinking profile at:
~/.insight-compiler/profile.md
The profile records only the user's topic-independent working habits: known constraints, validation tendencies, blind spots, and the default angle they enter from. It never records which topics or perspectives the user liked.
Personalization must never pick which perspectives are shown, narrow the internal scan, or reduce the hint bank. It only grounds the executability judgment, sharpens the validation fork, and may widen the discovery scan away from a habitual entry angle.
Do not enable both skills at the same time because their triggers intentionally overlap.
Use Insight Compiler when you want to think more deeply about:
- a vague consultation
- a product or business idea
- strategy and positioning
- a writing or content angle
- an important decision
- a personal dilemma
- a problem that feels stuck in conventional framing
Example prompts:
I have an idea for a new product, but I'm not sure it's different enough from what's already out there. How should I approach it?
Users are complaining about our paid plan. Should we lower the price?
I'm deciding whether to quit my job to build my own product. Help me think it through.
Insight Compiler is not the right tool when you need:
- a short factual answer
- pure code generation
- direct market research
- live competitor analysis
- legal, medical, or financial advice
- a final decision without further validation
Claims about novelty, market gaps, or competitor absence should be treated as hypotheses unless separately verified.
The skill follows this internal loop:
flowchart TD
A[Open-ended consultation] --> B[Intent discovery]
B --> C[Ordinary-answer baseline]
C --> D[Domain lenses]
C --> E[Discovery operators]
D --> F[Hint bank]
E --> F
F --> G[Strategy candidates]
G --> H[Honest evaluation]
H --> I[Validation fork]
I --> J[Executive read displayed first]
J --> K[Judgment update]
The internal scan is broad, but the output is curated. The skill does not dump every possible lens. It shows the strongest discoveries while keeping the answer readable.
Input:
I want to build a popular macOS app like Obsidian.
Ordinary answer:
- Choose a niche.
- Differentiate from Obsidian.
- Build an MVP.
- Interview users.
Insight Compiler reframes the problem:
The strategic question may not be "How do I build a better note app?"
It may be:
- Which battlefield can Obsidian structurally not fight on?
- Which users already failed at existing note apps?
- Is the durable value note storage, or decision support?
- What should be validated first before building the app?
The final output includes strategy candidates and a single validation fork, so the next step is not vague exploration but a concrete judgment update.
The output starts with an Executive read, so the user can understand the current judgment quickly before reading the full reasoning map.
For a full session on a real problem, see examples/nobody-visits-my-repository.md.
Insight Compiler is an Agent Skill: a directory containing a SKILL.md file. Installing it means copying one of the two skill directories into the place where your agent looks for skills.
Pick one version and copy only that one. Do not install both, because both are designed to trigger on the same kinds of consultation prompts.
For all your projects:
git clone https://github.com/snc2work/insight-compiler.git
mkdir -p ~/.claude/skills
cp -r insight-compiler/InsightCompiler ~/.claude/skills/Or for a single project, copy it into .claude/skills/ inside that repository instead.
Swap InsightCompiler for InsightCompilerPersonal if you want the version that keeps a local thinking profile.
Restart Claude Code, then check that it is loaded:
/skills
Any agent that supports Agent Skills can use it. Upload or copy the chosen directory — keeping SKILL.md and the references/ folder together — into that agent's skills location. In the Claude apps this is done from Settings → Capabilities → Skills.
Note that InsightCompilerPersonal writes a profile file only where the agent can read and write local files. In a plain chat, it still runs the full consultation, but nothing is persisted.
You do not call the skill by name. Ask a real question and it triggers on its own:
Let me consult you on something. I'm deciding whether to quit my job to build
my own product.
Only InsightCompilerPersonal writes a profile.
The profile is stored locally:
~/.insight-compiler/profile.md
It is a plain Markdown file. You can read, edit, or delete it at any time.
The profile is only saved in environments where the agent can read and write local files (for example a CLI-style coding agent). In a plain chat without file access, the Personal version still runs the full consultation, but nothing is persisted — every session behaves like a fresh start.
The profile is intended to record working habits, not personality claims or tastes. It should record signals such as:
- known constraints that affect what the user can execute (team size, skills, time, budget)
- how the user tends to run, or skip, validation
- recurring blind spots in how the user frames problems
- the default angle the user enters from (used only to widen away from it)
It should not record:
- which lens, hint, or candidate the user liked (tastes are never stored)
- hidden psychological interpretations
- emotional labels
- private facts unrelated to the consultation
- the model's guesses about the user
If you do not want persistent personalization, use InsightCompiler.
insight-compiler/
├── README.md
├── README.ja.md
├── LICENSE
├── examples/
│ └── nobody-visits-my-repository.md
├── assets/
│ ├── header.svg
│ ├── workflow.mmd
│ ├── version-comparison.mmd
│ └── image-prompts.md
├── InsightCompiler/
│ ├── SKILL.md
│ ├── references/
│ └── evals/
└── InsightCompilerPersonal/
├── SKILL.md
├── references/
└── evals/
Both skills include evaluation prompts and assertions under their evals/ directories.
The tests check whether the output:
- starts with an executive read that orients the user quickly
- keeps the ordinary-answer baseline compact
- selects rather than dumps domain lenses and operators
- produces a hint bank with sufficient breadth
- traces strategy candidates back to named hints
- evaluates candidates honestly instead of manufacturing a tie
- ends with exactly one validation fork
- responds in the user's language, matching the language of the prompt
- treats market novelty as a hypothesis unless verified
The Personal version also checks that the profile sharpens the output without creating an echo chamber.
Released under the MIT License. See LICENSE.