You've got four browser tabs open. One has ChatGPT, one has Microsoft Copilot, one has Claude, and one has Gemini. You paste the same question into all four and get four different answers. Some are better than others. Some are wrong in interesting ways. And now you're spending more time managing AI tools than actually doing your data work.
This is the reality for most data professionals right now. The AI landscape moved fast, the tools proliferated quickly, and nobody handed you a decision framework. You're expected to just... know which one to use. The good news is that once you understand what's actually different about these tools — not just the marketing language, but the real architectural and design differences — picking the right one for a given task becomes almost instinctive.
By the end of this lesson, you'll have a clear mental model for how each major AI assistant approaches problems, where each one genuinely excels for data work, and a practical decision process you can apply before you even open a new tab.
What you'll learn:
You don't need prior AI experience. You should have a basic sense of what data professionals do — writing queries, building pipelines, cleaning data, producing reports. Familiarity with SQL or Python at even a beginner level will help you appreciate the examples, but it's not required to follow the core reasoning.
Before comparing tools, let's establish what we're comparing. ChatGPT, Copilot, Claude, and Gemini are all large language models, or LLMs. That term sounds technical, but the concept is approachable: these are systems trained on enormous amounts of text to predict what a helpful, coherent response looks like given your input.
Think of them like extraordinarily well-read assistants who have absorbed most of the internet, thousands of textbooks, and millions of code repositories — but who have no memory between conversations (by default), can't run your code, and occasionally confabulate facts with complete confidence. That last part is important enough to repeat: all of these tools can be wrong. They don't "know" things the way you know your own name. They generate plausible-sounding responses based on patterns. Your job is to bring judgment they don't have.
Now, what actually differs between them?
Training data and cutoff dates determine what knowledge the model has. A model trained through mid-2023 genuinely doesn't know about a library released in late 2023.
Context window size determines how much text a model can "hold in mind" at once — including your conversation history, any documents you paste in, and the response it's generating. This matters enormously when you're working with schema files, lengthy data transformation logic, or CSV snippets you want analyzed.
System design and tuning reflects the priorities of the company building the tool. Some models are tuned heavily for safety and conservative answers. Some prioritize code quality. Some optimize for natural, flowing prose. These choices shape the output you get.
Integration with other tools determines whether the AI can actually see your spreadsheet, query your database, or run a Python cell in your notebook.
Let's look at each tool through this lens.
ChatGPT, built by OpenAI, is where most people started their AI journey, and for good reason. The GPT-4 model (available in ChatGPT Plus) is genuinely capable across a wide range of tasks, and the free tier (GPT-3.5, now GPT-4o mini) is accessible enough that most people have used it.
What ChatGPT does well for data work:
ChatGPT is excellent at explaining concepts. If you're new to window functions in SQL and you ask ChatGPT to explain them with a real example, you'll get a patient, well-structured explanation that builds from the ground up. It's also strong at writing boilerplate Python — data loading, pandas transformations, matplotlib charts. Ask it to write a function that reads a CSV, drops nulls in specific columns, and exports a cleaned version, and you'll get working code most of the time.
The Code Interpreter feature (now called "Advanced Data Analysis") is particularly powerful. When you upload a CSV file and ask ChatGPT to analyze it, it actually runs Python code in a sandboxed environment and shows you real outputs — actual charts, real summary statistics, genuine error messages when something breaks. This isn't pretending to analyze data. It's actually doing it.
Example prompt for ChatGPT Code Interpreter:
"I've uploaded our monthly sales data.
Please calculate the month-over-month growth rate for each product category,
identify the top 3 categories by total revenue,
and create a bar chart showing their trends over the past 12 months."
ChatGPT will write the Python, run it, show you the output, and explain what it found. For one-off exploratory analysis where you don't want to write the code yourself, this is legitimately useful.
Where ChatGPT struggles:
The free tier is noticeably weaker at complex, multi-step reasoning. If your SQL involves five CTEs (Common Table Expressions — basically named sub-queries you stack on top of each other), the free model starts to lose track of the logic. It also has a smaller context window on the free tier, which means if you paste in a long schema or a lengthy data pipeline, it starts forgetting the beginning by the time it's writing the end.
ChatGPT can also be overconfident. It will write SQL using syntax that doesn't exist in your specific database engine (say, using QUALIFY when you're on MySQL, which doesn't support it) without flagging this uncertainty.
Tip: Always specify your database engine when asking ChatGPT for SQL. Instead of "write a query to get the top 10 customers by revenue," say "write a PostgreSQL query to get the top 10 customers by revenue using a window function." The specificity dramatically improves accuracy.
Microsoft Copilot is a different kind of beast. While it also uses OpenAI's GPT-4 technology under the hood, Copilot's defining characteristic isn't the model — it's the integration. Copilot is embedded directly into Excel, Power BI, Teams, Word, Outlook, and the broader Microsoft 365 ecosystem.
For data professionals who live in the Microsoft stack, this changes everything. You're not copying data out of Excel to paste into a chat window. The AI is sitting inside the tool you're already using.
What Copilot does well for data work:
In Excel, Copilot can help you write complex formulas, generate pivot tables from natural language descriptions, and highlight patterns in your data — all without leaving the spreadsheet. If you have a messy column of dates in inconsistent formats, you can tell Copilot "standardize this date column to YYYY-MM-DD format" and it writes the formula in context.
In Power BI, Copilot can generate DAX measures (DAX is the formula language Power BI uses for calculations) from descriptions like "show me month-over-month revenue change as a percentage." Writing DAX from scratch is genuinely hard for beginners — the function syntax is unusual and the evaluation context rules trip up even experienced analysts. Having Copilot draft the measure and then explaining what it did can shorten your learning curve significantly.
Example Copilot prompt inside Power BI:
"Create a measure that calculates the rolling 3-month average of sales,
excluding weekends, filtered to the current year."
This would take a Power BI beginner a solid hour to figure out from documentation. Copilot can produce a working draft in seconds.
Where Copilot struggles:
Copilot is less useful as a standalone chat tool. When you use it outside of Microsoft 365 integrations (accessible at copilot.microsoft.com), it's capable but feels like a slightly more conservative ChatGPT. The search-grounded responses are helpful when you need current information, but for deep technical reasoning on data problems, it's not reliably ahead of the competition.
Copilot is also dependent on your organizational licensing. The full integration features require Microsoft 365 Copilot licensing, which is expensive and typically a company-level decision. If your company hasn't bought in, you're using a stripped-down version.
Warning: Copilot's access to your actual organizational data (SharePoint files, Teams messages, emails) is powerful but raises legitimate privacy questions. Understand your company's data governance policies before asking Copilot to summarize internal reports or analyze confidential datasets.
Claude is built by Anthropic, and it takes a meaningfully different approach from the OpenAI tools. Anthropic's research focus has been on building models that reason carefully, handle nuance well, and are genuinely honest about uncertainty. Claude tends to hedge when it's not sure, which can feel overly cautious — but in data work, "I'm not certain about this behavior in BigQuery specifically, you may want to verify" is more useful than a confidently wrong answer.
What Claude does well for data work:
Claude's context window is enormous. At the time of writing, Claude can handle up to 200,000 tokens in a single conversation — roughly 150,000 words or about 500 pages of text. For data professionals, this is transformative. You can paste your entire database schema, a lengthy stored procedure, a full data pipeline definition, and a sample of the data — all at once — and ask Claude to reason about the whole thing coherently.
Consider this realistic scenario: you're debugging a dbt (data build tool) model that produces incorrect revenue figures. The problem might be in the SQL logic, in how the upstream source model handles nulls, or in the grain of the join. You can paste the SQL for three related models, the schema YAML files, and a sample of the output data, then ask Claude: "Given all of this, why might the revenue total be double what's expected?" Claude can actually hold all of that context and trace the logic end-to-end.
Example: Debugging a multi-step pipeline with Claude
Paste in:
- Your staging model SQL (30 lines)
- Your intermediate model SQL (50 lines)
- Your final mart model SQL (80 lines)
- 10 sample rows from each model's output
- The schema YAML for column definitions
Then ask:
"The total_revenue column in the final mart is exactly 2x what
we see in our source system. Based on all of the above,
what's the most likely cause and where should I look first?"
Claude is also excellent for writing documentation. Data teams notoriously under-document their work. If you paste in a complex SQL transformation and ask Claude to write dbt model documentation in YAML format, including column descriptions, it does this with impressive nuance and will ask clarifying questions if the logic is ambiguous.
Where Claude struggles:
Claude does not currently have a built-in code execution environment the way ChatGPT's Code Interpreter does. It can write code and reason about code, but it can't actually run your data analysis and show you real outputs. You're working with the AI's prediction of what the code would produce, not actual execution. For exploratory data analysis where you want real charts and real numbers, this is a meaningful limitation.
Claude also doesn't have native integrations with data tools the way Copilot integrates with the Microsoft ecosystem.
Tip: Claude's thoughtfulness means it sometimes over-explains. If you're in a rapid iteration mode and just want code, add "respond with code only, no explanation" to your prompt. When you want the reasoning, ask explicitly: "explain your approach step by step before giving me the code."
Gemini is Google's AI, and like Copilot's relationship with Microsoft, Gemini's best features emerge from its integration with Google's ecosystem. If your data work happens in Google Sheets, Looker, BigQuery, or Google Colab, Gemini has native hooks that the other tools don't.
What Gemini does well for data work:
In Google Colab (the browser-based Python notebook environment), Gemini can help you write, explain, and debug code in context. This is similar to ChatGPT's Code Interpreter but embedded in the environment where data scientists already work. You're not copying code in and out of a chat window; the AI is a panel in your existing notebook.
Gemini is also deeply integrated with BigQuery. You can describe a query in natural language directly in the BigQuery console and Gemini will generate the SQL. For analysts who are comfortable with SQL concepts but less familiar with BigQuery-specific syntax — things like UNNEST() for working with nested JSON columns, or APPROX_COUNT_DISTINCT() for performance-optimized cardinality estimates — this is genuinely helpful scaffolding.
Example: Using Gemini in BigQuery
Natural language input:
"Show me the top 10 customers by total order value in the last 90 days,
include their email addresses, and only show customers with more than 3 orders."
Gemini generates BigQuery SQL with proper syntax,
including TIMESTAMP handling specific to BigQuery.
Gemini also has strong multimodal capabilities, meaning it can analyze images. If you screenshot a dashboard with a weird-looking chart and ask "why does this distribution look bimodal and what would cause that in sales data?" Gemini can engage with the image directly. This is a surprisingly practical capability for data work.
Where Gemini struggles:
Outside the Google ecosystem, Gemini's advantage shrinks considerably. As a standalone chat tool, it's competitive but not clearly ahead of GPT-4 or Claude for most data tasks. Its code generation quality is solid, but its explanations can feel thinner than Claude's and its error messages are sometimes less actionable than ChatGPT's.
Gemini has also had well-publicized quality issues in its early releases — moments where it produced factually incorrect outputs with high confidence. Google has improved the model significantly since those early stumbles, but if you're evaluating AI tools for a team, it's worth running your own tests rather than relying on any single source including this one.
Tip: If your organization uses Google Workspace and BigQuery, the case for Gemini is strong even if it's not the "best" model in a vacuum. Integration value often outweighs raw capability differences.
Given all of the above, here's a practical decision process. Think of it as a flowchart you run in your head before opening a tab.
Step 1: Where does your work live?
Step 2: What kind of task is this?
Step 3: Does context size matter? If your task requires the AI to understand more than about 10,000 words of context at once — long schema files, multiple SQL models, lengthy business requirements — use Claude.
Step 4: Do you need current information? If you're asking about a newly released library, a recent API change, or anything time-sensitive → Copilot (which has Bing search grounding by default) or ChatGPT with web browsing enabled.
This exercise is designed to build your evaluative instincts — the ability to judge AI output quality, not just receive it.
Setup: You'll need free accounts for at least two of the following: ChatGPT, Claude, Gemini, or Copilot.
The task: You're an analyst at a subscription software company. You have a table called subscriptions with these columns: customer_id, plan_type (values: 'basic', 'pro', 'enterprise'), start_date, end_date (null if still active), and monthly_revenue.
Step 1: Ask each tool the following prompt: "Write a SQL query that calculates, for each plan_type, the total number of currently active subscriptions, the average monthly revenue per active subscription, and the total revenue from subscriptions that churned (ended) in the last 30 days. Use PostgreSQL syntax."
Step 2: Evaluate each response against these criteria:
Step 3: Take the best response and intentionally break it: ask "what if end_date could also be set to a future date for scheduled cancellations?" and see how each tool handles the revised requirements.
What to notice: You're looking for which tools catch edge cases, which ones confidently produce subtly wrong logic, and which ones ask clarifying questions before assuming.
Mistake 1: Using one tool for everything out of habit Most people default to whichever tool they learned first. This is understandable but limiting. The exercise above is designed to help you feel the actual differences rather than just read about them.
Mistake 2: Trusting AI-generated SQL without reviewing it All four tools will occasionally write SQL that looks correct but has a subtle logic error — an off-by-one date range, a join that creates duplicates, an aggregation applied at the wrong level. Always review SQL against your expected output. Run it against a small sample first.
Mistake 3: Giving vague prompts and blaming the tool "Write me a data analysis" will produce mediocre output from any tool. The more specific your prompt — the business question you're answering, the table structure, the expected output format, the edge cases to handle — the better the result. Vague input is a user error, not a model limitation.
Mistake 4: Ignoring context window limits If you paste a 5,000-line schema into ChatGPT's free tier and the response starts referencing columns that don't exist, you've likely exceeded the context window. The model starts filling in gaps with plausible-sounding fabrications. Know the limits of your tool.
Mistake 5: Comparing tools on a single task and generalizing One impressive response from Gemini doesn't make it the best tool for all your work. One confusing answer from Claude doesn't mean it's bad at reasoning. Run multiple tests across different task types before forming strong opinions.
Let's crystallize what you now know. These four tools are not interchangeable commodities with slightly different logos. They have meaningfully different strengths:
The deeper lesson here is that choosing a tool is a skill. It requires you to think about what kind of task you have, where your data lives, how much context you need to provide, and what quality signals to look for in the output.
Where to go from here:
The best data professionals using AI right now aren't the ones who found the "best" tool. They're the ones who built the judgment to match the right tool to each problem — and who kept that judgment calibrated as the tools changed.
Learning Path: Intro to AI & Prompt Engineering