Research Planning

Research Planning

Create comprehensive research plans and paper architectures from a research topic or idea.

Input

• $0 — Research topic, idea description, or paper to reproduce

References

• Planning prompts from Paper2Code, AI-Researcher, AgentLaboratory: ~/.claude/skills/research-planning/references/planning-prompts.md
• Output schemas and templates: ~/.claude/skills/research-planning/references/output-schemas.md

Workflow

Step 1: Understand the Research Context

• Read any provided papers, code, or references
• Identify the core research question and its significance
• Assess available resources (datasets, compute, existing code)

Step 2: Generate Research Plan

Use the 4-stage planning approach (adapted from Paper2Code):

1. Overall Plan — Strategic overview: methodology, key experiments, evaluation metrics 2. Architecture Design — File structure, system design, Mermaid class/sequence diagrams 3. Logic Design — Task breakdown with dependencies, required packages, shared knowledge 4. Configuration — Extract or specify hyperparameters, training details, config.yaml

Step 3: Structure the Paper

Design the paper structure with section-by-section plan:

• Abstract, Introduction, Background, Related Work, Methods, Experiments, Results, Discussion/Conclusion
• For each section: key points to cover, required figures/tables, target word count

Step 4: Create Task Dependency Graph

• Order tasks by dependency (data → model → training → evaluation → writing)
• Identify parallelizable tasks
• Flag risks and potential failure modes

Output Format

{
  "research_question": "...",
  "methodology": "...",
  "paper_structure": {
    "sections": ["Abstract", "Introduction", ...],
    "section_plans": { "Introduction": "..." }
  },
  "task_list": [
    {"task": "...", "depends_on": [], "priority": 1}
  ],
  "baselines": ["..."],
  "datasets": ["..."],
  "evaluation_metrics": ["..."],
  "risks": ["..."]
}

Rules

• Each plan component must be detailed and actionable
• Include specific implementation references when available
• Ensure all components work together coherently
• Always include a testing/evaluation plan
• Flag ambiguities explicitly rather than making assumptions

Related Skills

• Upstream: idea-generation, literature-review
• Downstream: experiment-design, paper-assembly
• See also: atomic-decomposition

Research Planning Output Schemas

Complete Research Plan Schema

{
  "research_question": "What is the core research question?",
  "significance": "Why does this matter?",
  "methodology": {
    "approach": "High-level approach description",
    "key_techniques": ["technique1", "technique2"],
    "assumptions": ["assumption1", "assumption2"]
  },
  "paper_structure": {
    "sections": [
      {
        "name": "Abstract",
        "key_points": ["TL;DR", "contribution", "key result"],
        "target_words": 250
      },
      {
        "name": "Introduction",
        "key_points": ["motivation", "problem statement", "contributions"],
        "target_words": 800,
        "figures": ["fig:teaser"]
      },
      {
        "name": "Background",
        "key_points": ["problem formalization", "notation", "prerequisites"],
        "target_words": 500
      },
      {
        "name": "Related Work",
        "key_points": ["theme1: ...", "theme2: ...", "positioning"],
        "target_words": 600
      },
      {
        "name": "Methods",
        "key_points": ["algorithm description", "theoretical analysis"],
        "target_words": 1200,
        "figures": ["fig:architecture"],
        "equations": ["objective function", "update rule"]
      },
      {
        "name": "Experiments",
        "key_points": ["setup", "baselines", "main results", "ablations"],
        "target_words": 1500,
        "tables": ["tab:main_results", "tab:ablation"],
        "figures": ["fig:training_curves", "fig:comparison"]
      },
      {
        "name": "Conclusion",
        "key_points": ["summary", "limitations", "future work"],
        "target_words": 400
      }
    ]
  },
  "implementation": {
    "file_list": ["main.py", "model.py", "trainer.py", "evaluate.py"],
    "class_diagram": "classDiagram\n  class Model { ... }\n  ...",
    "sequence_diagram": "sequenceDiagram\n  ...",
    "required_packages": ["torch>=2.0", "numpy", "matplotlib"]
  },
  "task_list": [
    {
      "id": 1,
      "task": "Implement data loading pipeline",
      "depends_on": [],
      "priority": "high",
      "estimated_complexity": "low"
    },
    {
      "id": 2,
      "task": "Implement model architecture",
      "depends_on": [1],
      "priority": "high",
      "estimated_complexity": "medium"
    },
    {
      "id": 3,
      "task": "Implement training loop",
      "depends_on": [1, 2],
      "priority": "high",
      "estimated_complexity": "medium"
    },
    {
      "id": 4,
      "task": "Run baseline experiments",
      "depends_on": [3],
      "priority": "high",
      "estimated_complexity": "low"
    },
    {
      "id": 5,
      "task": "Run ablation studies",
      "depends_on": [4],
      "priority": "medium",
      "estimated_complexity": "medium"
    },
    {
      "id": 6,
      "task": "Generate figures and tables",
      "depends_on": [4, 5],
      "priority": "medium",
      "estimated_complexity": "low"
    },
    {
      "id": 7,
      "task": "Write paper",
      "depends_on": [6],
      "priority": "high",
      "estimated_complexity": "high"
    }
  ],
  "experiment_design": {
    "baselines": ["Baseline1", "Baseline2"],
    "datasets": ["Dataset1", "Dataset2"],
    "evaluation_metrics": ["accuracy", "F1", "inference_time"],
    "hyperparameters": {
      "learning_rate": 0.001,
      "batch_size": 64,
      "epochs": 100
    },
    "ablation_components": ["component_A", "component_B", "component_C"],
    "num_seeds": 3
  },
  "risks": [
    {
      "risk": "Method may not scale to large datasets",
      "mitigation": "Start with small-scale experiments, profile memory usage",
      "severity": "medium"
    }
  ]
}

Mermaid Diagram Templates

Class Diagram

classDiagram
    class Main {
        +__init__()
        +run_experiment()
    }
    class DatasetLoader {
        +__init__(config: dict)
        +load_data() -> DataLoader
        +preprocess(raw_data) -> Tensor
    }
    class Model {
        +__init__(params: dict)
        +forward(x: Tensor) -> Tensor
    }
    class Trainer {
        +__init__(model: Model, data: DataLoader)
        +train(epochs: int) -> dict
        +validate() -> dict
    }
    class Evaluator {
        +__init__(model: Model, data: DataLoader)
        +evaluate() -> dict
        +generate_plots() -> None
    }
    Main --> DatasetLoader
    Main --> Trainer
    Main --> Evaluator
    Trainer --> Model
    Evaluator --> Model

Sequence Diagram

sequenceDiagram
    participant M as Main
    participant DL as DatasetLoader
    participant MD as Model
    participant TR as Trainer
    participant EV as Evaluator

    M->>DL: load_data()
    DL-->>M: train_loader, val_loader, test_loader
    M->>MD: initialize model(config)
    M->>TR: train(model, train_loader, val_loader)
    loop Each Epoch
        TR->>MD: forward(batch)
        MD-->>TR: predictions
        TR->>TR: compute_loss()
        TR->>TR: backward()
        TR->>TR: validate()
    end
    TR-->>M: training_results
    M->>EV: evaluate(model, test_loader)
    EV->>MD: forward(test_batch)
    MD-->>EV: predictions
    EV-->>M: metrics
    M->>EV: generate_plots()

Research Planning Prompts Reference

Paper2Code: 4-Turn Planning Conversation

Turn 1 — Overall Plan

System:

You are an expert researcher and strategic planner with a deep understanding of experimental design and reproducibility in scientific research.
You will receive a research paper or idea description.
Your task is to create a detailed and efficient plan to implement the methodology described.

Instructions:
1. Align with the Paper/Idea: Your plan must strictly follow the methods, datasets, model configurations, hyperparameters, and experimental setups described.
2. Be Clear and Structured: Present the plan in a well-organized and easy-to-follow format, breaking it down into actionable steps.
3. Prioritize Efficiency: Optimize the plan for clarity and practical implementation while ensuring fidelity to the original design.

User:

## Research Context
{research_description}

## Task
1. We want to implement the method described above.
2. Before writing any code, outline a comprehensive plan that covers:
   - Key details from the Methodology
   - Important aspects of Experiments, including dataset requirements, experimental settings, hyperparameters, or evaluation metrics
3. The plan should be as detailed and informative as possible to help us write the final code later.

## Requirements
- Focus on a thorough, clear strategy
- If something is unclear, mention it explicitly

## Instruction
The response should give us a strong roadmap, making it easier to write the code later.

Turn 2 — Architecture Design (File List + UML)

User:

Based on the plan, please design a concise, usable, and complete software system.
Keep the architecture simple and make effective use of open-source libraries.

## Format
{
    "Implementation approach": "We will ...",
    "File list": ["main.py", "model.py", "trainer.py", "evaluation.py"],
    "Data structures and interfaces": "classDiagram\n    class Main { ... }\n    class Model { ... }\n    Main --> Model\n",
    "Program call flow": "sequenceDiagram\n    participant M as Main\n    M->>DL: load_data()\n    ...\n",
    "Anything UNCLEAR": "Need clarification on ..."
}

Turn 3 — Logic Design (Task List + Dependencies)

User:

Break down tasks according to the technical design, generate a task list, and analyze task dependencies.

## Format
{
    "Required packages": ["numpy==1.21.0", "torch==1.9.0"],
    "Logic Analysis": [
        ["dataset_loader.py", "DatasetLoader class handles loading and preprocessing..."],
        ["model.py", "Defines the model architecture..."],
        ["main.py", "Entry point orchestrating training and evaluation..."]
    ],
    "Task list": ["dataset_loader.py", "model.py", "trainer.py", "evaluation.py", "main.py"],
    "Shared Knowledge": "Both trainer.py and evaluation.py share the model forward pass...",
    "Anything UNCLEAR": "..."
}

Turn 4 — Configuration Extraction

User:

Extract the training details (e.g., learning rate, batch size, epochs, etc.) and generate config.yaml.
DO NOT FABRICATE DETAILS — only use what is provided.

---

AI-Researcher: Plan Agent

System Instructions

You are a Machine Learning Expert tasked with creating a detailed implementation plan for innovative ML projects.

WORKFLOW:
1. Code Review Phase
   - Review codebase structure and examine specific implementations
   - Document key implementation patterns and useful components

2. Planning Phase — Must include:
   a. Dataset Plan
      - Dataset Description, Location, Task Definition
      - Data loading pipeline (read → preprocess → dataloader)

   b. Model Plan (from survey notes)
      - Math formula, Implementation details
      - Reference codebases and papers

   c. Training Plan
      - Training pipeline, Loss functions
      - Optimization strategy, Training configurations
      - Monitoring and logging

   d. Testing Plan
      - Test metrics, Test dataset preparation, Test code

REQUIREMENTS:
- MUST thoroughly review all provided resources before planning
- Each plan component must be detailed and actionable
- Include specific implementation references from codebases
- Testing plan is mandatory with specific metrics and success criteria

Plan Tool Schemas

plan_dataset:

{
    "dataset_description": "...",
    "dataset_location": "...",
    "task_definition": "...",
    "data_processing": {
        "read_data": "...",
        "data_preprocessing": "...",
        "data_dataloader": "..."
    }
}

plan_training:

{
    "training_pipeline": "...",
    "loss_function": "...",
    "optimizer": "...",
    "training_configurations": "...",
    "monitor_and_logging": "..."
}

plan_testing:

{
    "test_metric": "...",
    "test_data": "...",
    "test_function": "..."
}

---

AgentLaboratory: Postdoc-PhD Dialogue Planning

Postdoc Role (Plan Formulation)

You are directing a PhD student to help them come up with a good plan, and you interact with them through dialogue.
Your goal is to produce plans that would make good experiments for the given topic.
You should aim for a very simple experiment that showcases your plan, not a complex one.
You should integrate the provided literature review and come up with plans on how to expand and build on these works for the given topic.
Your plans should provide a clear outline for how to achieve the task, including what machine learning models to use and implement, what types of datasets should be searched for and used to train the model, and the exact details of the experiment.
Your idea should be very innovative and unlike anything seen before.

PhD Student Role

You are a PhD student being directed by a postdoc who will help you come up with a good plan, and you interact with them through dialogue.
[Same goals as Postdoc, but from student perspective]

Commands

• DIALOGUE — Continue the planning conversation
• PLAN — Submit the final plan (ends the dialogue)

Plan Submission Format

[Clear outline including:

• Machine learning models to use and implement
• Datasets to search for and use
• Exact experiment details
• Evaluation metrics and success criteria]