Decision Clarity logo

Decision Clarity

Community
shanezzzz
decision-clarity

Improve decision quality by clarifying the real problem, exposing hidden assumptions, reasoning from fundamental facts, reducing unnecessary complexity, and ending with a cleaner recommendation or next step. Use when the user is confused, comparing options, overcomplicating a problem, questioning assumptions, trying to identify the real bottleneck, or asking things like "what am I missing?", "does this really have to be this way?", "what should I remove?", "what is the simplest explanation that still fits?", or "help me think this through".

Overview

Publishershanezzzz
Repositorydecision-clarity-skill
Skill namedecision-clarity
Stars
58
Forks
6
Bundled files
12
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 12 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by shanezzzz on GitHub. Read the source before you install it.

Installation

Install the Decision Clarity AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/shanezzzz/decision-clarity-skill/tree/main
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/shanezzzz/decision-clarity-skill.git \
  .claude/skills/decision-clarity
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Decision Clarity in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Decision Clarity on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Decision Clarity is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Decision Clarity

Use this skill to turn ambiguous, high-value, complexity-prone problems into clearer decisions.

This skill combines three reasoning modes in a practical sequence:

  1. Socratic questioning to clarify the real issue
  2. First-principles thinking to reduce the issue to facts and constraints
  3. Occam-style simplification to remove unnecessary complexity

Do not use this skill to sound philosophical. Use it to improve judgment.

Core objective

Produce answers that:

  1. identify the real question
  2. expose hidden assumptions
  3. reduce the issue to facts, constraints, and causal structure
  4. compare options by complexity and assumption load
  5. remove false complexity
  6. end with a clear recommendation, next step, or test

A strong answer should make the user feel:

  • "the real problem is clearer now"
  • "you found the assumption I was missing"
  • "this is simpler than I thought"
  • "I know what to do next"

Operating stance

Default to clarity before confidence.

Ask:

  • What is the user actually trying to decide or understand?
  • Which parts of the problem are vague, inherited, or untested?
  • What facts and hard constraints actually matter?
  • Which explanation or plan requires fewer unnecessary assumptions?
  • What is the simplest path that still respects reality?

Best-fit use cases

This skill is especially useful for:

  • startup and business decisions
  • product and MVP decisions
  • content and creator workflow design
  • operations and process simplification
  • strategy questions with multiple plausible options
  • personal decisions where confusion, self-justification, or complexity are distorting judgment
  • argument and reasoning audits

Not a good fit for

Do not use this skill for:

  • simple factual lookup
  • purely mechanical execution tasks
  • obvious low-stakes choices
  • cases where the user explicitly wants only conventional guidance without reframing

Workflow routing

Route to the smallest useful workflow.

  • The problem is vague, overloaded, or poorly framed → Workflows/Clarify.md
  • The issue needs to be broken into facts, constraints, and mechanics → Workflows/Deconstruct.md
  • The issue has too many explanations, steps, features, or moving parts → Workflows/Simplify.md
  • The user needs a recommendation, decision rule, priority order, or test → Workflows/Decide.md

For non-trivial problems, use the full sequence:

  1. Clarify
  2. Deconstruct
  3. Simplify
  4. Decide

For simpler problems, compress the sequence but preserve the logic.

Mode selection

Choose the lightest response mode that still improves the decision.

Mode A: Quick Reframe

Use for short questions such as:

  • "What am I missing?"
  • "Am I overcomplicating this?"
  • "Does this really have to be this way?"
  • "Which option actually makes more sense?"

Output:

  • Real issue
  • Hidden assumption
  • Main constraint
  • Simpler conclusion
  • Next move

Mode B: Structured Decision Analysis

Use for startup, product, content, operations, and strategic decisions.

Output:

  • Real goal
  • Assumptions
  • Basic facts
  • Hard constraints
  • Soft constraints
  • Simpler options
  • Recommendation
  • First test or next step

Mode C: Reasoning Audit

Use when the user presents an argument, thesis, or decision path that may be weak, confused, or overbuilt.

Output:

  • Real question
  • Weak assumptions
  • Missing evidence or contradiction
  • Simpler interpretation or design
  • Refined judgment

Do not force a long analysis when a shorter one is enough.

Required reasoning rules

1. Clarify before solving

Do not solve the wrong problem well.

Restate the issue in outcome terms, not only in the user's current framing.

Examples:

  • "Should I build an app?" may really mean "what is the best delivery mechanism for this user outcome?"
  • "How do I make this more professional?" may really mean "how do I increase trust, clarity, conversion, or authority?"
  • "Why is this so hard?" may really mean "which part is actually the bottleneck?"

If the question is framed at the wrong level, say so and correct it.

2. Surface assumptions explicitly

Look for assumptions in:

  • the user's wording
  • inherited workflows
  • industry norms
  • default best practices
  • preferred tools or formats
  • emotional preferences presented as logic

Useful prompts to yourself:

  • What is being treated as necessary?
  • What would have to be true for this conclusion to hold?
  • What is being accepted without evidence?
  • Which assumption is carrying the most weight?

3. Reduce the issue to facts and constraints

Break the problem into:

  • goals
  • user behavior
  • incentives
  • cost structure
  • time requirements
  • dependencies
  • information flow
  • causal drivers
  • legal or technical boundaries
  • real risks

Prefer mechanism over narrative.

Do not say "this is just how the market works" unless you explain the actual mechanics.

4. Distinguish hard constraints from soft constraints

Hard constraints

Treat these as real unless evidence suggests otherwise:

  • physical limits
  • legal or regulatory limits
  • hard technical boundaries
  • fixed budgets or capacities
  • immovable deadlines already fixed in reality
Soft constraints

Treat these as challengeable by default:

  • industry conventions
  • legacy process steps
  • default tool choices
  • current org boundaries
  • aesthetic expectations
  • existing architecture
  • "this is how it is usually done"

Never present a soft constraint as immutable without justification.

5. Prefer lower assumption load

When comparing explanations or options, prefer the one that:

  • requires fewer speculative assumptions
  • introduces fewer moving parts
  • adds less coordination cost
  • preserves the real goal with less structure
  • still adequately fits the facts and constraints

Do not simplify by deleting reality. Simplicity must remain sufficient.

6. End with a decision

Always end with one of:

  • a recommendation
  • a decision rule
  • a priority order
  • a smallest useful experiment
  • a first implementation step
  • a short list of what to answer next

Do not end with abstract reflection alone.

If information is incomplete

Do not stall. Instead:

  1. name the key ambiguity
  2. state the most likely interpretations
  3. make the minimum necessary assumptions explicit
  4. proceed with the best current interpretation
  5. say what fact would most change the recommendation

Domain references

Read only the relevant references when useful:

  • references/business.md for startup, pricing, growth, distribution, and strategy
  • references/product.md for MVP, feature decisions, onboarding, user jobs, and scope
  • references/content.md for tutorials, creator workflows, content quality, and production systems
  • references/operations.md for SOPs, approvals, handoffs, and workflow simplification
  • references/trigger-questions.md for transforming vague user prompts into sharper analysis frames
  • references/output-patterns.md for stable response structure
  • references/examples.md for concrete high-value examples
  • references/anti-patterns.md whenever the reasoning risks becoming overly abstract, endlessly inquisitive, falsely simple, or non-actionable

Quality bar

A strong answer produced with this skill should:

  • identify the real decision or question
  • expose the hidden assumption
  • separate facts from inertia
  • reduce unnecessary complexity
  • preserve adequacy
  • leave the user with a cleaner next step

If the answer sounds clever but does not improve the user's decision quality, it is not good enough.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Decision Clarity AI skill do?

Improve decision quality by clarifying the real problem, exposing hidden assumptions, reasoning from fundamental facts, reducing unnecessary complexity, and ending with a cleaner recommendation or next step. Use when the user is confused, comparing options, overcomplicating a problem, questioning assumptions, trying to identify the real bottleneck, or asking things like "what am I missing?", "does this really have to be this way?", "what should I remove?", "what is the simplest explanation that still fits?", or "help me think this through".

Why use Decision Clarity on TypingMind?

Because you install it once and use it with any model. Decision Clarity is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Decision Clarity in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/shanezzzz/decision-clarity-skill/tree/main. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Decision Clarity?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Decision Clarity?

As many as you like. As long as a model supports skills, you can use Decision Clarity with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Decision Clarity AI skill free?

It is published on GitHub by shanezzzz. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇