Research Prompts

By the Syncfusion DevTutorials team · Last updated October 20, 2026

Research safely with a model: plan sub-questions, judge sources, get claims with citations and check them, compare sources, catch invented links, and use the model as a tutor.

Models are great helpers for research. They can break a big question into smaller ones, summarise long documents, compare sources, and explain a new topic at your level. But they also have one dangerous habit: they can make up sources. A made-up paper title, or a link that goes nowhere, looks just as real as a true one.

This lesson shows you how to use a model for research safely. Let it plan, organise, and explain, while every fact comes from a source you can check.

The main idea: use the model to plan your research and work with your sources, not as the source itself. Every claim should point to a real document that you can open.

A Real-World Example

Think about a good research assistant in a library.

• They help you turn "I want to learn about climate" into clear questions.
• They find books and articles, and tell you which ones look trustworthy.
• They summarise what each source says, and show you the page.
• They never make up a book that doesn't exist.

That last point is where models need your help. A model is like a fast assistant who has no library card. You bring the sources, and it helps with everything else.

What You Will Learn

In this lesson, you will learn:

1. How to break a research question into smaller questions.
2. How to judge a source before you trust it.
3. How to get claims with citations, and check that every claim has one.
4. How to compare what two sources say.
5. Why you must check links and paper titles that a model gives you.
6. How to use a model as a patient teacher when you learn something new.

A Research Workflow

1. Plan: the model splits the big question into smaller questions.
2. Gather: you find real sources for each smaller question.
3. Process: the model summarises the sources, with a citation for each claim.
4. Check: you check the important claims against the sources.

The model is good at steps 1 and 3. Steps 2 and 4 are your job.

Break Down the Question

A big, unclear question gets a big, unclear answer. Ask the model to split it into specific, smaller questions that you can research one by one.

A prompt that plans sub-questions

function planPrompt(topic, reader, n) {
  return [
    "I am researching: " + topic,
    "The result is for: " + reader,
    "Split this into " + n + " specific sub-questions that can each be answered from documents.",
    "Reply as a numbered list. Do not answer the questions.",
  ].join("\n");
}

console.log(planPrompt("Should our team move our web app from REST to GraphQL?", "an engineering manager", 4));

Expected output:

I am researching: Should our team move our web app from REST to GraphQL?
The result is for: an engineering manager
Split this into 4 specific sub-questions that can each be answered from documents.
Reply as a numbered list. Do not answer the questions.

"Do not answer the questions" keeps the model in planning mode. At this step, you don't want answers from its memory.

Judge the Source

Some sources are better than others. Before you use one, ask a few simple questions. The next box turns these questions into a quick score. It is a rough guide to help you decide what to read first, not a final decision.

A quick source checklist

function sourceScore(s) {
  const notes = [];
  let score = 0;
  if (s.author) { score++; } else notes.push("no author");
  if (s.year >= 2023) { score++; } else notes.push("older than 2023");
  if (s.kind === "official docs" || s.kind === "paper") { score++; } else notes.push("not a primary source");
  if (s.citesSources) { score++; } else notes.push("cites nothing");
  return score + "/4" + (notes.length ? " (" + notes.join(", ") + ")" : "");
}

console.log(sourceScore({ author: "GraphQL Foundation", year: 2025, kind: "official docs", citesSources: true }));
console.log(sourceScore({ author: "", year: 2019, kind: "forum post", citesSources: false }));

Expected output:

4/4
0/4 (no author, older than 2023, not a primary source, cites nothing)

A forum post can still be useful, for example to find a known bug. But for the main facts, choose recent primary sources. These are sources that come straight from the people who know: official documentation, research papers, and first-hand data.

Claims With Citations

When the model summarises your sources, ask for one claim per line, with each line ending in the source id, like [S1]. Then code can check that every claim has a citation, and that every citation is a real source.

Check every claim has a real citation

const sourceIds = ["S1", "S2"];

function checkClaims(reply) {
  return reply.split("\n").filter(Boolean).map((line) => {
    const cites = [...line.matchAll(/\[(S\d+)\]/g)].map((m) => m[1]);
    if (cites.length === 0) return "NO SOURCE  | " + line;
    const fake = cites.filter((c) => !sourceIds.includes(c));
    return (fake.length ? "FAKE " + fake.join(",") + " | " : "ok         | ") + line;
  });
}

const reply = "GraphQL lets clients ask for exactly the fields they need. [S1]\nREST can need several requests for one screen. [S2]\nGraphQL is always faster than REST.\nMost large companies use GraphQL. [S4]";
checkClaims(reply).forEach((l) => console.log(l));

Expected output:

ok         | GraphQL lets clients ask for exactly the fields they need. [S1]
ok         | REST can need several requests for one screen. [S2]
NO SOURCE  | GraphQL is always faster than REST.
FAKE S4 | Most large companies use GraphQL. [S4]

The reply is a sample written for this example. The two flagged lines show common problems: a claim that sounds sure but has no source, and a citation to a source that doesn't exist. You must remove or check both before you use the summary.

Try it with the real model. The facts are in the prompt, and each test checks that the answer cites a source.

Compare Sources

In real research, you often read sources that disagree with each other. Ask the model to put their claims side by side. Then you can see where they agree and where they don't. The next box does a simple version of this comparison on claims taken from two sources.

Find agreement and disagreement between sources

const claims = {
  S1: { "fewer requests": "yes", "easier caching": "no", "learning curve": "higher" },
  S2: { "fewer requests": "yes", "easier caching": "no", "learning curve": "lower" },
};

for (const topic of Object.keys(claims.S1)) {
  const a = claims.S1[topic];
  const b = claims.S2[topic];
  console.log((a === b ? "agree    " : "DISAGREE ") + topic + ": S1=" + a + ", S2=" + b);
}

Expected output:

agree    fewer requests: S1=yes, S2=yes
agree    easier caching: S1=no, S2=no
DISAGREE learning curve: S1=higher, S2=lower

When separate sources agree, the claim is stronger. When they disagree, you know where to look more closely, for example by checking the date and the evidence of each source.

Known, Inferred, or Needs Checking

The answer that sounds most sure is not always the most reliable. Ask the model to sort its answer into three groups:

• Known: things the sources you gave say directly.
• Inferred: the model's own conclusions from those sources.
• Needs checking: things the model is unsure about, or that the sources don't cover.

Sort claims into known, inferred and to-check

// The prompt asked for each line to start with KNOWN, INFERRED or CHECK.
const reply = [
  "KNOWN: GraphQL lets clients request exactly the fields they need. [S1]",
  "INFERRED: Our mobile app may need fewer requests per screen.",
  "CHECK: Whether our caching layer works with GraphQL POST requests.",
  "KNOWN: GraphQL caching needs extra work. [S3]",
].join("\n");

const groups = { KNOWN: [], INFERRED: [], CHECK: [] };
for (const line of reply.split("\n")) {
  const [label, ...rest] = line.split(":");
  if (groups[label]) groups[label].push(rest.join(":").trim());
}

for (const label in groups) console.log(label + ": " + groups[label].length);
console.log("Known lines without a source:", groups.KNOWN.filter((t) => !/\[S\d+\]/.test(t)).length);

Expected output:

KNOWN: 2
INFERRED: 1
CHECK: 1
Known lines without a source: 0

The reply is a sample written for this example. The groups show you where to spend your checking time. "Known" lines need a quick check against the source. "Inferred" lines need your own judgement. "Check" lines are your to-do list.

Check Links and Titles

Ask a model for "5 sources on GraphQL performance", and it may give you titles, authors, and links that look real but do not exist. The model is guessing what a citation looks like. It is not looking one up.

Code can catch obvious problems, like a link in the wrong format. But it cannot prove that a source is real. Only opening it can do that.

Catch badly formed links (but not fake ones)

function linkCheck(url) {
  try {
    const u = new URL(url);
    if (u.protocol !== "https:") return "not https";
    if (!u.hostname.includes(".")) return "odd host";
    return "well formed: still open it to check it exists";
  } catch {
    return "not a valid URL";
  }
}

["https://graphql.org/learn/", "graphql dot org", "http://example.com/report.pdf"].forEach((u) => console.log(u, "->", linkCheck(u)));

Expected output:

https://graphql.org/learn/ -> well formed: still open it to check it exists
graphql dot org -> not a valid URL
http://example.com/report.pdf -> not https

Learning Prompts

Research also means learning something new yourself. A model can be a patient teacher, if you tell it how to teach you:

• Tell it your current level.
• Ask for one idea at a time, followed by a question to check that you understood.
• Ask it to wait for your answer before it goes on.

Build a tutor prompt

function tutorPrompt(topic, level) {
  return [
    "Teach me " + topic + ". My level: " + level + ".",
    "Explain one idea at a time in under 80 words, with one everyday example.",
    "After each idea, ask me one short question to check I understood, then wait for my answer.",
    "If my answer is wrong, explain the idea again in a different way.",
  ].join("\n");
}

console.log(tutorPrompt("how HTTP caching works", "I build web pages but have never set cache headers"));

Expected output:

Teach me how HTTP caching works. My level: I build web pages but have never set cache headers.
Explain one idea at a time in under 80 words, with one everyday example.
After each idea, ask me one short question to check I understood, then wait for my answer.
If my answer is wrong, explain the idea again in a different way.

Try it in the Chat tab, and answer its questions:

Two more lines make a learning prompt even better: "Define any jargon you use" and "End with three questions I should ask next." The first line keeps the explanation at the right level. The second line shows you where to go next with the topic.

A model that teaches can still be wrong. For anything you will depend on, check the key facts in the official documentation.

Common mistakes

Exercises

In each exercise, the last line should give back a value. Press Check to compare your value with the expected answer.

What to Remember

• Use the model to plan your research and work with your sources. You bring the sources.
• Split big questions into specific, smaller questions.
• Choose recent primary sources, and judge each source before you use it.
• Ask for a source id on every claim, and check that every id is real.
• Compare sources to see where they agree and disagree.
• Models can make up titles and links. Open every one.
• Ask the model to label its claims as known, inferred, or needs checking.
• For learning, ask for one idea at a time, with a question to check you understood, explanations of any jargon, and questions to ask next.

Next: Coding Prompts, where you use models to write, explain, debug, refactor, and review code.