How I’m Making Sure My Analytics Career Doesn’t Get Eaten by AI

How I’m Making Sure My Analytics Career Doesn’t Get Eaten by AI

Every week another headline flashes by: “AI can now write your reports”, “GPT‑4 passes the CPA exam”, “Data analysts are next on the chopping block.” As an analytics professional, I used to lie awake wondering how long I had before a large language model replaced every line of SQL I write. Then I realised the question isn’t whether AI will come for my job—it’s whether I will use AI to make my job better, faster, and more valuable.

The major technology players are clear about their direction. OpenAI, Google, and Microsoft are pouring billions into making generative models smarter, cheaper, and more accessible. Meanwhile, the Towards Data Science community is full of analysts who are pivoting from “button pushers” to strategic advisors. My own plan is not to outrun the machines, but to ride them. This article walks through the concrete steps I’m taking right now—including tools, code, and workflows—to ensure that my analytics career survives and thrives in the age of AI.

Why the standard playbook isn’t enough

A few years ago, career safety meant mastering Tableau, Excel, and a bit of SQL. Today, a junior analyst can prompt a chatbot to produce a dashboard mockup in seconds. The skills that used to differentiate you—writing clean SQL, formatting charts—are becoming commoditised. As noted in the Microsoft AI Blog, the company is embedding Copilot into every tier of the data stack, from Excel to Power BI. Google’s AI Blog similarly showcases Vertex AI agents that write queries on the fly.

The analysts who survive will be those who can **ask the right questions, validate the answers, and translate numbers into decisions**. This is a skillset that no AI (yet) fully masters. To build that skillset, I’m combining three strategies:

• **Automating the boring parts** so I can focus on strategy.
• **Building custom AI tools** that augment, not replace, my reasoning.
• **Deepening my domain knowledge** so I can spot nonsense that a model might generate.

Below I explain exactly how I set up the technical foundation for this approach.

Requirements

Before diving into the installation, here are the prerequisites for the environment I use daily:

• **Operating system**: macOS or Linux (Windows with WSL2 also works)
• **Python** 3.10 or later
• **Git** (for version control and cloning repos)
• **A local machine** with at least 16 GB RAM (for running small language models)
• **An internet connection** for downloading models and packages
• (Optional) An API key from OpenAI if you want to fall back on cloud models

Step‑by‑step installation

I build my augmented analytics workflow around three core components: a local language model (via Ollama), a Python environment with LangChain, and a lightweight vector database (Chroma) for indexing internal documents. Here’s how I set them up.

#### 1. Install Ollama for local AI

Ollama runs large language models locally, keeping sensitive data off the cloud. I use it for exploratory analysis when I don’t want to pay per API call or when I’m offline.

# How I’m Making Sure My Analytics Career Doesn’t Get Eaten by AI
curl -fsSL https://ollama.com/install.sh | sh

Once installed, start the Ollama server in the background:

ollama serve &

Now pull a reasonably sized model. I recommend `mistral` for analytics tasks because it’s fast and decent with numbers.

ollama pull mistral

You can test it by running:

ollama run mistral "What is 15% of 340?"

#### 2. Set up a Python virtual environment

I keep my projects isolated to avoid dependency conflicts.

# Create a new directory for the project
mkdir ~/analytics-ai
cd ~/analytics-ai

# Create a virtual environment
python3 -m venv venv

# Activate it
source venv/bin/activate

#### 3. Install essential Python packages

Now install the libraries that glue everything together. I use `langchain` for prompt chains, `chromadb` for local memory, and `pandas` for data wrangling.

pip install langchain langchain-community chromadb pandas openai

If you plan to use Ollama from Python, also install:

pip install ollama

#### 4. Verify the installation

Run a quick sanity check to confirm everything works.

# test_imports.py
import langchain
import chromadb
import pandas as pd
import ollama

print("All imports successful!")

Execute:

python test_imports.py

If you see no errors, you’re ready to move to the usage examples.

Usage examples

With the environment ready, I can now show three real scenarios where AI augments my analytics work.

#### Example 1: Automate data summarisation with LangChain

Instead of writing a multi‑page memo, I let a local model produce a first draft. The script below reads a CSV of sales data and asks the model for a concise summary.

# summarize_data.py
import pandas as pd
from langchain.llms import Ollama
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# Load a sample CSV (replace with your own file)
df = pd.read_csv("sales_data.csv")

# Prepare a text representation (first 10 rows + columns description)
sample_text = f"Columns: {list(df.columns)}\n\nFirst 5 rows:\n{df.head(5).to_string()}"

# Define the prompt
prompt = PromptTemplate(
    input_variables=["data"],
    template="Given the following sales data, provide a one‑paragraph executive summary highlighting key trends.\n\nData:\n{data}\n\nSummary:"
)

# Use local Ollama model
llm = Ollama(model="mistral")
chain = LLMChain(llm=llm, prompt=prompt)

# Generate summary
result = chain.run(data=sample_text)
print("AI‑generated summary:\n", result)

Run the script:

python summarize_data.py

The model will return a paragraph like: “Sales in the Northeast region grew 12% quarter‑over‑quarter, while the West saw a decline of 3% due to inventory shortages…” **I always check the numbers manually**, but the draft saves me twenty minutes of typing.

#### Example 2: Ask questions about your own documents using RAG

I often need to answer questions about internal policies (e.g., “What is our data retention policy?”). Storing those policies in a vector database lets me ask questions without exposing them to the public internet.

# rag_query.py
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.llms import Ollama

# 1. Load your internal documents (here a single text file)
loader = TextLoader("company_policies.txt")
documents = loader.load()

# 2. Split into chunks
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(documents)

# 3. Create embeddings and store in Chroma
embeddings = OllamaEmbeddings(model="mistral")
vectordb = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")

# 4. Create a retrieval QA chain
qa_chain = RetrievalQA.from_chain_type(
    llm=Ollama(model="mistral"),
    retriever=vectordb.as_retriever()
)

# 5. Ask a question
query = "What is the maximum retention period for customer purchase data?"
answer = qa_chain.run(query)
print("Answer:", answer)

Save and run:

python rag_query.py

This approach makes me the go‑to person for quick answers—I no longer have to search through dozens of PDFs.

#### Example 3: Generate boilerplate SQL queries

Writing repetitive SQL stains my soul. I use an LLM to produce a first‑pass query, which I then review and optimise.

# generate_sql.py
from langchain.llms import Ollama
from langchain.prompts import PromptTemplate

prompt = PromptTemplate(
    input_variables=["question", "table_schema"],
    template="Given the table schema below, write a SQL query to answer the question.\n\nTable schema:\n{table_schema}\n\nQuestion:\n{question}\n\nSQL query:"
)

llm = Ollama(model="mistral")
chain = LLMChain(llm=llm, prompt=prompt)

schema = """
Table: orders (
  order_id INT PRIMARY KEY,
  customer_id INT,
  order_date DATE,
  total_amount DECIMAL(10,2)
)
Table: customers (
  customer_id INT PRIMARY KEY,
  name VARCHAR(100),
  region VARCHAR(50)
)
"""

question = "What is the total revenue per region for each month in 2024?"
sql = chain.run(question=question, table_schema=schema)
print("Generated SQL:\n", sql)

Run:

python generate_sql.py

I always sanity‑check the joins and aggregations, but starting from a reasonable query accelerates development considerably.

The human side: validation, ethics, and domain expertise

None of these tools matter if I use them as a black box. The key insight from the Towards Data Science community is that **AI is a junior assistant, not a senior analyst**. Every output I get, I verify:

• Numeric claims: am I sure the model calculated the percentage correctly? (Often not.)
• Logical consistency: does the summary contradict known business rules?
• Bias: does the model ignore a segment that the business cares about?

I also keep my domain knowledge sharp. I read the Google AI Blog to understand what the models can’t do (e.g., causal inference, counterfactuals). I follow the Microsoft AI Blog to see how enterprise tools are integrating AI—and then I learn to use those tools before my peers.

Conclusion

The threat of AI to analytics careers is real, but it is not a death sentence—it’s a reset. The analysts who thrive will be those who stop writing every line of code by hand and start **designing systems that produce insights faster**, while applying human judgment to interpret, challenge, and communicate those insights.

I am making sure my career doesn’t get eaten by AI by eating AI first: installing local models, building retrieval‑augmented pipelines, and automating the grunt work that used to take hours. The technical steps in this article are the foundation. The real differentiator, however, is curiosity—asking “why” when the model spits out an answer, and knowing when to ignore it.

If you are an analytics professional, start today: install Ollama, write one script that augments a report you already produce, and see how much time you free up. Use that time to talk to stakeholders, learn the business model, and become the person who connects data to decisions. That is how you stay irreplaceable.

**Further reading (general context only):**

• Towards Data Science – articles on career pivots and analytical thinking
• OpenAI News – updates on model capabilities and safety
• Google AI Blog – research on responsible AI and data tools
• Microsoft AI Blog – enterprise AI integration in analytics

*No specific article, date, or author from the above sources has been cited because the sources are general landing pages.*