Paper 2 Dynamic

Transform academic research papers into multiple presentation and promotional formats including slide decks, blog posts, social media threads, and video scripts. This skill covers content extraction, format-specific adaptation, audience targeting, and automated multi-format output generation.

When to Use This Skill

Choose Paper 2 Dynamic when you need to:

• Convert a research paper into a conference presentation or slide deck
• Generate a blog post or press release from a technical publication
• Create social media threads summarizing key findings for public audiences
• Produce multiple communication formats from a single paper simultaneously

Consider alternatives when:

• You need to write original research papers (use academic writing tools)
• You need citation management and formatting (use Zotero or LaTeX)
• You need peer review or manuscript editing (use specialized editing services)

Quick Start

Copy
# Install required packages
pip install markitdown pdfplumber python-pptx jinja2

Copy
from markitdown import MarkItDown
import json

# Extract paper content
md = MarkItDown()
result = md.convert("research_paper.pdf")
paper_text = result.text_content

# Parse into sections
def parse_paper_sections(text):
    """Extract major sections from a paper."""
    sections = {}
    current_section = "preamble"
    current_content = []

    for line in text.split("\n"):
        if line.startswith("## ") or line.startswith("# "):
            if current_content:
                sections[current_section] = "\n".join(current_content)
            current_section = line.lstrip("# ").strip()
            current_content = []
        else:
            current_content.append(line)

    if current_content:
        sections[current_section] = "\n".join(current_content)

    return sections

sections = parse_paper_sections(paper_text)
print(f"Found sections: {list(sections.keys())}")

Core Concepts

Output Formats

Format	Audience	Key Adaptations
Slide deck	Conference attendees	Visual, one idea per slide, minimal text
Blog post	General technical audience	Accessible language, context, implications
Twitter thread	Public audience	Ultra-concise, hook-driven, numbered
Press release	Media and public	Newsworthy angle, quotes, impact
Video script	YouTube / lecture	Conversational, visual cues, pacing
Executive summary	Decision makers	Business impact, actionable insights
Poster	Conference attendees	Visual hierarchy, key figures, QR code

Automated Slide Deck Generation

Copy
from pptx import Presentation
from pptx.util import Inches, Pt

def paper_to_slides(sections, output_path="presentation.pptx"):
    """Convert paper sections to a slide deck."""
    prs = Presentation()

    # Title slide
    slide = prs.slides.add_slide(prs.slide_layouts[0])
    slide.shapes.title.text = sections.get("preamble", "Research Paper")[:80]
    slide.placeholders[1].text = "Conference Presentation"

    # Section mapping to slides
    slide_map = {
        "Abstract": ("Overview", "Key findings and contributions"),
        "Introduction": ("Background & Motivation", "Why this research matters"),
        "Methods": ("Methodology", "How we approached the problem"),
        "Results": ("Key Results", "What we found"),
        "Discussion": ("Implications", "What this means for the field"),
        "Conclusion": ("Summary & Future Work", "Takeaways and next steps")
    }

    for section_name, (slide_title, subtitle) in slide_map.items():
        content = sections.get(section_name, "")
        if not content:
            continue

        slide = prs.slides.add_slide(prs.slide_layouts[1])
        slide.shapes.title.text = slide_title

        # Extract key points (first 3 sentences)
        sentences = [s.strip() for s in content.split(".") if len(s.strip()) > 20]
        bullet_text = "\n".join(f"• {s}." for s in sentences[:4])

        slide.placeholders[1].text = bullet_text

    prs.save(output_path)
    print(f"Saved {len(prs.slides)} slides to {output_path}")

paper_to_slides(sections)

Blog Post Generation

Copy
def paper_to_blog(sections, audience="technical"):
    """Convert paper sections into a blog post draft."""
    blog = []

    # Title and hook
    title = sections.get("preamble", "Research Findings").split("\n")[0]
    blog.append(f"# {title}\n")

    # Opening hook from abstract
    abstract = sections.get("Abstract", "")
    if abstract:
        sentences = abstract.split(".")
        hook = sentences[0].strip() + "." if sentences else ""
        blog.append(f"{hook}\n")

    # Context from introduction
    intro = sections.get("Introduction", "")
    if intro:
        blog.append("## Why This Matters\n")
        # First 2-3 sentences for context
        context = ". ".join(intro.split(".")[:3]) + "."
        blog.append(f"{context}\n")

    # Methods simplified
    methods = sections.get("Methods", "")
    if methods:
        blog.append("## The Approach\n")
        if audience == "general":
            blog.append("In straightforward terms, the researchers:\n")
        blog.append(f"{methods[:500]}...\n")

    # Results as highlights
    results = sections.get("Results", "")
    if results:
        blog.append("## Key Findings\n")
        blog.append(f"{results[:600]}...\n")

    # Implications
    discussion = sections.get("Discussion", "")
    if discussion:
        blog.append("## What This Means\n")
        blog.append(f"{discussion[:400]}...\n")

    return "\n".join(blog)

blog_draft = paper_to_blog(sections, audience="technical")
print(blog_draft)

Configuration

Parameter	Description	Default
input_format	Paper file format (PDF, DOCX, LaTeX)	Auto-detect
output_formats	Target formats to generate	["slides"]
audience	Target audience level	"technical"
max_slides	Maximum slides in deck	15
blog_length	Target blog post word count	1000
include_figures	Extract and include paper figures	true

Best Practices

1. Extract figures separately from text — Paper figures carry critical information that text extraction misses. Use pdfplumber or PyMuPDF to extract images from the PDF and include them in the generated outputs. A slide deck without the paper's key figures is incomplete.

2. Adapt language to the target audience — A conference slide deck can use field-specific jargon, but a blog post should define technical terms. Create audience profiles (expert, technical, general) and adjust vocabulary, sentence complexity, and assumed background knowledge accordingly.

3. Preserve the narrative arc — Every paper tells a story: problem → approach → findings → impact. Maintain this arc regardless of output format. A Twitter thread still needs the hook (problem), method (approach), and punchline (finding), just compressed.

4. Verify extracted facts against the original — Automated extraction can garble numbers, misattribute findings, or lose context. Always cross-check generated outputs against the original paper, especially for quantitative claims, statistical results, and author attributions.

5. Generate outputs iteratively — Start with the slide deck (most structured), then adapt to blog post (adds context), then social media (compresses). Each subsequent format builds on the previous one's distillation rather than re-extracting from the raw paper.

Common Issues

PDF text extraction produces garbled output — Two-column paper layouts often interleave text from both columns. Use pdfplumber with column detection: extract text boxes with their coordinates and sort by column position before joining. LaTeX-generated PDFs generally extract cleanly; scanned PDFs require OCR first.

Generated slides have too much text — The template defaults to copying entire paragraphs. Limit each slide's body to 4-5 bullet points of 10-15 words each. Extract only topic sentences or key claims from each section rather than full paragraphs.

Social media threads lose technical accuracy — Compressing complex findings into 280 characters risks oversimplification or misrepresentation. Always include a link to the full paper, use qualifiers ("suggests" vs "proves"), and have a domain expert review threads before posting.