Phd Intro Drafter logo

Phd Intro Drafter

Community
Immortalqx
phd-intro-drafter

Drafts a 6-paragraph Introduction outline for a technical paper from a structured Flowchart: background and running example, existing limitations, problem essence and goal, key challenges, solution overview, contributions. Positions the paper as Technique or New Problem/Setting and aligns contributions with challenges. Use when the user asks to 'draft the Introduction', 'outline the Introduction', 'intro logic needs clarifying', 'help structure the paper story', or before writing any Introduction prose.

Overview

PublisherImmortalqx
Repositorymy_codex_skills
Skill namephd-intro-drafter
Stars
56
Forks
0
Bundled files
6
LicenseMIT
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.

  • 6 bundled files

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

  • Open source

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

Installation

Install the Phd Intro Drafter 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/Immortalqx/my_codex_skills/tree/main/phd-intro-drafter
  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/Immortalqx/my_codex_skills.git /tmp/my_codex_skills
mkdir -p .claude/skills
cp -r /tmp/my_codex_skills/phd-intro-drafter .claude/skills/phd-intro-drafter
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Phd Intro Drafter 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 Phd Intro Drafter 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 Phd Intro Drafter 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.

Introduction Drafter

Overview

The Introduction is the compressed version of the entire paper. In one and a half to two pages it must state the research object, why the problem matters, why existing work falls short, what the paper contributes, and how the contribution maps to section numbers. Reviewers decide whether to keep reading by the time they finish the Introduction, so the logical throughline has to be airtight.

This skill takes a small set of inputs (research area, limitations, hard constraints, key idea, challenges, solution overview) and produces a six-paragraph outline with an explicit purpose and writing points for every paragraph, plus a positioning as Technique Paper or New Problem/Setting Paper. It enforces the rule that contributions align one-to-one with challenges, and that every claim has a section to deliver it.

When to use this skill

  • Before writing any Introduction prose.
  • The user has finished planning but the Intro story feels fragmented.
  • The user has a partial Intro and wants to restructure.
  • The user asks to 'draft the Introduction', 'outline the Introduction', 'intro logic needs clarifying', or 'help structure the paper story'.
  • The paper's contributions are clear, but the storyline connecting them is not.
  • phd-idea-evaluator has returned Strong Accept and the next step is drafting.

When NOT to use this skill

  • The paper's core idea is not yet stable. Use phd-idea-evaluator first.
  • The paper is a benchmark paper. Use phd-benchmark-paper-template instead; the flowchart differs.
  • The user wants to polish Introduction prose that is already structured. Use phd-pre-submission-reviewer instead.
  • The user wants to evaluate whether the Introduction is ready for submission. Use phd-pre-submission-reviewer.

Core procedure

Step 1: Paper-type positioning

See: references/paper-types.md for the Technique versus New Problem/Setting distinction, positioning criteria, and worked examples from Alpha-SQL, AFlow, and LEAD.

Decide which type the paper is:

  • Technique Paper: main contribution is a new method or mechanism solving an existing problem. Narrative axis is Key Idea / Mechanism. Goal gets one sentence in passing.
  • New Problem/Setting Paper: main contribution is a new problem formulation. Narrative axis is Goal / Problem Formulation. Key Idea supports "why this definition is reasonable".

The positioning decides how much weight Paragraph 3 carries: in Technique papers it is a short bridge; in New Problem papers it is a load-bearing paragraph.

Step 2: Paragraph-by-paragraph outline

See: references/flowchart.md for each paragraph's canonical purpose, writing points, and common failures.

For each of the six paragraphs, return a mini-section containing:

  • Purpose: one sentence.
  • Writing points: three to five bullets derived from the user's inputs, each actionable.
  • Gaps: what the user's inputs do not yet cover for this paragraph. Tag each with severity (CRITICAL, MAJOR, MINOR).

Paragraphs:

  1. Background and Motivation. Running example. Why the problem matters in the real world.
  2. Limitations of existing work. At most three, each framed as "prior work X does not handle Y".
  3. Problem essence and Our Goal. Hard constraints explicit. In Technique papers this is a bridge; in New Problem/Setting papers this is the contribution itself.
  4. Key challenges. At most three, each explaining why naive extension of prior work fails.
  5. Solution overview. Each module addresses a challenge. Expect a one-to-one mapping between Paragraph 4 challenges and Paragraph 5 modules.
  6. Contributions. Three or four numbered bullets. Each maps to a section reference.

Step 3: Running example design

See: references/running-example.md for the design principles (real, specific, simple-yet-complete, recurring throughout), two design patterns (concrete-failure versus good-versus-bad), and worked examples.

If the user's inputs do not yet include a running example, propose two or three candidate examples and ask the user to pick. Record the chosen example in Paragraph 1 and make sure Paragraph 5 references it ("the Methodology section applies DynaGraph's hotspot detector to the running example from Section 1").

Step 4: Contribution alignment check

See: references/contribution-patterns.md for strong-versus-weak contribution patterns, anti-patterns, and the canonical mapping to section numbers.

For each contribution bullet, verify:

  • Maps to a challenge in Paragraph 4, a module in Paragraph 5, or a specific experiment result.
  • Specific, not vague ("comprehensive evaluation" is not a contribution).
  • Cites the section number that delivers it.

Step 5: Flowchart consistency check

Verify the six paragraphs form a single logical throughline:

  • Paragraph 1's running example is referenced in Paragraph 5 or a case study forecast.
  • Paragraph 2's limitations motivate Paragraph 4's challenges.
  • Paragraph 3's goal aligns with Paragraph 6's contribution 1.
  • Paragraph 4's challenges map one-to-one with Paragraph 5's modules.
  • Paragraph 5's modules appear in Paragraph 6's contribution 2 or 3.

Any break in the chain is a CRITICAL gap.

Step 6: Integrity gate

Before emitting the outline, run the checks in the Integrity gate section below.

Step 7: Output the outline

Emit the outline in the Output format below. For interactive mode, do not emit; converse one paragraph at a time.

Integrity gate

All seven bullets are [inspection] class: the LLM verifies each directly from its own output (counting, pattern-matching, or comparing sections). No user-side attestation required.

Before returning the outline:

  1. [inspection] Running example named in Paragraph 1 reappears in Paragraph 5 or 6 (or the Case Study forecast).
  2. [inspection] Limitations (Paragraph 2) are at most three and each is specific to a named prior work or a named capability.
  3. [inspection] Challenges (Paragraph 4) are at most three and each explains why a naive extension of prior work fails.
  4. [inspection] Challenge-to-module mapping is one-to-one, not one-to-many or many-to-one.
  5. [inspection] Contributions (Paragraph 6) are three or four and each maps to a section number.
  6. [inspection] No contribution is vague language ("extensive experiments", "thorough analysis" on their own).
  7. [inspection] Paper-type positioning from Step 1 is reflected in Paragraph 3's weight.

If any check fails, mark the paragraph as "needs user attention" and do not claim the outline is complete.

Output format

0. Type positioning

1. Paragraph 1: Background and Motivation

2. Paragraph 2: Limitations (at most 3)

3. Paragraph 3: Problem Essence and Our Goal

4. Paragraph 4: Key Challenges (at most 3)

5. Paragraph 5: Solution Overview

6. Paragraph 6: Contributions

7. Flowchart consistency

8. Integrity gate result

9. Severity summary

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 Phd Intro Drafter AI skill do?

Drafts a 6-paragraph Introduction outline for a technical paper from a structured Flowchart: background and running example, existing limitations, problem essence and goal, key challenges, solution overview, contributions. Positions the paper as Technique or New Problem/Setting and aligns contributions with challenges. Use when the user asks to 'draft the Introduction', 'outline the Introduction', 'intro logic needs clarifying', 'help structure the paper story', or before writing any Introduction prose.

Why use Phd Intro Drafter on TypingMind?

Because you install it once and use it with any model. Phd Intro Drafter 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 Phd Intro Drafter in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/Immortalqx/my_codex_skills/tree/main/phd-intro-drafter. 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 Phd Intro Drafter?

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 Phd Intro Drafter?

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

Is the Phd Intro Drafter AI skill free?

Yes. It is published on GitHub by Immortalqx under the MIT license. 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 👇