Understanding Claude's Knowledge and Models

In the previous lesson, you learned how to navigate Claude Code—how to start it, have conversations, clear your chat history, exit properly, and resume previous sessions. Now that you're comfortable with the interface, it's time to discover what makes Claude Code truly powerful for data visualization work.

Claude Code is powered by a Large Language Model (LLM), which is an AI system trained on vast amounts of text data from the internet, including documentation, code repositories, tutorials, and technical discussions. During this training process, Claude learned about programming languages like Python and popular libraries used for data visualization, such as Matplotlib, Pandas, Seaborn, and NumPy. This means Claude already understands these tools without your needing to explain them or provide documentation.

Think of it this way: when you ask a colleague who's experienced with Python about how to create a chart, they don't need you to hand them the Matplotlib documentation first. They already know it from their experience. Claude works similarly—it has extensive knowledge about data visualization libraries built into its training, so you can immediately start asking questions and getting code examples without any setup.

In this lesson, you'll discover the depth of Claude's knowledge by asking it about data visualization libraries and getting specific code examples. You'll also learn that Claude Code actually offers three different models—Haiku, Sonnet, and Opus—each with different capabilities and costs. By the end of this lesson, you'll understand how to leverage Claude's built-in knowledge and choose the right model for your specific data visualization tasks.

Claude Code is trained on a huge amount of Python code and documentation, including all the major data visualization libraries like Matplotlib, Pandas, Seaborn, and NumPy. This means Claude already knows how these libraries work and can help you with code, syntax, and best practices—no need for you to memorize every detail or look up documentation for common tasks.

For example, if you ask:

> What is matplotlib and what can it be used for?

Claude responds:

● Matplotlib is a comprehensive Python library for creating static, animated, and interactive visualizations. It's one of the
  most widely-used plotting libraries in the Python ecosystem.

  What it's used for:

  - Data visualization - Creating charts and graphs to understand and present data
  - Scientific plotting - Visualizing research data, experimental results, and mathematical functions
  - Statistical analysis - Generating histograms, scatter plots, box plots, and other statistical graphics
  - Publication-quality figures - Producing graphics suitable for academic papers and reports

  Common plot types:

  - Line plots, scatter plots, bar charts
  - Histograms and distributions
  - Pie charts, heatmaps, contour plots
  - 3D plots and surface plots
  - Time series visualizations
  - Subplots and multi-panel figures

  Matplotlib is particularly popular in data science, machine learning, and scientific computing. It integrates well with NumPy
  and Pandas, and provides fine-grained control over every aspect of a figure's appearance. Many other visualization libraries
  (like Seaborn and Pandas plotting) are built on top of matplotlib.

  The library follows a MATLAB-like interface through its pyplot module, making it familiar to users coming from that
  environment.

You can see that Claude gives you a thorough, practical answer—just like an expert colleague.

Claude doesn't just know about individual libraries; it understands how they work together in real-world data workflows. You can ask for recommendations and get actionable advice:

> What Python libraries would you recommend for loading and visualizing CSV data?

Claude responds:

● For loading and visualizing CSV data, I'd recommend this combination:

  For Loading CSV Data:

  Pandas - The go-to library for CSV handling
  - pd.read_csv() makes loading CSV files simple
  - Provides DataFrames for easy data manipulation and analysis
  - Built-in data cleaning and transformation tools
  - Handles missing values, data types, and large files well

  For Visualization:

  Matplotlib - Foundation for custom plots
  - Complete control over plot appearance
  - Works seamlessly with Pandas DataFrames
  - Good for publication-quality static figures

  Seaborn - Built on matplotlib, easier for statistical plots
  - Prettier default styles
  - Specialized for statistical visualizations (distributions, correlations, categorical data)
  - Less code needed for common plot types
  - Integrates directly with Pandas DataFrames

  Plotly - For interactive visualizations
  - Creates interactive, web-based plots
  - Users can zoom, pan, and hover for details
  - Great for dashboards and exploratory analysis
  - Easy export to HTML

  Typical workflow:

  import pandas as pd
  import matplotlib.pyplot as plt
  import seaborn as sns

  # Load data
  df = pd.read_csv('data.csv')

  # Quick visualization
  df.plot()  # Pandas has built-in plotting via matplotlib
  sns.scatterplot(data=df, x='column1', y='column2')

  For most projects, Pandas + Matplotlib/Seaborn covers the majority of needs. Add Plotly if you need interactivity.

With Claude, you don’t need to know every implementation detail—just describe your goal, and Claude can generate the code and guide you through the process.

Note: Claude’s training data goes up to a point in time before the present, so it may not include the very latest packages or features. However, Claude can search the web for new information if needed (we’ll cover how to use this feature later in the course).

Understanding concepts is helpful, but when you're actually building visualizations, you need specific code syntax. Let's see how Claude handles a more technical request. Ask Claude for the exact code needed to create a scatter plot with custom colors and sizes:

> What's the matplotlib code syntax for creating a scatter plot with custom colors and marker sizes based on a third variable?

Claude provides you with complete, working code examples:

● Here's the matplotlib syntax for scatter plots with variable colors and sizes:

  import matplotlib.pyplot as plt
  import numpy as np

  # Sample data
  x = np.array([1, 2, 3, 4, 5])
  y = np.array([2, 4, 5, 4, 6])
  colors = np.array([10, 20, 30, 40, 50])  # Values for color mapping
  sizes = np.array([100, 200, 300, 400, 500])  # Marker sizes in points²

  # Create scatter plot
  plt.scatter(x, y, c=colors, s=sizes, cmap='viridis', alpha=0.6)

  # Add colorbar to show color scale
  plt.colorbar(label='Color Variable')

  # Labels and title
  plt.xlabel('X axis')
  plt.ylabel('Y axis')
  plt.title('Scatter Plot with Variable Colors and Sizes')

  plt.show()

  Key parameters:

  - c - Values for color mapping (array-like)
  - s - Marker sizes in points² (scalar or array-like)
  - cmap - Colormap name (e.g., 'viridis', 'plasma', 'coolwarm', 'RdYlBu')
  - alpha - Transparency (0-1)

  With Pandas DataFrame:

  import pandas as pd
  import matplotlib.pyplot as plt

  df = pd.DataFrame({
      'x': [1, 2, 3, 4, 5],
      'y': [2, 4, 5, 4, 6],
      'color_var': [10, 20, 30, 40, 50],
      'size_var': [1, 2, 3, 4, 5]
  })

  # Scale sizes (multiply by constant for visibility)
  plt.scatter(df['x'], df['y'],
              c=df['color_var'],
              s=df['size_var']*100,  # Scale up for visibility
              cmap='viridis',
              alpha=0.6,
              edgecolors='black')  # Optional: add edge color

  plt.colorbar(label='Third Variable')
  plt.show()

  The s parameter expects sizes in points squared, so you often need to scale your data (multiply by 50-200) for good
  visibility.

Notice that Claude doesn't stop at just one example. It provides a second version showing how to accomplish the same task using a Pandas DataFrame, which is often how you'll work with real data. Claude even includes practical tips, like the note about scaling the size parameter for better visibility. This kind of detailed, practical guidance goes beyond just knowing the syntax—it shows an understanding of how people actually use these tools in real projects.

When you're working on your own data visualization projects, you can ask Claude for specific code patterns like this. Whether you need to create a histogram, customize axis labels, add a legend, or create subplots, Claude can provide the exact syntax along with explanations of how it works. This makes Claude Code an incredibly valuable reference tool that's always available right in your terminal.

Up until now, you've been using Claude Code with its default settings, but there's something important you should know: Claude Code actually offers three different models, each with different capabilities and costs. These models are called Haiku, Sonnet, and Opus, and they represent different trade-offs between speed, capability, and cost.

• Haiku 4.5 is the fastest and most economical model. It costs $1 per million input tokens and $5 per million output tokens. Think of tokens as small chunks of text—roughly, one token equals about four characters or three-quarters of a word. Haiku is designed for quick answers and straightforward tasks. When you need a fast response to a simple question or want to check basic syntax, Haiku can provide answers almost instantly without using many resources.

• Sonnet 4.5 is the balanced, middle-tier model and serves as the default for Claude Code. It costs $3 per million input tokens and $15 per million output tokens. Sonnet offers significantly more capability than Haiku while still being reasonably fast and cost-effective. For most data visualization workflows—creating charts, analyzing datasets, debugging code, and getting detailed explanations—Sonnet provides the right balance of performance and cost. This is why it's set as the default model when you first start using Claude Code.

• Opus 4.5 is the most capable model, designed for complex work that requires sophisticated reasoning. It costs $5 per million input tokens and $25 per million output tokens. Opus excels at tasks that involve multiple steps, complex logic, or deep analysis. When you're working on intricate multi-panel visualizations, performing sophisticated data transformations, or need Claude to reason through complex problems, Opus provides the highest level of capability.

The pricing structure reflects the computational resources each model uses. Haiku is lightweight and fast, so it costs less. Opus uses more computational power to provide deeper reasoning and more sophisticated responses, so it costs more. Sonnet sits in the middle, providing strong performance for most tasks without the premium cost of Opus.

It's worth noting that while you're learning on CodeSignal, you don't need to worry about these costs—everything is already set up and paid for in your learning environment. However, understanding the pricing structure helps you make informed decisions about which model to use for different tasks, and this knowledge will be valuable if you decide to use Claude Code on your own computer after completing this course.

Now that you understand the three models available, let's learn how to switch between them. Claude Code provides a simple command for changing models: /model. Type this command at the prompt and press Enter:

> /model

You'll see an interactive menu appear:

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Select model
 Switch between Claude models. Applies to this session and future Claude Code sessions. For other/previous model names, specify 
 with --model.

 ❯ 1. Default (recommended)   Use the default model (currently Sonnet 4.5) · $3/$15 per Mtok
   2. Opus                    Opus 4.5 · Most capable for complex work · $5/$25 per Mtok ✔
   3. Haiku                   Haiku 4.5 · Fastest for quick answers · $1/$5 per Mtok

This menu shows you all three models with their descriptions and pricing. The arrow symbol (❯) indicates which option is currently selected. You can use your arrow keys to move up and down through the options. Notice that the menu tells you this change "applies to this session and future Claude Code sessions"—this means that when you select a model, it becomes your new default for all future conversations until you change it again.

The menu interface makes it easy to see your options and understand what each model offers. You don't need to remember exact model names or type complex commands—just run /model, use your arrow keys, and press Enter. This simplicity means you can quickly experiment with different models to find what works best for your specific tasks.

Understanding when to use each model is just as important as knowing how to switch between them. The table below shows practical scenarios for each model so you can make informed decisions about which one to use.

Here's a practical example to illustrate these differences. Imagine you're working on a project to visualize sales data. If you just need to quickly check the syntax for creating a bar chart, use Haiku. If you're loading a CSV file of sales data and creating a line chart showing sales trends over time with custom colors and labels, use Sonnet. If you're combining sales data from multiple sources, calculating year-over-year growth rates, identifying seasonal patterns, and creating a multi-panel dashboard with different chart types for different insights, use Opus.

As you work through the practice exercises in this course, you'll develop intuition about which model to use. Don't be afraid to experiment—you can always switch models if you find that your current choice isn't quite right for the task at hand. Over time, you'll naturally learn to match the model to the complexity of your work, making your data visualization projects more efficient and effective.

You've just learned something fundamental about Claude Code: it's not just a chatbot—it's an AI assistant with extensive built-in knowledge of Python and data visualization libraries. Claude already understands Matplotlib, Pandas, Seaborn, NumPy, and many other tools you'll use for data visualization. You don't need to provide documentation or explain these libraries; Claude can immediately help you with code examples, syntax questions, and practical guidance.

Remember that Claude's knowledge is a tool for you to leverage. When you're stuck on syntax, unsure about which library to use, or need help understanding how to create a specific type of visualization, Claude is there to help. And now that you understand the three models available, you can choose the right tool for each job—using Haiku for quick answers, Sonnet for your regular work, and Opus when you need maximum capability. This flexibility makes Claude Code an incredibly powerful assistant for your data visualization journey.