How to Use Claude Code for Python & Data Science

February 2026 • 8 min read

Python developers and data scientists have a unique relationship with the terminal. Between Jupyter notebooks, virtual environments, data pipelines, and model training, you are juggling more terminal sessions than most. Claude Code understands Python deeply -- from pandas DataFrames to scikit-learn pipelines to FastAPI endpoints. Here is how to use it effectively, with Beam keeping your chaotic Python workflow organized.

Claude Code's Python Strengths

Claude Code is not just a code autocomplete for Python -- it is a genuine pair programmer that understands the language at a deep level. It knows Python idioms, type hinting conventions, and the difference between a quick script and production-grade code. Ask it for a one-liner and it will give you something Pythonic. Ask it for a library and it will generate proper package structure with __init__.py files, docstrings, and type annotations.

The framework coverage is broad and current. Claude Code is comfortable with the entire data science stack -- pandas, NumPy, scikit-learn, PyTorch, TensorFlow -- as well as web frameworks like FastAPI, Django, and Flask. It understands the differences between them and will match its output to whichever you are using. Ask for a FastAPI endpoint and you get Pydantic models and async handlers. Ask for a Django view and you get class-based views with proper serializers.

Perhaps most importantly for Python developers, Claude Code understands the ecosystem tooling. It generates proper requirements.txt, pyproject.toml, and setup.cfg files. It knows how to set up virtual environments, configure pytest, and write Makefiles for common tasks. This means you spend less time on boilerplate and more time on the logic that matters.

The Python Development Workspace

Python workflows are inherently multi-terminal. You need your AI assistant, a REPL for quick experiments, possibly a running server, and a place for package management. Beam lets you organize all of this into a single workspace instead of hunting through a dozen scattered terminal windows.

Here is the workspace layout that works well for Python and data science projects, set up as a Beam workspace called "Python Project":

• Tab 1: Claude Code -- your AI pair programmer, generating code and answering questions about your codebase
• Tab 2: Python REPL or Jupyter -- run jupyter lab or ipython for interactive exploration and quick verification of what Claude generates
• Tab 3: Server/Application -- if you are building a web app, keep uvicorn main:app --reload running here to see changes in real time
• Tab 4: Virtual env management -- dedicated to pip installs, dependency resolution, and environment troubleshooting
• Tab 5: Git -- version control operations, branch management, and diffs

The real power move is using Beam's split pane feature: put Claude Code on the left and your Python REPL on the right with ⌘⌥⌃T. When Claude generates a function, you can immediately paste it into the REPL to test it with your actual data. This instant feedback loop is what turns Claude Code from a suggestion engine into a true development accelerator.

Data Science Workflow

Data science projects follow a natural progression -- explore, clean, engineer features, train models, evaluate -- and Claude Code can assist at every stage. The key is working step by step and verifying each stage in your REPL tab before moving on.

Step 1: Exploratory Data Analysis. Start by telling Claude Code what you are working with: "Load and explore this CSV dataset. Show summary stats, check for missing values, and suggest cleaning steps." Claude will write a complete EDA script using pandas that loads your data, runs df.describe() and df.info(), identifies columns with null values, flags potential data quality issues, and even suggests transformations based on the data types it sees. Run this in your REPL tab and review the output before proceeding.

Step 2: Feature Engineering. Once you understand your data, tell Claude what you want to predict: "Build a feature engineering pipeline for predicting customer churn. Use sklearn transformers." Claude will create a proper scikit-learn Pipeline with ColumnTransformer, applying OneHotEncoder to categorical features, StandardScaler to numeric ones, and handling missing values with appropriate imputation strategies. The code it generates follows sklearn best practices -- no data leakage, proper train/test splits, and reusable transformer objects.

Step 3: Model Training and Evaluation. Now for the core of the workflow: "Train and evaluate three models -- logistic regression, random forest, and gradient boosting. Show comparison metrics." Claude generates training code with cross-validation, computes precision, recall, F1-score, and AUC-ROC for each model, and presents the results in a clean comparison table. It even knows to use stratified splits for imbalanced datasets. Run each training step in your REPL to verify the results, then ask Claude to refine the best-performing model with hyperparameter tuning.

Building Python APIs

Data science does not end with a Jupyter notebook. Sooner or later you need to deploy your model or build a service around your data. Claude Code is excellent at generating production-ready Python APIs, particularly with FastAPI.

Try a prompt like: "Create a FastAPI app with endpoints for user CRUD, JWT authentication, and SQLAlchemy models." Claude will generate a complete project structure -- main.py, models, Pydantic schemas, route files, and authentication middleware. It understands FastAPI's patterns deeply: dependency injection for database sessions, Pydantic models for request/response validation, async/await for non-blocking operations, and proper HTTP status codes for each endpoint.

This is where the multi-tab Beam workspace really pays off. While Claude is generating your API code in Tab 1, your server is auto-reloading in Tab 3. You can watch endpoints come alive as Claude creates them, test them with curl or your HTTP client, and ask Claude to fix issues you spot -- all without leaving your workspace. The server tab gives you immediate visibility into whether the generated code actually runs, catches import errors in real time, and shows you request logs as you test.

Script Generation and Automation

Python is the scripting language of choice for automation, and Claude Code excels at generating robust scripts that handle real-world edge cases. This is where it shines compared to writing scripts from scratch -- Claude adds the error handling, logging, and edge case management that you might skip when writing a quick script yourself.

Consider a common task: "Write a Python script that watches a directory for new CSV files, validates the schema, transforms the data, and loads it into PostgreSQL." Claude will generate a script using the watchdog library for file system monitoring, pandas for validation and transformation, and SQLAlchemy for bulk inserts. It handles file locking, corrupt files, schema mismatches, and connection retries -- all the things that would take you an hour to think through and implement.

CLI tools are another sweet spot. Ask Claude to "create a CLI tool using Click for managing database migrations" and it generates proper CLI structure with commands, subcommands, options, help text, and even shell completion. The code follows Click best practices with proper context management and error handling. You can test the CLI immediately in your dedicated Beam tab while Claude continues refining the implementation.

Virtual Environment and Dependency Management

One particularly useful pattern is asking Claude to audit your dependencies: "Review my requirements.txt and suggest version pinning, identify unused packages, and flag any known security vulnerabilities." Claude will analyze your dependency file, suggest compatible version ranges, and point out packages that could be replaced with lighter alternatives. This kind of maintenance task is tedious by hand but takes Claude seconds.

Testing Python Code

Testing is where Claude Code saves the most time in a Python workflow. Writing tests is important but repetitive, and Claude is remarkably good at generating thorough test suites that catch real bugs. Ask it to "write pytest tests for the user service with fixtures, parametrize, and async test support" and it generates a complete test file with proper fixtures, parametrized test cases covering edge conditions, and async test configuration using pytest-asyncio.

The generated tests are not surface-level. Claude creates a conftest.py with reusable fixtures, uses factory patterns for test data, mocks external dependencies correctly, and structures tests into logical classes. It knows to test both the happy path and failure cases -- invalid input, missing records, permission errors, and database constraint violations.

For data science code specifically, try asking Claude to "add property-based tests using Hypothesis for the data transformation functions." Property-based testing is powerful for validating data pipelines but rarely written because the setup is non-trivial. Claude generates Hypothesis strategies that match your data schema, tests invariants like "output should have the same number of rows as input" or "all values should be within expected ranges," and catches edge cases that unit tests miss. Run the test suite in your dedicated testing tab and watch the results come in while you continue working in Claude Code.

Memory File: Python Project Conventions

Every Python project has its own conventions -- which formatter you use, how strict your type hints are, which testing patterns you follow. A CLAUDE.md file at the root of your project tells Claude Code these conventions upfront so it generates code that matches your project from the first prompt.

Here is what to include in your CLAUDE.md for a Python project:

• Python version -- e.g., Python 3.12, so Claude uses the right syntax features
• Virtual environment tool -- venv, poetry, or conda, so Claude generates the right commands
• Framework -- FastAPI, Django, or Flask, so Claude follows the right patterns
• ORM and database -- SQLAlchemy with PostgreSQL, Django ORM with SQLite, etc.
• Testing framework and patterns -- pytest with fixtures, unittest style, or custom patterns
• Type hint policy -- strict (mypy --strict) or gradual adoption
• Linting and formatting -- black, ruff, isort, mypy configurations and any custom rules

With this file in place, every piece of code Claude generates will be formatted with black, typed according to your policy, tested in your preferred style, and structured to match the rest of your codebase. It turns Claude from a generic Python assistant into one that knows your project.

Summary

Claude Code and Python are a natural fit. The language's expressiveness, the richness of the data science ecosystem, and the multi-tool nature of Python workflows all benefit from having an AI pair programmer that genuinely understands the stack. With Beam organizing your workspace, you get:

• Side-by-side verification -- split Claude Code and your Python REPL to test generated code instantly
• Isolated environments -- keep pip installs, server logs, and git operations in separate tabs
• End-to-end data science -- from EDA through model training, all in one workspace
• Production-ready APIs -- watch FastAPI endpoints come alive as Claude generates them
• Comprehensive testing -- generate and run pytest suites without leaving your flow
• Project memory -- use CLAUDE.md to ensure consistent code style across your entire project

Set up your Python workspace in Beam, teach Claude your project conventions with a CLAUDE.md file, and start building. The combination of AI-assisted coding with an organized terminal workspace turns a chaotic Python development process into a streamlined one.