Numbers Every Claude.ai Skill Developer Should Know

Inspired by Jeff Dean's "Numbers Everyone Should Know" — adapted for the Claude.ai Container Compute Environment. Empirically researched and written by Claude opus 4.6

Jeff Dean's insight was that engineers who internalize a few key performance numbers can evaluate design alternatives on the back of an envelope — without building prototypes. The same principle applies to designing Skills for Claude.ai. Every tool call, file read, package install, and line of generated code has both a time cost (user-experienced latency) and a token cost (dollars). Skill authors who know these numbers will write faster, cheaper, and more effective skills. Those who don't will produce skills that feel sluggish and burn through token budgets.

This document provides the reference numbers, measured empirically in a live Claude.ai container (February 2026). Skim the summary table, absorb the design rules, and refer to the appendix when you need specifics.

At a Glance

Python startup                              40 ms
Import numpy                               200 ms
Import pandas                              860 ms
Import sklearn                           2,750 ms
uv pip install (any complexity)          ~800 ms       ← always use uv
pip install (light)                      3,500 ms
pip install (heavy)                     91,000 ms       ← 113× slower than uv
npm install express                      4,500 ms
Playwright browser launch               1,725 ms
Write 100 MB to disk                        84 ms
Read 100 MB from disk                       42 ms
Tool call round-trip (minimum)           3,000 ms       ← the dominant cost
Tool call round-trip (web_search)    5,000–10,000 ms

--- Token costs at Opus 4.5 rates ($5/$25 per MTok in/out) ---
1 tool call overhead                    ~50 tokens      ~$0.001
Read 10 KB file (input)              ~2,600 tokens      ~$0.013
Write 10 KB file (output)            ~2,600 tokens      ~$0.065  ← 5× reading
web_search result                 2,000–5,000 tokens     ~$0.01–0.03
web_fetch full page              5,000–50,000 tokens     ~$0.03–0.25
web_fetch (token-limited to 100)       ~130 tokens      ~$0.001

Design Rules

1. Batch everything into single tool calls

The ~3–4 second tool call round-trip dominates any operation that takes less than a second internally. This is the single most important optimization for skill design.

Bad: 5 view calls to read 5 files → 15–20 seconds, 125 output tokens of overhead
Good: 1 bash cat file1 file2 ... call → 3–4 seconds, 45 output tokens of overhead

2. Always use uv, never pip

uv pip install is 4.5× faster for light packages and 113× faster for heavy dependency trees (91s → 0.8s). The container ships with uv 0.9.26 pre-installed. There is no reason to ever use pip.

3. Check what's pre-installed before designing a skill

The container ships with a massive set of pre-installed Python packages: pandas, numpy, matplotlib, scikit-learn, scipy, openpyxl, python-docx, python-pptx, reportlab, pdfplumber, playwright, lxml, beautifulsoup4, Pillow, seaborn, requests, flask, markitdown, and many more. Node has pptxgenjs, sharp, mermaid, marked, pdf-lib, playwright, and typescript. Any skill that installs one of these is wasting 1–90 seconds for nothing.

4. Output tokens are 5× input tokens — treat writes as expensive

Reading a 10 KB file costs ~$0.013 (input tokens). Writing one costs ~$0.065 (output tokens). This makes str_replace for targeted edits far more economical than regenerating entire files, and makes the "iterate in /home/claude, copy once to outputs" pattern important for multi-step workflows.

5. Use view with line ranges aggressively

Reading an entire 10 KB file to check one section costs ~2,600 input tokens. Reading 5 specific lines costs ~80. That's a 32× difference. Inspect structure first (wc -l, head), then target specific ranges.

6. Control web_fetch ingestion

An uncontrolled web_fetch can dump 50,000 input tokens into context. Always use text_content_token_limit. For checking if a page exists or grabbing a headline, 100–200 tokens is plenty.

7. Front-load context in system prompts (caching makes it nearly free)

Prompt caching gives 90% savings on cache reads. Skill instructions in the system prompt pay full price on the first turn but only 10% on every subsequent turn. This makes detailed, information-rich skill instructions economically sound — the amortized cost is low.

8. Work in /home/claude, deliver to /mnt/user-data/outputs

Write throughput to /mnt/user-data/outputs is 2.4× slower than /home/claude. For any multi-step file generation, always work in the home directory and copy the final artifact to outputs.

9. Know the file-inspection decision matrix

What We Can't Measure From Inside

These numbers require external observation (a bookmarklet or Claude in Chrome, planned for Phase 2):

• End-to-end response time as seen by the user (message send → response complete)
• Claude's thinking/generation time between tool calls
• Streaming start latency (time to first visible token)
• Tool call dispatch latency isolated from Claude's processing
• Exact token counts per turn (would need API response headers or billing data)

Appendix A: Container Specifications

OS: Ubuntu 24.04.3 LTS, kernel 4.4.0
CPU: 4 cores (model undisclosed)
RAM: 9 GB
Disk: 10 GB (shared /home/claude and /mnt/user-data)
Python: 3.12.3 | Node: 22.22.0 | npm: 10.9.4 | uv: 0.9.26 | git: 2.43.0

The container filesystem resets between tasks. All benchmarks reflect fresh container state.

Appendix B: Detailed Benchmarks

B.1 File I/O

B.2 Python Import Times (cold, isolated process)

B.3 Compute Operations

B.4 Package Installation

B.5 Network (post-proxy-initialization)

B.6 Tool Call Round-Trip Overhead

Measured as wall-clock deltas between consecutive date +%s%N calls across minimal bash_tool invocations. Includes Claude's inter-call processing + API dispatch + execution.

B.7 Token Economics

API pricing (Feb 2026):

Per-tool token costs:

Appendix C: Methodology

All timings measured with date +%s%N (nanosecond precision) inside the container. Python import times measured in isolated processes (separate python3 -c invocations) to avoid module caching effects. Tool call round-trip times are upper bounds that include Claude's inter-call processing. Package install times are single-shot and may vary with network conditions. Token estimates use ~4 characters per token for English text. Pricing sourced from Anthropic's documentation and third-party analysis, February 2026.