Can Claude Write Python Code? What It Can Do and How to Check It

You will learn: which Claude surface to use, what to ask for, where generated Python tends to fail, and a five-step routine for checking a change before it ships.

Which Claude should you use for Python?

For a traceback or a small function, start in Claude chat and run the suggestion in your own environment. For a change to a real repository, use Claude Code and inspect the diff, tests and commands it ran. If you are building an application on Anthropic's API and need execution inside that interaction, the API code-execution tool can run code in its sandbox; check that its files, packages and outputs match your use case.

Anthropic describes Claude Code as a coding tool that reads a codebase, edits files and runs commands. Its terminal, editor, desktop and browser surfaces are ways to use that coding workflow. A normal chat response can give you Python to paste into a file, and Claude's file-creation feature can execute code for supported file tasks. The API code-execution tool is an Anthropic-hosted sandbox for API requests. These are related capabilities, but they are not the same execution environment.

That distinction matters when the result depends on a particular Python version, a private package, a database, a network permission or an existing test suite. A function that looks convincing in chat may fail on an import or edge case in your project. Even a successful run in a sandbox does not prove it works in production.

What Python work is Claude useful for?

It is particularly useful when the task has a small, testable result. Examples include converting a clear rule into a function, explaining a traceback, adding a unit test for a known bug, finding repeated logic, or translating a short script into more readable Python. In a repository, Claude Code can inspect neighboring code and the project's test commands before editing, which gives it context a pasted chat prompt may lack. Anthropic's common workflows include code changes and test runs, but you still need to inspect the output.

Give Claude the input shape, expected behavior and edge cases. For example:

In this repository, add a Python function that parses a CSV of invoices and totals only the rows with status paid. Use Decimal for money, leave the existing public function signature intact, and add tests for an empty file, a malformed amount and a refunded row. Show the proposed diff and the exact test command before changing anything else.

This prompt defines a job that can be checked. It does not claim that Claude has run those tests or produced a correct total. The reviewer must decide what a malformed amount should do and whether refunds are excluded, subtracted or handled elsewhere. Those are product rules, not syntax details for an assistant to guess.

Where can Claude-written Python go wrong?

The most common failure is a plausible assumption. Claude may choose a library that is not in your lockfile, call an API method that changed, swallow an exception that should fail loudly, or write a test that merely repeats the implementation's mistake. It may also simplify data handling in ways that lose time zones, currency precision, encoding rules or access controls.

Separate those risks from syntax. Python can compile while still computing the wrong answer. A passing test suite can miss a branch nobody tested. A unit test generated by the same assistant can be useful, but it should include an independently specified expected result. For a payment calculation, compare against a few hand-calculated cases. For a data migration, use a copy of representative data, inspect the before and after records and plan a rollback.

Do not paste secrets or client data into a prompt without checking the applicable account and company data rules. In Claude Code, review what commands and files the session is allowed to access. Anthropic's permissions documentation explains how its tool permissions work. A request to “fix everything” grants much less useful control than a named file, bounded edit and explicit review point.

A five-step check before accepting Python from Claude

These checks work whether the first draft came from chat or Claude Code. Run them in your own project. Use the project's existing environment and tools; do not install a new dependency just to make a generated suggestion pass.

1. Run the smallest example. Give the function a normal input and at least one edge case. If the code reads files or changes records, use a sample copy. Note the Python version with python -V and run the actual entry point your project uses.
2. Run the tests. Start with the tests that cover the changed behavior, then the project suite. For a repository using Python's standard unittest discovery, the documented command is python -m unittest discover -v. A project using another test runner should use its own checked-in command. Read the failure output rather than asking Claude to make it green at any cost. Python's unittest documentation defines the discovery command.
3. Run existing static checks. If the repository already has a linter or type checker configured, run that exact command. python -m compileall -q . can catch syntax errors, but it does not execute imports, lint the code or prove semantic correctness. Do not call a clean formatter run a functional test. Python documents compileall as a byte-compilation tool.
4. Read the diff. Use git diff or your editor's comparison view. Look for changed function signatures, broad exception handlers, deleted tests, altered security checks and changes outside the requested files. Ask why each changed line is needed. A small diff is easier to verify than a large repair that appears to work.
5. Keep the environment reproducible. Record the Python version and preserve the project's existing dependency pins and lockfile. If a new library is truly needed, review its official documentation and add it through the project's normal approved dependency workflow. Python's virtual-environment documentation explains how an environment isolates installed packages; an isolated environment alone does not pin their versions.

If step one or two fails, feed Claude the exact command, error and relevant file, then ask for a narrow correction. Run the checks again on the new diff. If the failure is in an external service or an unavailable package, mark that limit instead of reporting the code as verified.

A small check we actually ran

On 19 October 2026, we asked the installed Claude Code CLI for one standard-library function that totals only paid CSV rows using Decimal. The CLI returned the function below verbatim. We disabled its tools, so it did not run a command, edit a file or install a package.

```python
import csv
import io
from decimal import Decimal, InvalidOperation

def total_paid_invoice_amount(csv_text: str) -> Decimal:
"""Sum the amount column of rows whose status is exactly "paid".

Rows with any other status (e.g. "refunded") are skipped and their
amounts are never parsed. Returns Decimal(0) for empty input.

Raises ValueError, citing the CSV line number, when a paid row has a
missing amount, a malformed amount, or a NaN/Infinity amount.
"""
total = Decimal(0)
reader = csv.DictReader(io.StringIO(csv_text, newline=""))

for row in reader:
if row.get("status") != "paid":
continue

line = reader.line_num
raw = row.get("amount")
if raw is None or not raw.strip():
raise ValueError(f"line {line}: missing amount for paid invoice")

text = raw.strip()
if "_" in text:
raise ValueError(f"line {line}: malformed amount {raw!r}")
try:
amount = Decimal(text)
except InvalidOperation:
raise ValueError(f"line {line}: malformed amount {raw!r}") from None

if not amount.is_finite():
raise ValueError(f"line {line}: non-finite amount {raw!r}")

total += amount

return total
```

We ran three independently specified checks with Python 3.12.10. The input had two paid rows totaling 19.75 and a refunded row that had to be excluded. We also checked an empty CSV and a malformed paid amount. Here are the actual output lines:

```text
paid sum: 19.75; refunded row excluded
empty rows: 0
malformed paid amount: line 2: malformed amount 'abc'
compileall passed
```

These three checks do not cover every edge case or establish a success rate for other Python tasks. They show the function and the independent results a reviewer can inspect.

Claude chat, Claude Code or API execution: a practical choice

For a question about why a loop fails, start in chat with the smallest reproducible example and traceback. For a change that must fit an existing repository, use Claude Code with access to the relevant files and tests, then review every edit. For an application that needs Anthropic to execute Python during an API interaction, consider the code-execution tool and its sandbox limits. Do not assume that a file produced by one surface automatically appears in another.

The choice also affects evidence. A chat answer shows a suggestion. A Claude Code transcript plus a saved diff and test output shows what happened in that repository at that time. An API tool response shows what happened in its sandbox. None is a substitute for a deploy check in the environment where users will run the code.

If you publish a Python tutorial, measure whether anyone can find it

Writing correct Python and earning visibility for the explanation are separate jobs. A public tutorial should answer a specific question, show the tested input and output, identify the Python version and link the official behavior it relies on. After publishing, you can check whether an AI answer to that exact question cites the tutorial's exact URL. Xtrusio describes that exact-page citation check as a later observation, not a guarantee that a code assistant or an SEO edit caused the citation.

Sources and scope

Checked 19 October 2026: Anthropic's Claude Code overview, common workflows, permissions, Claude chat file creation, API code execution, and Python's unittest, compileall and virtual-environment documentation. This guide describes documented capabilities and one bounded local run. It does not present a performance benchmark.