Vibe Coding for Scientists

Honest assessment: Most scientists don't need to become AI engineers. Vibe coding is sufficient for research tools, internal applications, and proof-of-concept work. Consider the transition when:

Example Questions to Ask Claude:

• "I'm getting 'command not found' when running uv venv. What does this mean?"
• "Does Cursor create the virtual environment automatically or do I need to run uv venv?"
• "How does Cursor know which packages to install automatically?"
• "Claude is installed but Cursor can't find it. How do I verify the path?"
• "I'm on Linux—do I need to change any of these commands?"
• "When would I need to manually run uv sync instead of letting Cursor handle it?"

Goal: Get Claude to create a structured, detailed prompt for Cursor AI. Claude should output ONLY a single markdown file containing comprehensive specifications, architecture, and requirements—including a regression test suite. Claude generates NO code. This prompt will guide Cursor AI to generate all application code with built-in quality checks.

⛔ Critical: Claude Does NOT Generate Code in Step 1
Claude's role is to create a detailed prompt document for Cursor AI. All code generation happens in Cursor AI (Step 3). If Claude starts generating Python files, HTML, or any code—stop and revise your prompt.

Create a structured and detailed prompt for Cursor AI to build a [platform] [language] application that implements [core function] for [scientific domain].

Here is the method/protocol to follow:
[URL to reference methodology, paper, or protocol]
[Optional: additional context or requirements]

The prompt should be output as a single markdown file (cursor_prompt.md) that includes:
1. Project overview and objectives
2. Technical architecture and technology stack recommendations
3. Complete directory structure with file specifications
4. Detailed implementation requirements for each component
5. User interface specifications (if applicable)
6. Data processing pipeline details
7. **Comprehensive regression test suite** covering:
   - Unit tests for core functions
   - Integration tests for workflows
   - Edge case handling
   - Error condition validation

The final implementation will use:
- Python 3.12+
- uv for package management
- pytest for testing

Include 2+ test inputs with expected outputs to prevent hardcoding.

Do NOT generate any code or files other than this single markdown prompt file.

This is what was used to get Claude to create the Cursor AI prompt:

Create a structured and detailed prompt for Cursor AI to build a local Python application that implements Confluence Assessment for cells in life sciences.

Here is the method to follow:
https://www.thermofisher.com/blog/life-in-the-lab/how-to-measure-cell-confluency/

The prompt should be output as a single markdown file (cursor_prompt.md) that includes:
1. Project overview and objectives
2. Technical architecture (FastAPI, HTMX, Tailwind CSS, scikit-image)
3. Complete directory structure with file specifications
4. Detailed implementation requirements for each component
5. User interface specifications with image upload capability
6. Image processing pipeline for confluence calculation
7. **Comprehensive regression test suite** covering:
   - Unit tests for image processing functions
   - Integration tests for API endpoints
   - Edge cases (empty images, invalid formats, extreme confluence values)
   - Error handling validation

The final implementation will use:
- Python 3.12+
- uv for package management
- pytest for testing

Test inputs:
- Cell microscopy image at 10% confluence (expected: 8-12% output)
- Cell microscopy image at 90% confluence (expected: 88-92% output)

Do NOT generate any code or files other than this single markdown prompt file.

⚠️ Common Mistakes to Avoid (Step 1 - Claude Design Prompt)

• Asking Claude to generate code: "Write the Python code..." or "Create main.py..." → WRONG! Step 1 should only produce cursor_prompt.md. All code generation happens in Cursor AI (Step 3)
• Too vague: "Build something to analyze cells" → Missing: what kind of analysis?
• Too prescriptive about tech: "Use FastAPI with HTMX and Tailwind" → Let Claude recommend the stack
• No context: "I need an image analyzer" → Missing: what domain, what methodology?
• No test suite: Forgetting to request comprehensive regression tests → Code errors won't be caught
• Missing test inputs: No example data with expected outputs → Risk of hardcoded solutions

✓ Good Practice Tips (for Step 1 - Claude Design Prompt)

• Remember: Claude generates NO code—only a prompt for Cursor AI
• Start broad, let Claude ask clarifying questions
• Reference URLs to protocols/papers directly in the prompt
• Explicitly state "output as a single markdown file" to avoid code generation
• Request complete directory structure and file specifications in the prompt
• Mention implementation context (Python 3.12+, uv, Cursor) for better recommendations
• Create a Claude Project for this work to manage multiple related chats

Your Task: Write Your Own Prompt

Before moving to Step 2, craft your initial prompt following the template above. Think about your scientific problem, find reference methodology, and be honest about constraints.

These are the types of images the Confluence Analyzer application needs to process:

Four microscopy images showing cells at varying confluence levels (approximately 10%, 40%, 60%, and 90% coverage)

Goal: Use Claude's cursor_prompt.md in Cursor AI to generate all application code.

Take the markdown prompt file Claude created in Step 1 and use it to guide Cursor AI's code generation. Cursor AI will handle all implementation details including file structure, dependencies, and testing.

1. Open Cursor AI and create a new project directory
2. Copy the cursor_prompt.md content from Claude's output
3. Paste into Cursor's Composer (Cmd+I or Ctrl+I) or use the Chat interface
4. Let Cursor generate the complete application including:
   • Directory structure
   • All Python files (main application, utilities, tests)
   • Configuration files (pyproject.toml, .env templates)
   • Test suite (unit tests, integration tests)
   • Documentation (README.md)
5. Use Cursor's Auto mode for fixes, refinements, and debugging

✓ Why This Workflow Works:

• Claude focuses on strategy: Creates comprehensive specifications without getting bogged down in code
• Cursor focuses on implementation: Generates all code based on Claude's detailed requirements
• Test suite catches errors: Regression tests from Step 1 validate Cursor's code generation
• Single source of truth: The cursor_prompt.md file contains everything Cursor needs
• Iterative refinement: Use Cursor's Auto mode to fix bugs found by tests

Application Screenshots

Initial State

Clean upload interface with drag-and-drop zone

After Analysis

16.5% confluence with detailed metrics and processing time

✓ README.md Generated Automatically

Cursor also generated comprehensive documentation including installation steps, usage instructions, API endpoints, and troubleshooting guides. This wasn't requested—it followed best practices automatically.

Expected total development time: 2-4 hours from prompt to working application

Note: Disabling this prevents your conversations from being used in model training, keeping your scientific data and proprietary information private.

Note: Privacy Mode protects your codebase and project files from being transmitted to Cursor's servers for training purposes.

Best Practice: Create project-specific folders like /Projects/experiment-analyzer rather than opening ~/Documents or ~/Home

Step 1: The "Deep Think" (Claude Sonnet 4.5)

Time: 5-10 minutes

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.

What to expect: Detailed analytical plan, JSON/text specification, edge case warnings, literature references

Action: Copy the summary and key specifications into a text file

Step 2: The "Spec Transfer" (You)

Create a new file in Cursor (e.g., specs/edge_features_spec.md)

Why this matters: You are feeding the "smart" reasoning into the "fast" coder. This grounds Cursor and prevents naive implementation mistakes.

# 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

Step 3: The "Build" (Cursor AI)

Tool: Cursor Composer (Cmd+I / Ctrl+I) | Time: 5-15 minutes

Model verification: Go to Cursor Settings → Models → Confirm "Claude 3.5 Sonnet" (NOT cursor-small)

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.

Expected: 90%+ correct first attempt (following high-quality blueprint)

Step 4: Review & Refine (Cursor Chat)

Tool: Cursor Chat (Cmd+K / Ctrl+K) | Time: 5-10 minutes (iterative)

Run the generated code, highlight problematic blocks, ask for specific fixes:

• "This loop looks slow for large molecules. Vectorize it using RDKit operations."
• "Add handling for molecules with 100+ atoms—current implementation times out."
• "The current approach loses stereochemistry. Integrate CIP rules for priorities."

Each refinement cycle: 2-3 prompts until convergence

Step 5: Integration (Cursor Chat)

Time: 5 minutes

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.

Free Tier Limits

• 1GB total storage
• 1,000 read requests per month
• 1,000 write requests per month
• 1GB bandwidth per month

Basic Usage (Python):

from vercel_blob import put, get, list_blobs

# Upload file
blob = await put('data.csv', file_content, token=BLOB_TOKEN)
# Returns: {'url': 'https://...', 'pathname': 'data.csv'}

# Download file
data = await get('data.csv', token=BLOB_TOKEN)

# List all files
files = await list_blobs(token=BLOB_TOKEN)

Important limitation: The Confluence Analyzer uses FastAPI with image processing (scikit-image, NumPy). While individual libraries might seem manageable, their transitive dependencies (scipy, joblib, etc.) can push the total beyond Vercel's 250MB uncompressed serverless limit. This walkthrough demonstrates the process, but you'd likely need to either: (a) significantly simplify dependencies, (b) use Vercel Edge Functions with WebAssembly, or (c) deploy the full app elsewhere (Railway, Render, Fly.io).

Step 1: Prepare Your Project

Create a simple project structure:

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

Step 2: Create Vercel Account

1. Go to vercel.com
2. Sign up with GitHub (recommended) or email
3. Connect your GitHub account for automatic deployments

Step 3: Initialize Git Repository

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

Step 4: Deploy to Vercel

Option A: Via Vercel Dashboard (Easiest)

1. Go to vercel.com dashboard
2. Click "Add New Project"
3. Import your GitHub repository
4. Vercel auto-detects it's a static site
5. Click "Deploy"
6. Wait 30-60 seconds
7. Get live URL: https://confluence-demo.vercel.app

Option B: Via Vercel CLI

# 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

Step 5: Configure Custom Domain (Optional)

1. Go to Project Settings → Domains
2. Add your domain (e.g., confluence.yourdomain.com)
3. Update DNS records as instructed by Vercel
4. Vercel automatically provisions SSL certificate

Step 6: Automatic Deployments

Every push to your GitHub main branch triggers automatic deployment:

# 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

Project Structure for Serverless

api/
├── index.py           # Main FastAPI app
└── pyproject.toml     # Python dependencies

public/
└── index.html         # Static frontend

vercel.json            # Deployment config

vercel.json Configuration

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

Reality check: The Confluence Analyzer requires scikit-image (~40MB) + NumPy (~15MB) + Pillow (~3MB) = ~58MB for the core libraries, which fits within the 250MB uncompressed limit. However, scikit-image pulls in scipy (~100MB), joblib, and other transitive dependencies that can push the total deployment size to 200MB+.

💡 Use Claude & Cursor AI to Optimize Package Size

If your deployment approaches the 250MB limit, use the two-brain approach to optimize:

# Export dependencies for deployment
uv export --no-hashes > requirements.txt
pip install -r requirements.txt --target ./package
du -sh ./package
# Compare before and after

This iterative approach often reduces deployment size by 40-60% while maintaining functionality.

For ML/scientific apps: Modal Labs (modal.com) is particularly well-suited for applications requiring compute resources. No size limits on dependencies, built-in GPU support, and often more cost-effective than traditional hosting.

Why Modal for Scientific Apps

• No dependency size limits—PyTorch, TensorFlow, scikit-image all work fine
• On-demand compute: Pay only for actual function execution time
• Built-in GPU support for ML inference or training
• Automatic scaling from zero to thousands of concurrent requests
• Container-based: Full control over environment and dependencies

Basic Modal Setup

# Install Modal
uv add modal

# Login
modal token new

# Create app.py
import modal

app = modal.App("confluence-analyzer")

@app.function(
    image=modal.Image.debian_slim()
        .pip_install("scikit-image", "numpy", "pillow", "fastapi"),  # Modal's API for container dependencies
    gpu="T4"  # Optional: Add GPU if needed
)
@modal.web_endpoint()
def analyze_confluence(request):
    # Your analysis code here
    return {"confluence": 0.85}

# Deploy
modal deploy app.py

Cost Comparison

Modal charges per compute-second. For scientific apps with intermittent usage (demos, research tools), this is often cheaper than always-on hosting:

• Free tier: $30/month credits
• CPU: ~$0.0001 per second
• GPU (T4): ~$0.0005 per second
• No charges when not in use