Academic Productivity with GenAI: A Researcher’s Guide

My Everyday Use of GenAI as a Researcher

Generative AI tools like ChatGPT, Gemini, and Claude have completely changed how I work as a researcher. As a postdoc and soon-to-be assistant professor, I use these tools in my workflow every day — from debugging code, to writing LaTeX and mentoring students. This post summarizes how I use GenAI in my academic life, with prompts and examples.

Confession: I used GPT+Gemini to help write this post about using GenAI.
(Yes, it’s meta! and I'm just the human in the loop.)

1. Research Ideation & Literature

First Attempt:

"What are existing models of polarization on networks?"

Better Prompt: [Use Gemini/ GPT + Deep Research]

First prompt: "Think like [your favorite author].If you were designing a polarization model with exposure-based updates and dynamic attention weights over a network, what structure and dynamics would matter most?
Do it in rounds, switch to be your own reviewer (critic) and revise.
Repeat the steps until no major critic comes up.”
Second prompt: “Revise your explanation into context with Econ-CS literature [venues like ACM-EC, econometrica, operations research]."

Pro Tips:

• Add the phrase "Think like [expert]" to nudge the model's reasoning.
  You can use your name if you have enough publications.
  If curious you can ask what is the style of “name” in writing to see what the model knows.

• Add venues to put in context

• Use "what would you criticize in this model?" to simulate reviewer perspective.

• Personal observation:
  One nice thing about Gemini compared to GPT in lit. review is that it will simply say “no relevant results” when there truly isn’t anything related, instead of forcing a weak connection.

• Chain prompts: idea → critique → extension.
  Idea Prompt

  "Propose a simple model of polarization on networks where each node updates its opinion based on a weighted average of its neighbors’ opinions, but with decreasing weight on opinions that differ too much."

  Critique Prompt

  "Now be a reviewer. What’s a potential limitation of this model in real social networks?"

  Extension Prompt

  "Revise the model to address one of those critiques."

• For calculations that need multiple steps add in your prompt
  “first devise a plan. and then carry out the plan.”

---

2. Writing & Formalization

Prompt:

"Write the LaTeX for the likelihood function of the Mallows model using $L_\alpha$ distance in style of [name of your target venue]. Assume item-wise additive form."

Pro Tips:

• Add: "Match the style of Annals of Probability".

• "Think like a mathematician. Don't make handwavy arguments."

• Iteratively refine with: "Now make it more readable" or "Formalize this into a lemma".

• You can upload picture of your handwriting and it will output the tex
  (mathpix also does it)

• Scispace [it’s a gpt app] is trained on papers. It’s specially helpful for retrieving references as it does not hallucinate publications.

• Multi-shot prompting: Give 2 examples of your writing, then ask GenAI to continue.

• GPT-o3 in my experience is the best for editing.

---

3. Simulation & Data Analysis

Basic Prompt:

"Simulate agent behavior in Python."

Expert Prompt:

First prompt “Understand the uploaded document using your analytical thinking. Don’t yet write anything”
Second prompt "Based on the model described in the document, write Python code to simulate strategic raters using a stopping rule based on expected future losses. Add Monte Carlo logic to estimate expected loss at each decision node."

Pro Tips:

• Add: "Explain each part in comments" or "Modularize it for reuse in pipelines".

• Debug tip: Copy-paste traceback error and ask: "What caused this? How do I fix it?"

• Ask for: "Rewrite this using multiprocessing" or "Add type hints and make it testable".

• Codex is the new tool openAI introduced which can be linked to your github,
  So when you ask for a task, it finds the right place in the code to add it and you can run the code along with your current repo to see the result.

---

4. Teaching, Slides, and Talks

Basic Prompt:

"Make slides about networks."

Better Prompt:

"Design a 20-minute talk titled 'The Hidden Web: How Network Data Powers Science and Society' for high school students. Include biological, transportation, and social network examples. End with 2 slides on how I used network theory in epidemic modeling."

Expert Prompt:

Give your talk to GPT (using the voice) slide by slide and ask for rephrasing for better “flow/engagement/ clarity” in the same tone I have.
Example “We’re writing a talk script. I’ll feed you paragraphs. Help me improve flow and clarity while keeping my style. At the end, we’ll make a slide deck”
By the end of your conversation you have a neat script.
At the end you can ask for PPT/beamer slide with visuals in “Downloadable” format
Example: Now make slides from this. Format for academic Beamer or modern PPT. Use icons or diagrams for each key concept. Output as a downloadable file

Pro Tips:

• Ask for: "Make it engaging for a non-technical audience".

• Add visual hints: "Suggest figures and analogies for each slide".

• Request a TikZ diagram or a matplotlib figure directly.

• Change color of figure
  Instead of asking it to “change the colors” of an image directly, it’s often better to say: “Use Python to read this image and remap the colors based on [your criteria].”
  This gives you more control, and in my experience, it leads to better, more reproducible results.

---

5. Reviewer Responses & Polishing

Basic Prompt:

"Respond to the reviewer."

Expert Prompt:

"Rephrase this paragraph to politely clarify that the reviewer misunderstood the role of $\alpha$ in the $L_\alpha$-Mallows model. Acknowledge the confusion, restate the definition, and emphasize the correct interpretation without sounding dismissive."

Pro Tips:

• Use: "Sound warm and collegial", "Make this tone more neutral".

• Ask: "How would a reviewer at [your target venue] interpret this?"

• Upload your paper and ask: “Be like a reviewer in Econ/CS [or your target venues here]. Are there any results in literature missing. Be critical about the paper”
  [use deep research for better result]

---

6. Projects [GPT’s Feature]

The Projects feature in ChatGPT is ideal for long-term tasks. Each project acts like a dedicated workspace with memory, files, and conversational history.

Why Projects Matter:

• In very long chats, the assistant can lose earlier context or drift from the original goals.

• With Projects, you can switch contexts quickly between ideas and return to each one with full memory retained.

How I Use Projects:

• Maintain separate spaces for distinct areas of research, each with memory of notation, assumptions, goals, and code.

• Build projects around manuscripts, teaching modules, or exploratory studies, storing slide scripts, model variants, or reviewer feedback.

Pro Tips:

• Summarize progress: "Summarize key findings and remaining tasks".

• Transition smoothly:
  you can start new chats in the project for a continuous transition
  "Continue from where we left off in this project".

• End-product ready: "Now convert this into a downloadable paper draft/slides".

7. Summarizing Talks [on YouTube] with Gemini

Gemini (Google’s multimodal AI) is the best at summarizing video content using transcripts and vision models. In my personal experience other competing products don’t work as well on youtube, and maps.

Basic Prompt:

"Summarize this YouTube lecture [give the link]l."

Expert Prompt:

"Summarize the main technical contributions and assumptions from this YouTube lecture. Focus on what makes it different from other models."

Pro Tips:

• Ask for timestamped insights:
  "List key moments with timestamps and what was discussed"

• Ask for lecture outline: "Break this into topics with slide-style bullet points"

8. Staying Updated with arXiv via GenAI

Generative AI can also streamline the process of keeping up with daily research updates on arXiv. Instead of skimming dozens of abstracts manually, you can automate a personalized filter.

Prompt:

"Search arXiv for new papers posted today (MM/DD/YYYY) in these categories: [use arxiv categories for example: Machine Learning (cs.LG), Artificial Intelligence (cs.AI), Social and Information Networks (cs.SI), General Economics (econ.GN), Statistical ML (stat.ML), and Applications (stat.AP). ]
Then, filter for relevance to these topics: [add your favorite topics here I do: Causal inference with interference or network data, Network science, Operations research / game theory applied to online platforms or social systems, Statistical or ML methods for social, economic, or recommendation systems]
For each relevant paper, return: - 📌 Title - ✍️ Authors - 🔗 arXiv link - 📄 2–4 bullet-point summary (provide main technical contribution, and main conceptual contribution) - 🧪 Code/data availability if stated
Skip these topics [add topics that may seem related but you don’t want for me I say: physics, or pure math papers unless applied to the above topics. ]
Only include papers posted today."

Pro Tips:

• Use domain filters:
  "Focus on preference learning under uncertainty"

• Ask for structured output: "Summarize in markdown table with tags for relevance"

• Use the following code to get daily updates on your email:

Code Snippet (Python using arXiv API + OpenAI):

import feedparser
import datetime
import os
from dotenv import load_dotenv
import openai
import yagmail

# Load environment variables
load_dotenv()

# Configuration
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
USE_OPENAI_SUMMARY = os.getenv("USE_OPENAI_SUMMARY", "false").lower() == "true"
EMAIL_USER = os.getenv("EMAIL_USER")
EMAIL_PASS = os.getenv("EMAIL_PASS")
EMAIL_RECIPIENT = os.getenv("EMAIL_RECIPIENT")

openai.api_key = OPENAI_API_KEY
print("🔐 Using OpenAI key:", OPENAI_API_KEY[:5] + "...masked")

# Categories of interest
CATEGORIES = [
    "cs.LG", "cs.SI", "cs.AI", "cs.CL",
    "stat.ML", "stat.AP", "econ.GN" # change this for your liking
]

ARXIV_API = "http://export.arxiv.org/api/query?search_query="

def build_query():
    category_query = "+OR+".join([f"cat:{cat}" for cat in CATEGORIES])
    return f"{ARXIV_API}({category_query})&sortBy=submittedDate&sortOrder=descending&max_results=100"

def summarize(text):
    if not USE_OPENAI_SUMMARY or not OPENAI_API_KEY:
        return text
    try:
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are an expert research assistant. Given an arXiv abstract, determine if the paper is relevant to one or more of the following topics:\n\n🎯 Relevance Topics\n- [add your topics here]\n\n🧪 For each relevant abstract, return:\n- 📌 Title\n- ✍️ Authors\n- 🔗 arXiv link\n- 📄 2–4 bullet points summarizing:\n  - the core method or contribution\n  - key results or theorems\n  - application domain \n  - why it's relevant to one or more of the topics above\n- 🧪 Note if code or data is provided\n\nIf the paper is not clearly relevant, return a one-line note stating 'This paper does not match the listed topics.'"},
                {"role": "user", "content": text}
            ],
            max_tokens=500,
            temperature=0.3,
        )
        print("🔁 OpenAI raw response:", response)
        return response.choices[0].message.content.strip()
    except Exception as e:
        print("❌ OpenAI summary failed:", e)
        return "OpenAI summary failed"

def fetch_today_papers():
    feed = feedparser.parse(build_query())
    today = datetime.datetime.now(datetime.timezone.utc).date()
    results = []
    print(f"Found {len(feed.entries)} total entries from arXiv.")
    for entry in feed.entries:
    	print(entry)
        published_date = datetime.datetime(*entry.published_parsed[:6]).date()
        if published_date == today:
            raw_summary = entry.summary.replace("\n", " ").strip()
            summary = summarize(raw_summary)
            print("\n---")
            print(f"📌 Title: {entry.title}")
            print(f"🔗 Link: {entry.link}")
            print(f"📄 GPT Summary Preview:\n{summary[:500]}\n")
     
             results.append({
                    "title": entry.title,
                    "authors": entry.author,
                    "link": entry.link,
                    "summary": summary
                })
    return results
def format_email(papers):
    if not papers:
        return "No new relevant arXiv papers today."
    lines = ["📚 New arXiv Papers for Today\n"]
    for p in papers:
        lines.append(f"**{p['title']}**")
        lines.append(f"Authors: {p['authors']}")
        lines.append(f"Link: {p['link']}")
        lines.append(f"Summary:\n{p['summary']}\n")
        lines.append("---\n")
    return "\n".join(lines)

def send_email(body):
    yag = yagmail.SMTP(user=EMAIL_USER, password=EMAIL_PASS)
    yag.send(to=EMAIL_RECIPIENT, subject="📄 Daily arXiv Digest", contents=body)
    print("✅ Email sent successfully.")

def main():
    papers = fetch_today_papers()
    email_body = format_email(papers)
    send_email(email_body)

if __name__ == "__main__":
    main()

You can use cron to get your custom research feed each morning. You also need to setup .env file with your api key and mailing address for this code to work.

---

Acknowledgments

I'm really grateful to everyone who gave thoughtful feedback as I worked on this post. Special thanks to Amin Saberi, Christian Borgs, Kate Donahue, Karissa Huang, Geng Zhao, and Christian Ikeokwu for their generous input and suggestions.

---