Requirements: pip install anthropic

Usage:

export ANTHROPIC_API_KEY="your_api_key_here"

python token_tracker.py

import os

from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def send_prompt(prompt_text: str, model="claude-3-5-sonnet-20240620"):

    """Send a prompt to Claude and print token usage statistics."""

    message = client.messages.create(

        model=model,

        max_tokens=300,

        messages=[{"role": "user", "content": prompt_text}]

    )

    usage = message.usage # contains input/output token data

    print("Claude’s Response:\n")

    print(message.content[0].text)

    print("\nToken Usage Summary:")

    print(f" Input tokens: {usage.input_tokens}")

    print(f" Output tokens: {usage.output_tokens}")

    print(f" Total tokens: {usage.input_tokens + usage.output_tokens}")

if __name__ == "__main__":

    prompt = "Explain the difference between synchronous and asynchronous programming in Python with short examples."

    send_prompt(prompt)

Explanation:This script not only prints Claude’s response but also reports how many tokens were used for input, output, and total. You can experiment by sending different prompts to see how changes in prompt size and verbosity impact cost.

For instance:

• Adding detailed instructions or long code snippets drastically increasesinput tokens.
• Asking for “a concise summary” instead of “an in-depth analysis” cutsoutput tokensnearly in half.

Practical Optimization Example

Here’s a simple demonstration of how Claude’s output can be constrained to control token usage effectively:

prompt_long = (

    "Explain asynchronous programming in detail with multiple examples "

    "and comparisons to multithreading and multiprocessing."

)

prompt_short = (

    "In 100 words, summarize how asynchronous programming differs from threading."

)

for prompt in [prompt_long, prompt_short]:

    print("\nPrompt Length:", len(prompt.split()), "words")

    send_prompt(prompt)

You’ll observe that the shorter, more focused prompt reduces both tokens and cost, while still delivering useful insights. This reinforces that clarity beats verbosity when working with AI models.

Clarification Table

Managing token usage is a skill that balances clarity, brevity, and precision. By monitoring how many tokens your prompts consume, selecting the right model, and setting explicit output limits, you gain full control over performance and cost. Efficient developers treat tokens like compute cycles — everyone should have a purpose.

In the next section, we’ll explore Caching and Reuse Strategies, where you’ll learn how to store intermediate Claude responses and reuse them intelligently across sessions to save both time and budget while keeping context continuity intact.

6.5 Building a Productive Claude-Driven Workflow

A productive Claude-driven workflow is about designing an efficient rhythm between you, your tools, and Claude Code’s reasoning capabilities. The goal is not simply to use Claude for ad-hoc code generation but to integrate it as a structured part of your development loop—from brainstorming ideas and scaffolding code to debugging, refactoring, and testing. When developers approach Claude systematically, it becomes an intelligent extension of the team rather than a sporadic assistant. This section teaches you how to build that system: a repeatable, low-friction process that enhances creativity, ensures accuracy, and keeps momentum steady across projects.

Concept Development

The secret to productivity with Claude Code lies in workflow orchestration—structuring your interactions so that every exchange has context, purpose, and continuity. Instead of prompting in isolation, you use Claude as part of a consistent cycle:

1. Intent Stage: You clarify what you want to achieve in natural language (a new feature, bug fix, or architectural change).
2. Reasoning Stage: Claude outlines its plan or approach, allowing you to review its reasoning before code generation.
3. Execution Stage: Claude produces complete, validated code with inline comments.
4. Verification Stage: You test or run the code locally, feeding errors or test results back to Claude for refinement.
5. Reflection Stage: Claude summarizes what changed and why, creating a knowledge artifact for future reference.

This cycle mirrors the human process of pair programming: planning, writing, testing, and learning iteratively. Once automated or repeated consistently, it forms a Claude loop—a feedback-driven development system that reduces friction and accelerates delivery.

A good workflow also distinguishes between temporary prompts (for exploratory tasks) and persistent system prompts (which define Claude’s long-term behavior for a given project). Keeping these separate prevents context drift and ensures that Claude behaves predictably no matter how long the session lasts.

Hands-On Example: A Continuous Claude Workflow

Let’s build a lightweight, Claude-assisted loop for developing and refining a simple Flask API. The loop will automate planning, generation, testing, and summarization.

claude_workflow.py