Skip to content

OUTLINE.md

Latest commit

 

History

History
253 lines (191 loc) · 7.61 KB

OUTLINE.md

File metadata and controls

253 lines (191 loc) · 7.61 KB

Claude Code Tutorial: End-to-End Course Outline

A practical introduction to Claude Code for academics and researchers—beyond coding, into real-world task automation, writing, and analysis.

Part 0: Prerequisites & Philosophy

  • Who this is for: Students, researchers, academics with no prior CLI or AI coding assistant experience
  • What Claude Code is: A terminal-based AI assistant that can read, write, and execute code in your projects
  • What we'll learn: Not just coding—paper writing, data analysis, automation, bioinformatics workflows, website building
  • Philosophy: Learn by doing; we make mistakes and fix them together

Part 1: Environment Setup

1.1 Installing Visual Studio Code

  • Download and install VS Code
  • Brief tour of the interface (sidebar, terminal, extensions)
  • Installing the terminal / understanding the integrated terminal

1.2 [Branch] Creating an Anthropic Account

Optional section for those without an account

  • Navigating to console.anthropic.com
  • Account creation steps
  • API key generation and storage (security note: never commit keys)
  • Academic/student tier considerations
    • Current pricing model
    • Free tier limitations (if any)

1.3 [Branch] Setting Up GitHub

Optional section for those new to GitHub

  • Creating a GitHub account
  • Authentication options (this is where it gets annoying):
    • SSH keys: generation, adding to GitHub, testing connection
    • Personal Access Tokens (PAT): creation, scopes, storing securely
    • GitHub CLI (gh auth login) as the simplest path
  • Troubleshooting common auth errors

1.4 Installing Claude Code

  • Prerequisites check (Node.js if required)
  • Installation command
  • First launch and authentication
  • Verifying the installation works

Part 2: First Steps with Claude Code

2.1 The Basics

  • Starting Claude Code in a project
  • The conversation interface
  • Understanding what Claude can "see" (your codebase, terminal)
  • Basic commands: asking questions, requesting edits

2.2 Core Workflow

  • Reading and understanding code
  • Making edits through conversation
  • Running commands (build, test, git)
  • The approve/reject cycle for changes

2.3 Project Initialization

  • Creating a new project from scratch with Claude Code
  • .gitignore, README, basic structure
  • First commit and push

Part 3: Demonstration Track A — Data Analysis & Bioinformatics

Choose one or work through both

3.A.1 Meta-Analysis: Cell Type Mapping Tools

Goal: Determine which of 5 cell type mapping tools is most cited/used in practice

Steps:

  1. Define the 5 tools to compare (e.g., CellTypist, scType, Azimuth, SingleR, scArches)
  2. Use an MCP (or web search) to find citation counts for each original paper
  3. Search for papers that cite these tools
  4. For papers with open full text, parse which tool was actually used
  5. Tally results and handle ambiguities
  6. Generate a summary plot (bar chart of usage)

Learning outcomes:

  • Working with MCPs for literature search
  • Parsing and summarizing text data
  • Data visualization with Python/R
  • Handling real-world messiness in data

3.A.2 Alternative: Protein Structure Visualization

Goal: Visualize a protein binding site using PyMol despite no prior PyMol knowledge

Steps:

  1. Identify a protein of interest (e.g., from a recent paper)
  2. Download structure from PDB
  3. Install PyMol (or use web viewer)
  4. Ask Claude Code to generate PyMol commands for:
    • Loading the structure
    • Highlighting the binding site
    • Coloring by residue properties
    • Generating publication-quality images
  5. Iterate on visualization aesthetics

Learning outcomes:

  • Using Claude Code to learn unfamiliar tools
  • Structural biology basics
  • Scripting PyMol

3.A.3 Alternative: Reverse-Engineering Oligo Design (TRISCO)

Goal: Understand and reproduce the oligo design logic from Kanatani et al.

Steps:

  1. Obtain the paper and supplementary materials
  2. Identify the oligo sequences used
  3. Ask Claude Code to help understand the design principles
  4. Reverse-engineer the rules/constraints
  5. Attempt to design new oligos following the same logic
  6. Validate designs (in silico checks)

Learning outcomes:

  • Reading and interpreting methods sections
  • Primer/oligo design principles
  • Systematic reverse-engineering with AI assistance

Part 4: Demonstration Track B — Paper Writing Support

4.1 Citation Recovery with PubMed MCP

Goal: Take an introduction paragraph stripped of citations and systematically find and insert appropriate references

Setup:

  • A sample introduction (provided) with [CITATION NEEDED] markers
  • PubMed MCP configured

Steps:

  1. Read the introduction, identify claims needing citations
  2. For each claim:
    • Formulate a PubMed search query
    • Review returned papers
    • Select the most appropriate reference
    • Insert citation in proper format
  3. Generate a bibliography
  4. Review for coherence and citation quality

Learning outcomes:

  • Using MCPs for literature search
  • Critical evaluation of sources
  • Academic writing workflow
  • Bibliography management

4.2 Extended: Full Paper Section Workflow

Optional deeper dive

  • Outlining a methods section
  • Generating figure legends
  • Consistency checking across sections
  • Exporting to LaTeX/Word

Part 5: Beyond the Demos — Other Use Cases

5.1 LaTeX Document Preparation

  • Setting up a LaTeX project
  • Claude Code for equation formatting
  • Managing bibliographies with BibTeX
  • Compiling and troubleshooting errors

5.2 Automating Repetitive Tasks

  • Batch file renaming/organization
  • Data format conversion
  • Scheduled scripts and cron jobs

5.3 Building a Simple Website

  • Static site generators (Jekyll, Hugo, Quarto)
  • Deploying to GitHub Pages
  • Basic HTML/CSS with AI assistance

5.4 Bioinformatics Tool Integration

  • Installing and configuring common tools (samtools, bedtools, etc.)
  • Pipeline construction
  • Working with SLURM/HPC environments

Part 6: Best Practices & Tips

6.1 Effective Prompting

  • Being specific about what you want
  • Providing context
  • Iterating on responses

6.2 Safety and Review

  • Always review suggested changes
  • Understanding what commands do before approving
  • Sensitive data considerations

6.3 When Claude Code Struggles

  • Complex multi-file refactors
  • Domain-specific knowledge gaps
  • Knowing when to take manual control

6.4 Keeping Up to Date

  • Claude Code updates
  • New MCPs and integrations
  • Community resources

Appendices

Appendix A: Troubleshooting

  • Common installation issues
  • GitHub authentication problems
  • API key and billing issues

Appendix B: MCP Setup Guide

  • What are MCPs?
  • Installing the PubMed MCP
  • Other useful MCPs for academics

Appendix C: Glossary

  • CLI, API, MCP, SSH, PAT, etc.

Appendix D: Resources

  • Official Claude Code documentation
  • Community forums
  • Related tutorials

Format Considerations (Internal Note)

Format Pros Cons
Jupyter Notebook Interactive, runnable code, familiar to academics Linear, no branching, heavy for text-focused sections
HTML (Quarto/MkDocs) Branching, searchable, expandable sections, embeds Requires build step, less interactive
LaTeX → PDF Polished, printable, academic-friendly Static, no interactivity, no branching
Hybrid Best of both: HTML for navigation + embedded notebooks for demos More complex to maintain

Recommendation: Quarto with embedded executable code blocks—gives you HTML output with optional PDF export, supports branching navigation, and can execute Python/R.

Last updated: January 2026