Framing Research Questions logo

Framing Research Questions

Organization
K-Dense-AI
framing-research-questions

You MUST use this before any data analysis or investigation - before exploring a dataset, loading or profiling data, running a model, computing a statistic, or testing an idea, and before any outcome data is touched

Overview

PublisherK-Dense-AI
Repositoryscience-superpowers
Skill nameframing-research-questions
Stars
360
Forks
37
Bundled files
Instructions only
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.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by K-Dense-AI on GitHub. Read the source before you install it.

Installation

Install the Framing Research Questions 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/K-Dense-AI/science-superpowers/tree/main/skills/framing-research-questions
  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/K-Dense-AI/science-superpowers.git /tmp/science-superpowers
mkdir -p .claude/skills
cp -r /tmp/science-superpowers/skills/framing-research-questions .claude/skills/framing-research-questions
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Framing Research Questions 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 Framing Research Questions 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 Framing Research Questions 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.

Framing Research Questions Into Investigations

Help turn a fuzzy research interest into a precise, falsifiable question with explicit hypotheses, the data required, and what would count as an answer — through natural collaborative dialogue.

Start by understanding the context (the data on hand, the domain, what your human partner already knows), then ask questions one at a time to sharpen the interest. Once you understand what is being investigated, present the framing and get approval.

Why this gate is strict for science specifically: Looking at outcomes before the question and predictions are fixed contaminates a confirmatory analysis. Once you have seen the data, you cannot un-see it, and every later choice (which test, which subgroup, which cutoff) becomes suspect. Framing first is what keeps a result confirmatory rather than a story told after the fact.

What this gate does NOT forbid: measuring whether the computation can run — assembly size, peak memory, wall clock, iteration counts, convergence behavior. Those are provenance and structure, not outcomes. Resource measurement never contaminates a confirmatory analysis, because the outcome variable is untouched.

When Feasibility Is Unknown

If it is not yet known whether the computation can run at all — an unbenchmarked solver, an unproven pipeline, a configuration whose memory or wall-clock ceiling is estimated rather than measured — say so during framing and offer feasibility mode:

"Whether this can run at scale is unknown, and the design depends on the answer. I can establish feasibility first — a minimal runner, three scaling probes, one exploratory campaign — and defer the survey, plan, and pre-registration until we know what is runnable. Nothing produced that way can support a confirmatory claim. Or we proceed with the standard sequence. Which?"

Only your human partner can choose it. If they do, use science-superpowers:establishing-feasibility-first after a short framing. If they decline or say nothing, continue the standard sequence below.

Separate the two questions in the framing either way: the feasibility question (a measurable threshold) and the scientific question it gates. Tangling them produces predictions written over runs that may not be possible.

Anti-Pattern: "This Is Too Simple To Need Framing"

Every investigation goes through this process. A single t-test, a quick correlation, a "just look at the trend" — all of them. "Simple" questions are where unexamined assumptions and undeclared researcher degrees of freedom do the most damage. The framing can be short (a few sentences for a truly simple question), but you MUST present it and get approval.

Checklist

You MUST create a task for each of these items and complete them in order:

  1. Explore context — what data exists, its shape and provenance, the domain, recent related work in the repo
  2. Ask clarifying questions — one at a time; understand the phenomenon, the population, the unit of analysis, and what decision the answer informs
  3. Propose 2-3 framings — different ways to make the question precise, with trade-offs and your recommendation
  4. Present the framing — question, hypotheses, data needed, success/answer criteria, scope; get approval after each section
  5. Write the question document — save to docs/science-superpowers/questions/YYYY-MM-DD-<topic>.md and commit
  6. Self-review — quick inline check for vagueness, unfalsifiable claims, undefined measures, scope creep (see below)
  7. Your human partner reviews the written framing — ask them to review the file before proceeding
  8. Transition — invoke surveying-prior-work to ground methods, then designing-the-analysis

Process Flow

dot
digraph framing {
    "Explore context" [shape=box];
    "Ask clarifying questions" [shape=box];
    "Propose 2-3 framings" [shape=box];
    "Present framing sections" [shape=box];
    "Partner approves framing?" [shape=diamond];
    "Write question doc" [shape=box];
    "Self-review (fix inline)" [shape=box];
    "Partner reviews doc?" [shape=diamond];
    "Invoke surveying-prior-work" [shape=doublecircle];

    "Explore context" -> "Ask clarifying questions";
    "Ask clarifying questions" -> "Propose 2-3 framings";
    "Propose 2-3 framings" -> "Present framing sections";
    "Present framing sections" -> "Partner approves framing?";
    "Partner approves framing?" -> "Present framing sections" [label="no, revise"];
    "Partner approves framing?" -> "Write question doc" [label="yes"];
    "Write question doc" -> "Self-review (fix inline)";
    "Self-review (fix inline)" -> "Partner reviews doc?";
    "Partner reviews doc?" -> "Write question doc" [label="changes requested"];
    "Partner reviews doc?" -> "Invoke surveying-prior-work" [label="approved"];
}

The terminal state is invoking surveying-prior-work (then designing-the-analysis). Do NOT jump to loading data or fitting models. The ONLY skills you invoke after framing are surveying-prior-work and designing-the-analysis — or, if and only if your human partner opted into feasibility mode, establishing-feasibility-first.

The Process

Understanding the interest:

  • Inspect the context first: what data is available, its schema, size, and where it came from. You may look at structure and provenance (column names, row counts, collection method) — but do NOT look at outcome distributions or relationships you might later test.
  • Before asking detailed questions, assess scope: if the request bundles several independent questions ("does the treatment work, and what drives churn, and can we forecast revenue"), flag it immediately. Decompose into separate investigations, each with its own question → design → pre-registration cycle.
  • For appropriately-scoped interests, ask questions one at a time.
  • Prefer multiple-choice questions when possible; open-ended is fine too.
  • Only one question per message.
  • Focus on: the phenomenon, the population/sample, the unit of analysis, the comparison, and what decision or understanding the answer serves.

A good research question is:

  • Specific — names the variables, the population, and the relationship being examined
  • Falsifiable — there is an outcome that would prove it wrong
  • Operationalized — every construct maps to something measurable in the data ("engagement" → what column, computed how)
  • Scoped — answerable with one coherent analysis, not five

Exploring framings:

  • Propose 2-3 ways to make the question precise (e.g., association vs. causal effect; continuous outcome vs. threshold; population-level vs. subgroup).
  • Lead with your recommended framing and explain the trade-offs (what each can and cannot conclude, what data each needs).

Presenting the framing:

  • Once you understand the question, present it in sections scaled to complexity.
  • Cover: the question, the hypotheses (including the null and a directional prediction if appropriate), the data and key variables, what would count as a confirmatory answer, and explicit scope/exclusions.
  • Ask after each section whether it looks right.

After the Framing

Documentation — write the approved framing to docs/science-superpowers/questions/YYYY-MM-DD-<topic>.md:

markdown
# <Question title>

**Research question:** <one precise, falsifiable sentence>

**Background / motivation:** <why this matters, what decision it informs>

**Hypotheses:**
- H0 (null): <...>
- H1 (alternative, directional if justified): <...>

**Population & unit of analysis:** <who/what, the sample, the unit>

**Key variables (operationalized):**
- Outcome: <construct> → <measure / column / computation>
- Predictor(s) / exposure: <...> → <...>
- Covariates / potential confounders: <...>

**What counts as an answer:** <the confirmatory criterion, stated qualitatively here; exact decision rules come later in pre-registration>

**Scope & exclusions:** <what is explicitly out of scope>

**Open questions for prior-work survey:** <methods to check, known confounds to look up>

Commit the document to git.

Self-Review — look at the document with fresh eyes:

  1. Vagueness scan: Any construct not mapped to a measure? Any "better", "improves", "related to" without specifying direction or magnitude? Fix them.
  2. Falsifiability: Is there an outcome that would disconfirm H1? If not, reframe.
  3. Scope check: Is this one investigation, or several wearing a trench coat? Decompose if needed.
  4. Unit/population clarity: Is the unit of analysis unambiguous (person? session? cluster?)? Fix if not.

Fix issues inline. No need to re-review — just fix and move on.

Partner Review Gate — after the self-review passes:

"Framing written and committed to <path>. Please review it and let me know if you want changes before we survey prior work and design the analysis."

Wait for the response. If they request changes, make them and re-run the self-review. Only proceed once they approve.

Transition:

  • Invoke surveying-prior-work to ground the question and methods in existing knowledge.
  • Then designing-the-analysis. Do NOT invoke any other skill or touch outcomes yet.

Key Principles

  • One question at a time — don't overwhelm
  • Falsifiable or it's not a question — there must be an outcome that proves it wrong
  • Operationalize everything — constructs must map to measures
  • YAGNI ruthlessly — cut sub-questions that don't serve the decision
  • Don't peek — structure and provenance are fair game; outcomes are not, until pre-registration is done

Frequently asked questions

What does the Framing Research Questions AI skill do?

You MUST use this before any data analysis or investigation - before exploring a dataset, loading or profiling data, running a model, computing a statistic, or testing an idea, and before any outcome data is touched

Why use Framing Research Questions on TypingMind?

Because you install it once and use it with any model. Framing Research Questions 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 Framing Research Questions in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/K-Dense-AI/science-superpowers/tree/main/skills/framing-research-questions. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Framing Research Questions?

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 Framing Research Questions?

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

Is the Framing Research Questions AI skill free?

It is published on GitHub by K-Dense-AI. 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 👇