Vibe Coding for Scientists

Production Systems

Reliability, monitoring, error handling, logging, deployment pipelines

Cost Management

Token optimization, caching strategies, model selection, budget tracking

Evaluation & Testing

Systematic prompt testing, output validation, regression testing, performance benchmarks

Architecture Patterns

RAG implementations, agent frameworks, multi-model orchestration, state management

✓ Understanding AI Capabilities & Limits

You've learned what LLMs can and cannot do reliably through direct experience

✓ Prompt Engineering Fundamentals

Clear communication with LLMs, context management, specification clarity

✓ Application Architecture Patterns

FastAPI structures, data flow, API design from generated applications

✓ Debugging Intuition

Pattern recognition for common errors, understanding stack traces

✓ Python Ecosystem Familiarity

Package management, virtual environments, common libraries

✓ Scientific Domain Knowledge

Your research problem understanding—this doesn't change

Multiple Users

Your tool needs to serve colleagues or external users reliably

High Frequency Use

Running hundreds or thousands of times per day with cost implications

Critical Research Path

Failures would significantly impact research outcomes or timelines

Publication/Reproducibility

Need to publish methods or share with the scientific community

Complex LLM Workflows

Multi-step agent systems, RAG implementations, or custom fine-tuning

Career Direction

Moving toward computational roles or building AI-powered products

1. Clear Objective

What does your app need to do?

• State the core function plainly
• Use domain-specific terminology
• Avoid vague language

2. Scientific Context

Why does this exist?

• Reference established methods
• Link to protocols or papers
• Specify your research domain

3. Honest Constraints

What are you handling manually?

• Environment setup (venv, etc.)
• Package installation
• Platform specifics (macOS, Linux)

Why this worked:

• Clear objective: "Confluence Assessment for cells"
• Domain specified: "life sciences"
• Reference provided: Thermo Fisher methodology URL
• Honest about manual steps: venv and requirements handled separately
• Platform implied: "local" means not cloud/web-based

📋 UI Mockups

Interactive HTML viewer showing main window, settings panel, batch processing interface

🔄 Data Flow Diagram

SVG showing 7-step processing pipeline with timing estimates

🏗️ Architecture Design

Technology stack recommendations and system architecture

📁 Project Structure

confluence-assessment/
├── src/
│   ├── main.py
│   ├── config.py
│   ├── image_processing.py
│   ├── batch_processor.py
│   └── models.py
├── templates/
│   ├── index.html
│   ├── results.html
│   └── batch.html
├── uploads/
├── outputs/
└── requirements.txt

📊 Performance Achieved

• ⚡ ~130ms processing time
• 🎯 85-95% accuracy vs manual
• 📦 FastAPI + HTMX + Tailwind
• ✅ Batch processing capable

🤖 In Claude

1. Create a new Project for this work
2. Copy the initial prompt (from Step 1 above)
3. Request UI mockups and architecture diagrams
4. Download artifacts as HTML/SVG files
5. Ask Claude to refine specifications if needed

⌨️ In Cursor AI

1. Create project directory structure
2. Set up venv: python3 -m venv venv
3. Reference Claude's files in Cursor prompt
4. Generate code with Sonnet 4.5
5. Test, debug, iterate with Cursor

🧠 Brain 1: The Scientist (Claude Opus)

Purpose: High-level reasoning and scientific strategy

Why Opus?

• Better at "holding the whole problem in its head"
• Spots subtle scientific flaws (data leakage, biological violations)
• Provides nuanced analysis of algorithm implications

Output: Text specification or detailed blueprint

⚙️ Brain 2: The Builder (Cursor Sonnet)

Purpose: Implementation and code generation

Why Sonnet?

• Superior at coding mechanics (imports, syntax, refactoring)
• Better file management and multi-file edits
• Fewer syntax errors, better edge case handling

Output: Production-ready code

I am designing a GNN for drug discovery. I need to engineer edge features
based on bond type and stereochemistry. Review standard literature (like RDKit
conventions) and propose a robust JSON schema for these features. Warn me about
potential edge cases with disconnected graphs.

# Edge Features Specification

## Feature Schema
[JSON or structured description]

## Constraints
- No null values in bond types
- Must handle disconnected atoms
- Stereochemistry: must preserve 3D orientation

## Edge Cases
- Aromatic bonds: treat as hybrid sp2
- Implicit hydrogens: RDKit convention

Read `specs/edge_features_spec.md`. Create a new file `features/bond_processing.py`.
Implement the `BondFeaturizer` class described in the spec. Use `rdkit` and
`torch_geometric`. Ensure strict typing.

Integrate the BondFeaturizer into `data/molecule_loader.py`.
Update the `__getitem__` method to use the new edge features.
Also update `config/train_config.yaml` with new feature dimensions.

1. Separate Strategy from Execution

Opus = "What and Why" | Sonnet = "How and When"

2. Use Specs as Bridges

Write down Opus reasoning before asking Sonnet to code. Reduces iteration cycles by 50%+

3. Cursor Composer is Your Multiplier

Use Cmd+I to edit multiple files at once. Perfect for features that span multiple modules

4. Always Review Output

Sonnet is "too agreeable"—check for data leakage, silent column drops, assumption mismatches

5. Iterate Rapidly

Each cycle takes 5-10 minutes. 4 cycles = polished, production-ready module

✓ Static HTML/CSS/JS sites

Single-page apps, documentation, visualizations, interactive demos

✓ Serverless Python/Node APIs

Simple REST endpoints, data processing, file conversions (max 10s execution)

✓ Prototype sharing

Get a live URL in minutes to share with collaborators or supervisors

✓ Free tier generous

100GB bandwidth, unlimited deployments, automatic HTTPS, custom domains

✗ Long-running computations

Serverless functions timeout at 10s (hobby) or 60s (pro). No overnight model training.

✗ Large file storage

Blob storage free tier: 1GB total. Not for datasets, images, or user uploads at scale.

✗ Stateful applications

Every request gets a fresh container. No persistent in-memory state.

✗ Heavy Python dependencies

250MB uncompressed limit (50MB compressed). PyTorch, TensorFlow, full scipy stacks often exceed this with all dependencies.

confluence-demo/
├── index.html          # Your main HTML file
├── assets/
│   ├── logo.png       # Any images
│   └── styles.css     # Optional CSS
└── vercel.json        # Optional config

cd confluence-demo
git init
git add .
git commit -m "Initial commit"

# Create GitHub repo and push
git remote add origin https://github.com/yourusername/confluence-demo.git
git push -u origin main

# Install Vercel CLI
npm install -g vercel

# Login
vercel login

# Deploy (from project directory)
vercel

# Follow prompts:
# - Link to existing project? No
# - Project name? confluence-demo
# - Directory to deploy? ./
# - Auto-detected settings okay? Yes

# Deploy to production
vercel --prod

# Make changes
echo "Updated content" >> index.html

# Commit and push
git add .
git commit -m "Update content"
git push

# Vercel automatically deploys within 30-60 seconds
# Preview URL: https://confluence-demo-git-main.vercel.app
# Production URL: https://confluence-demo.vercel.app

api/
├── index.py           # Main FastAPI app
└── requirements.txt   # Python dependencies

public/
└── index.html         # Static frontend

vercel.json            # Deployment config

{
  "builds": [
    {
      "src": "api/index.py",
      "use": "@vercel/python"
    }
  ],
  "routes": [
    {
      "src": "/api/(.*)",
      "dest": "api/index.py"
    }
  ]
}

Step 1: Ask Claude for Strategy

Prompt example:

Claude will identify heavy dependencies, suggest alternatives (e.g., PIL instead of scikit-image for basic operations), and propose architectural changes.

Step 2: Implement with Cursor AI

Take Claude's recommendations to Cursor:

Cursor will handle the refactoring, update imports, and modify your requirements.txt file.

Step 3: Verify Size Reduction

After optimization, check your deployment size locally:

# Install dependencies and check size
pip install -r requirements.txt --target ./package
du -sh ./package
# Compare before and after