What started as a small experiment on a Friday afternoon evolved into something unexpected—my central command center for project management, strategic communications, and operational intelligence. Through the Model Context Protocol (MCP), it connects seamlessly with my existing tools rather than trying to replace them.

This isn’t just about writing better code faster. It’s about transforming how AI integrates with my workflow—evolving from a separate tool into a seamless layer across my entire work environment. What began as a casual Friday experiment has become my indispensable command center, something I find myself opening dozens of times throughout each day.

The Promise That Actually Delivered

Many productivity tools promise to be a “second brain” but end up being yet another system to maintain. I tried many and always failed—too opinionated or too open. Claude Code is different: it doesn’t replace tools, it connects them. Through the Model Context Protocol (MCP), it can read my emails, access my project management tools, pull from documentation systems, and write back to them seamlessly.

I approached the setup with a different mindset than adopting a new tool. I looked for a setup that works for AI, not for me to babysit. I don’t want to be in charge of making sure meeting transcripts have the correct metadata and are linked to relevant projects. That is the AI’s job. My job is to provide information and give guidance.

The result? An AI assistant that actually understands my context without me having to explain it every time.

Consider my morning routine: Instead of checking five different systems to understand my day, I simply run /briefing in Claude Code. In seconds, it gives me:

• Unread emails requiring my attention

• Today’s meetings with relevant context

• Outstanding tasks from Todoist

• Recent updates from my team’s Confluence and Jira

This isn’t magic—it’s what becomes possible when AI can access the actual work environment rather than operating in isolation.

The Architecture of Integration

What makes Claude Code effective as my strategic hub comes down to four key components that work together:

Persistent Instructions via CLAUDE.md I don’t lose context with each conversation. Claude Code reads a CLAUDE.md file that defines my working style, communication preferences, and standard operating procedures. This keeps every interaction consistent in tone, format, and approach—crucial for professional communications. I found that Claude Code follows instructions in CLAUDE.md way better than other LLMs and agents do.

Tool Integration Through MCP This is where the real power lies. Through MCP servers, Claude Code connects with my essential systems: BigQuery for analytics, Confluence for documentation, Microsoft Graph for communications, Todoist for task management, and my local filesystem. This integration creates a unified working environment that adapts to my specific needs.

Specialized Sub-Agents

I’ve designed specialized sub-agents for different domains, each handling specific tasks with domain-appropriate knowledge and tools. For example, my Office Agent connects to Microsoft Graph API for email drafting and meeting scheduling, while my Research Agent integrates with documentation systems. These domain-specific agents maintain their own context and expertise, allowing Claude Code to delegate subtasks efficiently and create a collaborative system rather than trying to handle everything itself.

Custom Slash Commands I treat these as programmable shortcuts. /standup generates my team status, /summarise condenses meeting notes, /tomorrow previews priorities. Each turns complex processes into a single, memorable action. Every prompt I use more than 3 times gets added as slash command.

The magic happens when these capabilities combine. When I ask for a project status update, Claude Code can pull the latest data, check related documentation, identify blockers from my task list, and format everything according to my communication standards—all in one fluid interaction.

Beyond Efficiency: Strategic Amplification

The real transformation isn’t just about doing existing tasks faster—it’s about becoming capable of strategic work that was previously impractical.

Take quarterly planning: Previously, gathering context across multiple systems, synthesizing insights, and drafting strategic communications would consume entire days. Now, I can ask Claude Code to collect current initiatives and status, pull progress from Jira tickets and look through my notes for next quarter’s ideas and commitments —all within a single conversation thread.

The AI doesn’t make the strategic decisions, but it eliminates the friction that often prevents good strategic thinking: information gathering, context switching, and administrative overhead.

The Learning Curve That’s Worth It

Let’s be clear about the realities: Setting up Claude Code as my operational hub requires investment. I needed to:

• Find a good file structure that works for AIs

• Configure MCP servers for my specific tools

• Develop my CLAUDE.md instructions through iteration

• Design slash commands and subagents that match my workflows

• Establish boundaries for what the AI should and shouldn’t access

Initial setup was frustrating at times as simple tasks failed, some integrations needed tweaking. Yet after about 2 weeks of adjustments, I had a mostly smooth experience.

But here’s what I’ve learned: these limitations pale compared to the cognitive overhead of managing multiple systems manually. The occasional error is far outweighed by the consistent value of having an AI assistant that truly understands my working context.

The Broader Implications

Claude Code as my strategic operations hub represents something larger: the emergence of AI as genuine workplace infrastructure rather than a standalone tool. I’m seeing a move beyond “AI for coding” or “AI for writing” toward AI as an integration layer that connects and amplifies existing capabilities. Personal copilots are the most prominent example of this shift.

This shift raises important questions for me and my teams: How do I maintain human oversight when AI handles increasingly complex workflows? What happens to institutional knowledge when AI becomes the primary interface for our systems? How do I balance automation with the need to stay connected to the details of the work?

With the speed of innovation these questions will become only more pressing and the frontier of what is possible is constantly moving.

My Next Steps

When I started my copilot in Claude Code I deliberately started small; after all I had a working copilot in Claude Desktop already.

The goal wasn’t to automate everything immediately. I was developing an understanding of where AI integration adds genuine value versus where it creates unnecessary complexity.

Now I am at a state where my copilot is truly useful and I use it constantly throughout the day for all kinds of tasks.

Looking forward, I see significant opportunities to make my copilot even more proactive. I want to automate more routine tasks - for example, when I need to schedule a meeting, instead of manually checking everyone’s availability, the copilot should interface with my calendar to find optimal times that work for all participants and propose them.

These workflow automations would eliminate dozens of micro-decisions I make daily, freeing up mental bandwidth for more strategic work.

Have you built your AI copilot yet? I want to hear your stories! What unexpected wins have you discovered? Where have you hit walls? Which workflows transformed overnight?

The question isn’t whether these kinds of AI agents will become part of our work — it’s whether you’ll be ready when they do.

I’d love to learn from others navigating this evolving landscape.

It reminded me of using my first smartphone app. The hardware hadn’t changed, but suddenly the device could do things I’d never imagined. For our team, MCP was that same unlock moment for AI. What had always been confined in a chat interface was now ready to transform how we work.

But what exactly is MCP? The Model Context Protocol is Anthropic’s open-source standard that lets AI assistants like Claude connect directly to your tools—databases, documentation systems, code repositories, you name it. Instead of copy-pasting information back and forth, your AI can now read from and write to these systems directly. Think of it as giving your AI assistant actual hands to work with, not just a voice to talk. It’s the difference between describing what needs to be done and actually doing it.

The Hidden Cost of Tribal Knowledge

Before I share our transformation, let me paint you a picture of where we started. Our team’s knowledge was scattered across Teams chats, email threads, and meeting notes that vanished into the void. Critical insights lived exclusively in people’s heads.

Every question about KPI definitions meant interrupting the same two analysts. Every bug investigation required hunting down whoever built that dashboard six months ago. When someone took vacation, projects stalled. When someone left, institutional knowledge walked out with them.

We weren’t just inefficient—we were fragile. One key person getting sick could derail an entire sprint. This wasn’t sustainable, yet every attempt to fix it failed. At a fast-paced company, the next project is already waiting for you impatiently. And what gets sacrificed first? You know the answer.

The Moment AI Clicked for Everyone

When we started experimenting with MCP servers, there was genuine excitement, that rare spark of curiosity that glues people to their laptops for hours.

Nearly everyone started by connecting BigQuery and conversing with our data warehouse. That itself wasn’t revolutionary, but it was the gateway drug—the “aha moment” that hooked them on exploring deeper.

One team member went all-in, connecting his AI copilot to Obsidian for personal notes, Confluence for team docs, and BigQuery for our data. His experiment quickly became his default workflow for anything requiring planning, prioritization, or analysis.

The moment I knew we’d crossed a threshold? He used his MCP-enabled copilot to analyze raw output from a complex marketing experiment. Not just summarize it—actually analyze it, generate visualizations, and draft findings. Then, with a single command, he published the entire analysis to Confluence. Within days, teams across the company were referencing his work.

The Virtuous Cycle Nobody Expected

We didn’t set out to “solve documentation.” It just happened. Suddenly, analysts could say, “document this in Confluence” right after a task—no friction, no forgetting, no context-switching.

Almost overnight, our Confluence space flipped from graveyard to living hub. Each new doc gave our AI copilots more context, making the next analysis—and the next doc—even easier. Documentation became a force multiplier: the better our records, the smarter our AI, and the faster we moved.

The real payoff? Projects moved faster, knowledge stayed put, and we stopped worrying about what would break if someone went on vacation. One config file, and our team went from fragile to resilient.

Reality Check: Where the Rubber Meets the Road

Let’s be honest—it wasn’t all magic and rainbows. The simplicity of setup made the subsequent challenges more jarring.

Sometimes the AI would misfire spectacularly, like attempting to write to a read-only database or pulling from the wrong Confluence space. When we got overzealous and connected too many MCP servers, the LLMs would ignore some tools or simply forget about them. Corporate security restrictions meant some tools remained tantalizingly out of reach.

But the biggest challenge was maintaining quality at scale. When AI writes significant portions of your documentation, human oversight becomes critical—yet exhausting. LLM responses can mask subtle errors in the details that matter most, requiring constant vigilance.

We learned that giving AI agency only works when you maintain the foundations it depends on. The right context at the right time matters more than drowning it in information.

The Paradox That Changed Everything

Here’s what I didn’t see coming: the more we automated, the more human our work became. By offloading the mechanical tasks—documentation, routine queries, standard analyses—we created space for what actually matters: strategic thinking, creative problem-solving, and meaningful stakeholder partnerships.

That experiment analysis wasn’t valuable because AI wrote it up nicely. It was valuable because my colleague could focus on interpreting results and crafting actionable recommendations instead of wrestling with formatting. The AI handled production; humans provided insight.

This wasn’t replacement—it was amplification. And it revealed an uncomfortable truth: a lot of “analytics work” is actually just information logistics. Once we accepted this, we faced an even more unsettling realization: the only barrier between most teams and this transformation is simply knowing it exists. It will always require highly-qualified humans working with data, but their day-to-day job is going to change… a lot!

Your Gateway to the Future

The setup is shockingly accessible. MCP isn’t some complex enterprise rollout requiring consultants and committees. It’s literally editing a text file to connect the world’s most advanced AI models to your everyday tools. Install Claude Desktop (or Cursor, or Windsurf), add a few lines of configuration, and you’re off to the races.

That simplicity is both thrilling and terrifying. The only real obstacles are organizational: permission to experiment, willingness to evolve workflows, and discipline to maintain knowledge hygiene and continued vigilant human oversight.

Teams that figure this out now will operate on an entirely different level than those that don’t. Not because they have fancier tools, but because they’ll have reclaimed all the time and mental energy currently required for necessary, but boring tasks.

Your Move

We started with a modest goal: make documentation less painful. We ended up fundamentally changing how our team operates. Knowledge once locked in heads is now accessible for everyone. Friction that slowed projects has largely vanished. The fragility that sometimes kept me up at night has given way to resilience.

But here’s what really keeps me awake: if a single config file can unlock this much potential, what else are we leaving on the table? What other “impossible” problems are actually just one small experiment away from being solved? The whole AI landscape evolves so fast, that it is hard to imagine what will be possible in 6 months time.

So I’ll leave you with this challenge: What’s the one workflow in your team that everyone accepts as “just how things are”—but secretly costs hours every week? Because I’m betting LLMs with MCP can at least alleviate the pain.

What I was doing, without fully realizing it, was participating in what's now being called "vibe coding" - a term that gained popularity when AI researcher Andrej Karpathy quipped about "fully giving in to the vibes... and forget code even exists." This approach transforms programming from writing line-by-line code into a natural language conversation with AI.

Today, I want to go deeper into this trend that's reshaping how software gets built, who can build it, and what skills truly matter in the AI era. What does this shift mean for developers, teams, and the future of coding itself?

The Vibe Coding Revolution

The core concept of vibe coding is simple yet transformative: instead of writing code directly, you describe what you want in plain language, and AI tools generate the implementation for you. You become less of a traditional programmer and more of a director, guiding the AI toward your vision.

The hype around vibe coding is huge already. Tools like Cursor have exploded in popularity, reaching an estimated 360,000 users and $100M ARR within just a year of launch. Meanwhile, Lovable - another vibe coding platform - amassed over 30,000 paying customers in just three months, with users creating more than 1.2 million apps.

The workflows emerging around these tools are fascinating:

• Rather than starting with boilerplate code, developers begin with a natural language specification

• Instead of writing functions line by line, they ask for features like "add a user login system" or "create an analytics dashboard"

• Rather than spending hours debugging, they can highlight problematic code and say "fix this issue"

For experienced developers, this means less time on tedious tasks and more focus on architecture and problem-solving. For newcomers, it lowers the barrier to entry dramatically. It's no wonder these tools are being adopted so rapidly.

Democratizing Development

Perhaps the most exciting aspect of vibe coding is how it's expanding who can build software. In my previous newsletter, I mentioned how I was able to jump back into development after years away - but the implications go much further.

Product designers can now skip high-fidelity mockups and build interactive prototypes directly. Entrepreneurs can launch MVPs without hiring an engineering team. Analysts can create data tools without deep programming knowledge.

This democratization is powerful. Software has eaten the world, but until now, only a small percentage of people could create it. Vibe coding is changing that equation, giving more people the ability to bring their ideas to life.

The Evolving Role of Professional Developers

Rather than making developers obsolete (a common fear), the rise of AI is creating two distinct tracks in software development: casual "vibe coding" for rapid creation and AI-enhanced professional development for complex, production-grade systems.

Casual Vibe Coding

This approach, which I used for my side projects mentioned earlier, excels in contexts where speed and iteration trump architectural perfection:

• Quick prototypes and MVPs

• Personal projects and tools

• Simple applications with limited scope

• Learning environments and experiments

The focus here is on rapid results—getting something functional that can validate ideas, demonstrate concepts, or solve immediate problems without the overhead of traditional development processes.

AI-Enhanced Software Development

For enterprise applications, critical systems, and production environments, a different paradigm is emerging. Professional developers are integrating AI into more rigorous workflows where they become:

1. System architects who define software structure that AI fills in

2. Prompt engineers who precisely articulate requirements for the AI

3. Quality guardians who rigorously validate AI-generated code through testing and code review

4. Technical directors who guide AI through complex problems while maintaining overall vision

5. Integration specialists who connect AI-generated components into robust systems

In these professional settings, AI isn't replacing software engineering disciplines - it's augmenting them. Version control, code reviews, performance testing, and security practices remain essential, but they're now complemented by AI capabilities.

Some development teams are establishing formal patterns: using AI for the first draft of code, pair programming with it on complex problems, or delegating specific components while maintaining human oversight on critical paths. It's a more structured approach that treats AI as a powerful team member rather than a replacement for human expertise.

This evolution reminds me how computers transformed mathematics—they didn't replace mathematicians but revolutionized their workflow, enabling them to tackle previously impossible problems. Similarly, AI tools are liberating professional developers from boilerplate code, allowing them to focus on the creative and strategic aspects of software creation.

The Pitfalls: What We're Learning

As the saying goes, with great power comes great responsibility, and vibe coding exemplifies this perfectly. Here are a few pitfalls you need to be aware of when vibe coding:

1. The Learning Paradox

A quick online review of vibe coding experiences reveals several cautionary tales: developers losing months of work due to missing version control, exposed databases compromising user data, and security vulnerabilities arising from incomplete understanding of best practices. These incidents underscore the importance of maintaining fundamental development practices even while embracing AI assistance.

This highlights what I call "The Learning Paradox" of AI-assisted development: the same tools that make coding more accessible can inadvertently short-circuit essential learning. When AI handles the difficult parts, developers might skip building the foundational knowledge they'll need when things go wrong.

Traditional learning paths followed a logical progression: master simple queries before complex ones, understand basic data structures before advanced algorithms. Each step built on the last, creating a solid foundation of knowledge. But AI tools can generate complex code without requiring you to understand the fundamentals first—like giving someone advanced calculus solutions without teaching basic arithmetic.

This doesn't mean we should avoid these tools, but rather that we need to be intentional about skill development. The developer who lost months of work might not have made that mistake had they learned coding through the traditional, sometimes frustrating path that emphasizes fundamentals like version control from day one.

2. Quality and Maintainability Concerns

AI-generated code often works on the surface but may have hidden issues:

• Over-engineered solutions with unnecessary complexity

• Subtle bugs that only appear in edge cases

• Security vulnerabilities that aren't immediately obvious

• Poor performance optimization

• Difficulty maintaining code whose rationale isn't clear

I've experienced this firsthand. Recently, while building a feature using Cursor, the AI suggested an elegant-looking solution that actually circumvented the authentication system. If I hadn't been testing thoroughly, this would have caused problems down the line.

3. Versioning and Auditability Challenges

Traditional development practices need adaptation in the vibe coding era:

• How do you track which parts of code came from your intent versus the AI's inference?

• When a bug is found months later, how do you trace back through AI-generated code?

• What about licensing issues when AI potentially incorporates open-source snippets?

These aren't insurmountable problems, but they require new approaches. Some developers have started logging prompts as part of their documentation, creating an audit trail that explains why code was written a certain way.

Moving Forward: Finding Your Sweet Spot

After several months working with these tools, I've discovered that success lies in finding the right balance between AI assistance and engineering discipline.

When to Vibe and When to Engineer

For getting started, exploring ideas, and building MVPs, vibe coding is revolutionary. I can transform concepts into working prototypes in hours instead of days, testing assumptions and gathering feedback with unprecedented speed.

However, as projects mature toward production, traditional software engineering skills become increasingly vital. Production-ready code requires robust error handling, performance optimization, security considerations, and maintainable architecture that AI alone cannot (yet) provide.

What This Means for You

For professional developers: Embrace AI for rapid prototyping and mundane tasks, but maintain your expertise in system architecture and fundamentals. Your value increasingly lies in the areas AI struggles with—making critical design decisions, ensuring security, and architecting scalable systems.

For newcomers: These tools can help you build projects that once seemed out of reach, but invest time learning the fundamentals alongside your AI experiments. The developer who lost months of work illustrates why understanding basics like version control remains essential.

For teams: Consider how these tools might reshape your workflows. Could designers prototype directly? Might PMs implement simple features themselves? Then establish guidelines for when projects transition from "vibe mode" to more rigorous engineering practices.

The future isn't about AI replacing human expertise—it's about finding the right partnership where AI handles the tedious parts while humans focus on creativity, judgment, and the deeper aspects of software engineering that truly require our unique capabilities.

Final Thoughts

The vibe coding movement represents a profound shift in how software is created - blending human creativity with AI capabilities in ways that were science fiction just a few years ago. While it comes with challenges, the potential benefits for productivity, creativity, and accessibility are too significant to ignore.

As I continue my journey with these tools, I've learned that they don't replace the need to understand fundamental software principles - they amplify what you already know and can do. The future isn't about AI replacing human effort - it's about a new kind of partnership where each side brings unique strengths to the table.

I'd love to hear about your experiences with vibe coding tools. Have you tried Cursor, Lovable, Bolt or similar platforms? What successes or challenges have you encountered?

This desperate Reddit post caught my eye last week – a developer who had leveraged AI-powered coding to build a project over several months, only to see it vanish with a single misplaced command. The developer hadn't established basic Git version control, a foundational skill most programmers learn in their first weeks of training.

The irony wasn't lost on me. In the last post, I shared how Cursor helped me build three applications in record time after a 4-year coding hiatus. AI coding tools are transformative, but as this cautionary tale demonstrates, they create a fascinating paradox: the same tools that accelerate our work can inadvertently short-circuit essential learning.

This incident crystallizes the challenge analytics teams face today: How do we harness AI's incredible efficiency while ensuring team members develop the foundational skills needed to make the most out of their AI copilot?

When Easy Becomes Too Easy

Remember your first data job? If you're like me, you probably spent countless hours cleaning messy data, writing (and rewriting) SQL queries, and building reports that weren't quite right. These tasks weren't just about getting work done – they were essential learning experiences that built your foundational skills through good old-fashioned trial and error.

Today, that landscape has fundamentally shifted. What once took days of productive struggle can now be accomplished in minutes with the right prompts. While this acceleration of work is impressive, it creates an interesting challenge: How do you develop deep understanding when AI can handle the basics?

The New Learning Curve: Not Your Standard SQL Tutorial

I've noticed a fascinating pattern emerging in analytics teams, including my own. I have seen junior team members producing code and analyses faster than ever, yet sometimes struggling when systems break or edge cases appear. It's not that they lack intelligence, talent or dedication – it's that their learning journey has fundamentally changed.

In the traditional analytics learning path, the progression was relatively straightforward:

You'd start with simple SELECT statements, gradually adding JOINs and subqueries as you built confidence. You'd create basic charts before tackling complex dashboards. Each step built naturally on the last, creating a solid foundation of knowledge through sustained practice and occasional failures. The skills developed through this gradual progression – especially troubleshooting and debugging – became invaluable as problems grew more complex.

Today's learning landscape is radically different. With AI tools generating complex code on demand, analysts can begin their journey with advanced concepts like window functions and statistical models without necessarily understanding the fundamentals behind them. On the one hand that enables people to contribute meaningful results early on, on the other hand they are wielding powerful tools without knowing the proper technique.

This disruption of the traditional learning sequence creates a fascinating paradox: we can produce sophisticated work faster than ever, but might be building on shaky foundations. It's like learning to drive in a vehicle with advanced driver assistance – you can navigate effectively in ideal conditions, but might not develop the instincts needed when systems fail or conditions change.

The traditional learning ladder now has some critical middle rungs missing. The question becomes: how do we ensure analysts develop both speed and depth when the natural progression of difficulty has been short-circuited?

What's often missing is learning from first principles - understanding why certain approaches work rather than just that they work. First-principles thinking enables analysts to break down complex problems into their fundamental components, reason from the ground up, and build solutions based on core truths rather than pattern matching or templates. This type of thinking allows analysts to adapt when facing novel problems, build intuition about data relationships, and develop confidence in their technical judgments. These capabilities become essential when AI-generated solutions fail or when unprecedented business questions arise.

Finding the Sweet Spot: When to Embrace the Struggle

Here's where things get interesting. Think about learning to ride a bike. While training wheels prevent falls, they also delay mastering the real skill of balancing. The same principle applies to learning new skills in the workplace – we learn best through what's called the "Goldilocks effect," where tasks are neither too easy nor too hard, but "just right."

AI tools, however, can accidentally remove this productive struggle. When ChatGPT can instantly generate a perfect SQL query or Claude can fix the bug in your Python code, it's like having training wheels that never come off. You only get as far as AI takes you – and no further. Sure, you'll get to your destination, but you might miss out on developing crucial skills along the way:

• The pattern recognition that comes from debugging your own code

• The deep understanding of why certain approaches work better than others

• The intuition about data structures that only develops through hands-on experience

• The confidence that comes from solving complex problems on your own

Eventually, a cyclist needs to remove the training wheels to develop true mastery. They might fall occasionally, but each fall teaches valuable lessons about balance and control that can't be learned any other way. Similarly, learners need moments of productive struggle – writing code from scratch, troubleshooting their own errors, and reasoning through complex problems – to develop the expertise that makes them truly effective. This creates a tricky balance: how do we leverage AI's power while ensuring we're occasionally taking off the training wheels to develop deep, independent expertise?

Making Analytics Learning Work in the AI Era

Through experimentation with our team, we've discovered approaches that help develop strong analytical skills while leveraging AI's benefits. Here's what works at different levels:

Use AI as a Validator, Not a Generator: Write your own solutions first, then use AI to check and improve them. This maintains the learning challenge while providing valuable feedback. For instance, if you're crafting a complex SQL query, write it yourself first, then ask AI to review it for optimization, potential errors, or alternative approaches.

Practice Selective Difficulty: Choose specific areas where you'll intentionally work without AI assistance. If you're learning a new programming language, try writing small scripts or functions without AI autocomplete to reinforce syntax and logic understanding.

Focus on What AI Can’t Do: AI excels at generating code and identifying patterns, but struggles with defining problems worth solving and connecting insights to business value. By focusing learning efforts on these human-centered skills, analysts develop capabilities that complement AI rather than compete with it.

Establish Review Processes: Create checkpoints where team members explain not just what they did, but how and why. Questions we ask: How did you break down the problem? Where did you use AI assistance? What would you do differently next time?

The silver lining in all this change is significant: AI handling routine tasks frees up time for more strategic work earlier in careers. Junior analysts can now contribute meaningful insights much faster than before, assuming they develop the right skills to work effectively with AI. Rather than spending months mastering syntax, they can focus on learning the business context that makes their analyses truly valuable.

Building the Future of Analytics Learning

The AI revolution isn't just reshaping our workflows – it's fundamentally transforming how we learn and grow as professionals. This transformation brings both opportunity and challenge: while AI has disrupted traditional learning paths, it's also unlocked unprecedented potential for rapid skill development and impact. The key lies not in choosing between human expertise and AI capabilities, but in mastering their synergy.

As we look to the future, analytics talent development is evolving into something remarkable – a powerful fusion of deep technical understanding and AI-enhanced capabilities. The most successful analysts won't be those who simply lean on AI as a crutch, nor those who stubbornly resist it. Instead, they'll be the ones who embrace AI as a partnership, maintaining their intellectual curiosity while leveraging AI to amplify their capabilities. Think of it as developing a new kind of literacy – one that combines human insight with machine intelligence.

I'm curious to hear your perspective on this evolving landscape. How is your team navigating the balance between AI assistance and fundamental skill development? What strategies have proven effective (or surprisingly ineffective) in your experience? Share your thoughts below – let's learn from each other's journeys in this fascinating new era.

This was made possible by Cursor, an AI-based code editor that transformed how I write code - by letting me barely write any code at all. While new AI models get ever more capable, the breakthrough is not just in the models themselves. It's in tools that integrate AI in new, intuitive ways. AI isn't just another feature - it's becoming the core of a whole new generation of software, and we're just seeing the first glimpses. Cursor is exactly that. While AI-assisted coding has been around since GitHub Copilot launched in 2021, it never gained real traction. What's different now is a new wave of development tools that have AI capabilities built into their very core.

What makes Cursor special?

The biggest paradigm shift when working with Cursor is simple - you practically don't write code anymore. Instead, you have conversations about what you want to build. Most of my interactions happen in the Composer window, which acts like a super-powered chat interface. I might type 'Add a function that parses the HTML from a URL and summarizes it using GPT’ or 'Fix this bug where the form submission fails on mobile,' and Cursor will generate, modify, or debug the necessary code across multiple files.

Let me give you a real example. Last week, I needed to add user authentication to a Nuxt.js app. Instead of spending hours setting up routes, forms, and API calls, I simply told Cursor: 'Add Supabase authentication with email and Google sign-in options.' Within minutes, it had created the necessary components, set up the authentication flow, and even added error handling. The implementation worked on the first try and only needed minor enhancements to the user flow.

Of course, it's not a replacement for a human developer. You still need to know what you want to build and handle complex business logic yourself. But that's not the goal - Cursor isn't trying to replace developers, it's augmenting them. Think of it as pair programming with an AI that handles the tedious parts while you focus on the bigger picture.

My personal Cursor experience

Like many technical managers, I started as a data scientist who could build useful things, even if they weren't pretty. This ability to quickly prototype ideas was invaluable early in my career. But as I moved into management, coding fell by the wayside. Every time I tried to build something in my spare time, the overhead of setup and boilerplate code killed my momentum. For four years, I sat on ideas because I couldn't find the energy to bring them to life.

Enter Cursor.

Over Christmas break, I installed Cursor and everything changed. Within two weeks, I built three projects: an AI agent helping me with researching newsletter content, a Google Books/Notion integration that helps me manage my reading list and a small personal dashboard. The game-changer wasn't just coding faster - it was eliminating the mental overhead. Instead of juggling files and remembering where I left off, I could just open my laptop and start describing what I wanted to build.

This momentum carried forward. I've since launched btw-vergleich.de, a website that compares election programs for the upcoming German federal election, and made significant progress on an app idea I've been sitting on for 1.5 years. The barrier between idea and implementation has never been lower.

Cursor at work

Developing personal projects is one thing - working with large corporate codebases is another beast entirely. Multiple developers, strict performance requirements, and complex dependencies all raise the stakes. My personal success with Cursor made me optimistic, but would it hold up in a professional environment?

The answer is a resounding yes. After sharing my experience, a data engineer on my team decided to try Cursor on his backlog. Within a week, he had closed over 20 tickets - everything from adding new features, enhancing existing ones and fixing bugs. He actually complained about 'ticket fatigue' because he was closing tickets faster than he could remember what he worked on.

This wasn't just about speed - the quality held up under review. Cursor-generated code followed our style guides, included proper error handling, and came with comprehensive test coverage. Other teams in the company discovered Cursor around the same time and word spread quickly. Within two months, my entire team had company licenses, and today over 100 people across our company use Cursor daily.

While it's too early to quantify the full impact, the early indicators are clear. Tasks that used to eat up hours - writing test cases, adding documentation, creating boilerplate code - now take minutes. This frees up our developers to focus on what really matters: solving complex business problems and building new features that drive value.

Tips for getting the most out of Cursor

While Cursor is incredibly powerful, knowing a few key strategies can help you avoid common pitfalls and maximize its potential. Here are five tips I've learned from months of daily use:

1. Focus on the Composer Window Cursor offers both Chat and Composer views, but Composer is where the real magic happens. Unlike Chat, which is for general questions, Composer understands your codebase and can directly modify your files. Skip the Chat and go straight to Composer - simply tell it what feature you want to build or what bug needs fixing.

2. Enable Agent Mode There's a small but crucial toggle in Composer between normal and agent mode - always choose agent. While it takes longer to generate code, the quality improvement is worth the wait. Agent mode can self-correct and verify its work. For the adventurous, try YOLO mode in settings, which lets Cursor delete files and run terminal commands autonomously.

3. Commit Early and Often When Cursor goes off track, it rarely happens obviously. Instead, you might find yourself in a cycle of trying to fix increasingly broken code. Regular Git commits are your safety net - when things go sideways, you can easily revert to your last working state and try a different approach.

4. Start With a Plan While Cursor can build projects from scratch, it works best with direction. Before starting, write a quick project plan: your goals, preferred tools, and key requirements. Run this plan through ChatGPT or Claude first to get a basic prototype, then let Cursor expand it into a full project. I recently used this approach to build a Nuxt.js app with Supabase authentication in record time.

5. Augment with Documentation Like all AI tools, Cursor sometimes needs help with newer libraries or specific issues. Share relevant documentation or GitHub issues in your prompts - this dramatically improves its ability to generate correct, up-to-date code.

These practices help maintain momentum while avoiding the occasional AI rabbit holes that can eat up your time.

Outlook & Conclusion

While I've focused on Cursor, it's just one player in a rapidly evolving landscape. GitHub Copilot has launched a powerful new version, Cline offers a compelling alternative to Cursor, and specialized tools are emerging for specific needs:

• Lovable for browser-based app development

• v0 for frontend-focused work

• Replit Agent for backend development

The field is moving so quickly that specific tools and features I've described might be outdated in a few months. But that's not what matters. What's happening here is a fundamental shift in how we build software. AI isn't just helping us code faster - it's changing our relationship with development itself. The tedious parts - boilerplate, testing, documentation - are increasingly handled by AI, letting us focus on the creative and strategic aspects of building software.

This is a unique moment. In a year, AI-assisted development will be the norm. But right now, it feels like having superpowers. Whether you're a seasoned developer or, like me, someone who just wants to bring ideas to life, these tools supercharge your productivity.

Don't wait for this to become standard practice. Install Cursor today, try building something small, and experience this shift firsthand. The gap between idea and implementation has never been smaller - take advantage of it.

Creating the Right Environment

Encourage experimentation

Adopting AI tools and workflows takes time. Like any skill, you need to familiarize yourself with new tools, and AI is no different. What sets AI apart is that there's no clear playbook for using it effectively. While there are best practices for prompting and guidelines about AI's strengths and limitations, you need to discover what works for you. AI isn't just another programming language or company tool—it's a completely new way of working, and we're all beginners in this revolution. Finding what works best requires experimentation, with both successes and failures along the way. You'll be amazed by AI's capabilities in some moments and puzzled by its limitations in others. Ethan Mollick calls this the "jagged frontier"—an invisible border between what works and what doesn't. This frontier varies not only by domain but also by individual, as everyone has unique needs and contexts.

To foster AI adoption, give your team time and space to experiment. No one fully understands what this technology can do when starting out, and unlike programming languages, there's no structured learning path. Spark curiosity in your team, remove friction (e.g., by providing company licenses for ChatGPT), and keep the conversation going. Once your team starts experimenting, you're halfway there.

Set expectations

While generative AI is rapidly evolving with each new model release, setting realistic expectations has been key to successful adoption in our team. Even as capabilities grow, understanding AI's limitations is just as important as exploring its potential.

To create an AI-friendly environment, we first ensured everyone understood the basics: how large language models work, their common pitfalls, and fundamental prompting techniques. When my team grasped how LLMs work, they better understood both the impressive capabilities and occasional bizarre responses. This knowledge transformed AI from either a magical solution or an unreliable gimmick into what it truly is: a powerful but imperfect collaborative tool.

Understanding these fundamentals makes teams more resilient in their AI journey. Rather than giving up when hitting limitations, people learn to find creative workarounds. They start viewing prompting as a skill to develop rather than a fixed rulebook to follow. Setting these expectations early creates an environment where both success and failure become valuable learning experiences, helping to make AI adoption an exciting journey of discovery.

Practical Strategies That Work

Low entry points

A common mistake when starting with generative AI tools is thinking too big. It's natural—everywhere you hear about how AI is changing work and replacing jobs. In practice, the use cases are often more mundane. Start small. Don't try to run right away; take baby steps. Familiarize yourself with the technology before attempting to revolutionize your workflow.

My team initially tried using AI tools to generate SQL queries, thinking it was the obvious use case. Since ChatGPT excels at writing SQL, we assumed applying this to our data warehouse would be straightforward. It turns out Text-to-SQL remains challenging, and our simple attempts fell short. While I don't regret trying this approach, focusing on smaller, achievable tasks is more productive. Encourage your team to use AI tools to review existing queries, explain query logic, or structure new queries. As mentioned earlier, ensure everyone has reasonable expectations. When talking to colleagues and friends, these use cases are good entry points for beginners:

• Assisting with communication: summarizing emails, refine tone of emails.

• Instead of googling a question that would inevitably lead to Stack Overflow, ask ChatGPT about the problem.

• Ask ChatGPT questions about a PDF.

Build Momentum Through Champions

The AI space evolves at a dizzying pace, with new tools and capabilities emerging weekly. As a manager, part of my role is curating these developments and identifying which ones could genuinely benefit the team. But introducing new tools effectively requires more than just announcing their availability—it needs champions who can demonstrate their real-world value.

A powerful example of this dynamic played out recently when we introduced Cursor, a new AI code editor, to our team. While many developers had grown skeptical of AI coding assistants after mixed experiences with GitHub Copilot, one of our data engineers saw Cursor's potential immediately. He began using it in his daily work, showing others how it significantly improved his workflow during code reviews and pair programming sessions. His authentic enthusiasm and practical demonstrations did more for adoption than any formal introduction could have achieved.

This pattern of champions naturally emerging to drive adoption has become a cornerstone of our AI integration strategy. For instance, one of our data analysts became our unofficial "ChatGPT whisperer" after extensively using it for stakeholder communication. He showed the team how to draft polished responses, streamline reports, and even review SQL queries. These weren't just demos—they were real work problems being solved more efficiently. His success sparked discussions about query efficiency and inspired others to experiment with similar techniques.

The key is recognizing that new technology adoption and champions form a virtuous cycle:

• Champions help evaluate and validate new tools in real-world scenarios

• Their successes make adoption feel more achievable for others

• This creates space to introduce more advanced tools

• Which in turn empowers champions to push boundaries further

As a manager, your role is to identify these champions early and support them. When you spot a promising new tool or technology, share it first with team members who have shown enthusiasm for AI experimentation. Their practical experience and peer influence will help determine if and how to roll it out more broadly.

Remember: while countless new AI tools emerge daily, the goal isn't to adopt everything. Be selective and let your champions help guide which tools truly add value to your team's specific needs and workflows. Their ground-level perspective is invaluable in cutting through the hype and identifying practical applications that stick.

Managing The Human Side

As with any change, some individuals will embrace working with AI while others will be more reserved. To drive adoption, it's crucial to ensure everyone is aligned and ready to embark on this journey. When introducing AI tools, these approaches helped me tremendously:

Hands-on Workshops & Knowledge Sharing

One effective way to spark curiosity is through hands-on workshops. These sessions provide a safe space for team members to share their experiments with AI tools. They can showcase their successes and discuss their failures. Both are invaluable lessons. Sometimes a failure can even be corrected (e.g., by improving the prompt), which in turn sparks interest in mastering these technologies.

An important aspect of these workshops is that they shouldn't be lectures. Nobody learns by being told how to do things. Make it hands-on, interactive, and collaborative. These workshops should feel more like kindergarten than university.

Once your team embraces the change, encourage them to share their experiences so others can learn. While finding the right way to use AI is personal, the lessons learned are valuable for everyone.

Success Stories

One way to boost AI tool adoption is through friendly competition. In my team, we held a mascot competition where everyone could contribute suggestions for our team mascot—with one condition: it had to be AI-generated. Though image generation isn't typically relevant for data teams, it encouraged participants to think about AI interaction and playfully improve their prompting skills while learning about GenAI's quirks (e.g., six-finger hands, made-up text in images).

The winner received a book, and we used the mascot as a logo everywhere possible: our stakeholder Teams chat icon, JIRA board, and PowerBI workspace. It even made its way onto T-shirts we gifted to departing colleagues.

Conclusion

The journey to AI adoption in your data team doesn't have to be overwhelming. By creating the right environment, starting small, and empowering champions, you can transform AI from a buzzword into a practical tool that genuinely enhances your team's capabilities. Remember that success isn't measured by how many AI tools you adopt, but by how effectively they solve real problems and improve your team's work.

The key is to maintain balance: embrace the technology's potential while acknowledging its limitations, encourage experimentation while setting realistic expectations, and most importantly, keep the focus on your team's growth and development. As you move forward, celebrate the small wins, learn from the setbacks, and keep fostering an environment where AI adoption can grow organically.

Your role as a leader isn't to force AI adoption, but to nurture an environment where it can flourish naturally. By following these principles, you'll find that your team doesn't just adapt to AI—they thrive with it.

This issue explores three key developments that are reshaping marketing and analytics: reasoning models that enhance problem-solving capabilities, true multimodality that transforms how we interact with AI, and autonomous AI agents that are revolutionizing workflow automation. Let's examine how these innovations will impact our work in 2025.

Reasoning models

OpenAI kicked off their 12 days with the release of their new flagship models o1 and o1-pro. While ChatGPT Plus users had access to an o1-preview, the final o1 model delivers significantly better performance and faster responses. The o1 model family represents a new class of "reasoning models"—the next evolution in LLMs. Unlike previous models that simply used context from prompts and attached documents to craft responses, reasoning models add a chain-of-thought step. This allows them to reason step-by-step and break down complex problems into smaller parts. Through reinforcement learning, o1 can identify and correct its own mistakes while exploring alternative approaches when needed. Alongside o1, OpenAI released o1-pro, available exclusively through a new ChatGPT Pro plan priced at $200 per month.

Google has also entered the arena with their newest model: Gemini 2.0 Flash. Though it's a smaller reasoning model and still experimental, it offers true multimodality (more on that later) and boasts an 8x larger context window (1M for 2.0 Flash vs 128K for o1), enabling comprehensive problem analysis. Given that Flash models have historically been Google's most limited offerings (similar to GPT's mini and turbo versions), the upcoming Pro models in the Gemini 2.0 family show tremendous promise.

Reasoning models have shown their most dramatic performance improvements in mathematics and coding, where problems have "correct" answers. For instance, o1 demonstrated this capability by instantly identifying a mathematical error in a controversial paper claiming black kitchen utensils release toxins during cooking. This rigorous analysis will be invaluable when reviewing assumptions and calculations to ensure decisions and conclusions rest on solid foundations. AI adds an extra layer of confidence, even in highly specialized domains.

Less is known yet about performance in open domains where solutions often depend on complex context and constraints—the kind of challenges faced daily in business settings. While we lack validated data on reasoning models' business performance improvements, I believe they'll be substantial. Though content creation may see just modest gains, fields like marketing analytics should experience significant advances. In my comparison of GPT-4o and o1 responses for designing an incrementality test, o1 demonstrated notably deeper understanding and detail compared to 4o's more generic—though not incorrect—response.

As we step into this new era of reasoning models, early experimentation is key to staying competitive. We'll see major advances in both the models and our understanding of their optimal use. I encourage you to run your own comparisons between reasoning and non-reasoning models—this practical experience will reveal where reasoning models excel (such as complex analysis) and where simpler models remain sufficient (like email drafting or text summarization). The earlier you begin exploring these capabilities, the better equipped you'll be to harness their full potential in your work.

Multimodality

Multimodality has been part of LLMs for some time now. Features like file uploads, image recognition, and voice output are available in both ChatGPT and Google's Gemini. However, these models never felt truly natural. While ChatGPT could generate images, it did so indirectly by creating prompts for DALL-E rather than generating images natively. Similarly, Voice Modes were available, but there's a significant difference between simply reading responses aloud and engaging in natural conversation.

The game-changer came with OpenAI's Advanced Voice Mode, which made ChatGPT interactions feel more natural and enabled features like humor and back-and-forth conversation. Now Advanced Voice Mode also supports video and screen sharing, expanding the AI's world model and allowing for more human-like interactions with ChatGPT.

Google raised the bar with their Multimodal Live API for Gemini 2.0. This allows you to share your video or screen while talking to Gemini simultaneously. The AI can now reason about any document, video, or code file open on your screen. Even in its early version, this feature transforms AI into a genuine pair programmer.

True multimodality brings a human touch to LLM interactions. It feels natural to politely interrupt the LLM during its reply for follow-ups or corrections. Advanced Voice Mode already offers compelling use cases, and with an expanded world model that can "see," the possibilities will only grow. Need to practice delivering difficult news to your team? An AI companion can provide feedback on clarity and help anticipate team members' questions. Preparing for an important presentation? Walk through your slide deck with AI tools that challenge you from different attendees' perspectives. The applications are virtually endless. While reasoning models expand what problems AI can solve, multimodality transforms how we interact with AI.

Agents

Since ChatGPT's release two years ago, developers have focused heavily on optimizing prompts and building AI workflows. This has enabled specialized use cases that connect multiple systems to create powerful automations. Tools like Make.com and Zapier have made these AI workflows accessible to non-technical users. However, while these workflows can be sophisticated, they remain static due to their rule-based structure.

We're now entering a new era where AI systems not only facilitate communication between systems but also make autonomous decisions and recommend optimal workflows. This "agentic AI" approach is embraced by all new LLM models, with reasoning models particularly excelling at planning and breaking down complex tasks. Imagine shopping for a new TV: you simply tell an AI agent your preferences and budget, and it finds suitable options, analyzes prices, and recommends the best choice at the best price. While we're not quite at one-click purchasing yet, many companies are developing these tools with promising early results. Anthropic's Claude, with its Computer Use feature, offers a preview of what's coming—actively browsing websites, comparing information, and compiling research like a human assistant. Though still in its early stages, this capability clearly signals where AI agents are headed in 2025.

For marketing and analytics professionals, agentic AI opens up remarkable possibilities. Imagine an AI that autonomously generates and tests marketing content for maximum engagement. It could create various ad copies, visuals, and calls-to-action for different audience segments, then conduct real-time A/B testing across platforms to identify the best performers. When it discovers that younger audiences engage more with humorous short-form videos while older audiences prefer detailed carousel ads, it automatically adjusts future content. This approach not only enhances campaign performance but also significantly reduces the time and resources spent on manual content creation and testing.

Conclusion

The pace of AI development shows no signs of slowing down as we move through 2025. While reasoning models, multimodality, and agentic AI represent major breakthroughs, they're just the latest wave in an ongoing revolution. Professionals in marketing and analytics who want to stay competitive must continuously adapt and learn, as each month brings new capabilities that can transform how we work with data and derive insights. While it's easy to feel overwhelmed by the pace of change, remember that the key to success lies in practical experimentation. Start small: test a reasoning model's ability to analyze complex problems by comparing its output with traditional LLMs, try using voice and screen sharing for your next dashboard review, or experiment with simple AI agents to automate routine analytics tasks. The goal isn't to revolutionize your entire workflow overnight but to gradually incorporate these tools where they add the most value to your analytics work. Stay curious and keep exploring. The tools we have today are just the beginning, and those who maintain an experimental mindset will be best positioned to leverage tomorrow's innovations. The future of AI-assisted analytics is not just about more powerful models—it's about more natural, intuitive, and productive ways of working together with AI.

In this article, I’ll share how I’ve integrated AI into my daily work as an analytics manager—beyond building dashboards and models—to streamline strategy, refine communications, energize teams, and support smarter hiring. My goal isn’t to replace your expertise, but to free up your time and mental bandwidth for the challenges that truly demand human insight.

These use cases aren’t theoretical. They reflect how I actually use AI tools like ChatGPT or Claude on a regular basis.

1. Strategic Planning & Prioritization

Turning Objectives into Meaningful OKRs

Drafting clear, measurable OKRs can feel daunting. You know where you want to go, but translating that vision into business-oriented metrics is tricky. AI tools can help move from project-driven objectives to outcome-driven ones that hold you and your team accountable.

Example:

Original Objective: “Improve marketing measurement”

Original Key Results:

• Finish MVP for measurement project

• Finalize strategy for automation project

• Roll-out data activation process

AI-Enhanced OKR:

Objective: Elevate the accuracy, coverage, and actionability of marketing data to inform strategic decision-making.

Key Results:

• Reduce data inconsistencies between ad platforms and CRM by 90%.

• Implement automated data workflows to cut manual reporting time by 30% and ensure data freshness within 24 hours.

• Integrate marketing data into at least three downstream platforms (CRM, attribution tool) to improve campaign optimization and closed-loop insights

By letting AI question your assumptions and push for specifics, you end up with OKRs that are both ambitious and truly measurable.

Prioritizing Projects by Impact

Prioritization often relies on intuition, but AI can bring a more rigorous approach. For example, when evaluating a lead scoring improvement project, I fed assumptions (e.g., conversion rates, marketing spend) into a reasoning model. It not only considered direct revenue gains but also suggested reinvesting the increased revenue back into marketing, amplifying the overall ROI. This logical, data-informed perspective made justifying the initiative much easier.

2. Stakeholder Communication

When announcing a new initiative or addressing a crisis, tailoring your message to different audiences is crucial. Technical teams, marketing peers, and executives each require their own angle.

My Method:

1. Draft a “brain dump” of all relevant details.

2. Prompt the AI to produce multiple versions of the communication:

   • A technical deep-dive for engineers

   • A business-focused impact summary for marketing

   • A concise executive overview for leadership

This approach saved me precious hours during a recent incident where 15% of leads were affected by a bug. Rather than fretting over every sentence, I let AI handle the first draft for each audience, and then I refined. It freed me to focus on resolving the issue rather than getting stuck in communication loops.

3. Team Management & Engagement

Leadership is about more than planning; it’s about keeping people engaged. In a remote environment, where casual interactions are limited, creative team activities and authentic connection matter.

One way for AI is to help you get fresh ideas for retrospectives. Instead of relying on the same old formats, I ask AI for a list of 20 or 50 ideas for retrospectives or icebreakers. Not every suggestion shines, but by refining prompts or asking the AI to critique its own ideas, I uncover genuinely fun activities. This led me to a “Wheel of Fortune”-style icebreaker that sparked laughter and better camaraderie.

Beyond giving you ideas for retros, AI can suggest other ways to nurture culture:

• Team Event Brainstorming: AI proposes formats that work well for virtual or in-person gatherings.

• Discussion Starters: Prompts that encourage asynchronous chats on professional and personal topics.

• Cultural Rituals: Ideas like virtual coffee breaks or themed show-and-tells to maintain a sense of connection.

These subtle shifts help keep morale high and build resilience for tougher times ahead.

4. Smarter Recruitment

Hiring data people takes time. Crafting job descriptions, business cases, and interview questions can feel repetitive.

How AI Helps:

• Job Descriptions: Generate an initial draft tailored to your requirements, then refine.

• Interview Questions: Maintain a standard bank and have AI suggest fresh angles to test problem-solving skills.

• Business Cases and Assessments: Create synthetic datasets that mimic real scenarios without exposing sensitive data.

The result? A more efficient hiring process that still feels thorough and personalized.

Looking Ahead

As AI tools continue to evolve, their potential for supporting managers will only grow. The key is striking the right balance: delegate first drafts, idea generation, and basic analysis to AI, while you contribute the context, judgment, and leadership that only human experience can provide.

We’re still at the early stages of reasoning models and agentic AI. As these technologies mature, they’re poised to fundamentally reshape managerial work. To stay ahead, begin exploring their capabilities now. By integrating these tools into your workflow, you can streamline the routine aspects of your role and focus on the tasks where your expertise, creativity, and empathy make all the difference.

By offloading administrative chores and tapping into AI’s knack for generating ideas, you’re not merely saving time—you’re enhancing the quality of your strategic decisions, communications, and team interactions.

What about you? Have you tried using AI in your management tasks? I’d love to hear what’s worked, what hasn’t, and how you envision these tools shaping the future of analytics leadership.

"Should these KPIs be on the same dashboard?"

"Am I writing this query most efficiently?"

Every data professional faces these questions. While traditional peer reviews are valuable, they're not always feasible – especially for solo analysts or small teams. But what if you could have an always-available analytics coach, ready to review your work at any time?

In my previous article, I explored how AI can accelerate analytics prototyping. Now, let's flip the perspective: instead of using AI to create, let's leverage it as a critical thinking partner to review and improve our existing work. The best part? It's straightforward. You don't need perfect prompts – typically just a few lines explaining your goal, some basic instructions, and your input are enough to get valuable feedback. Let me show you how.

Understanding AI's Role: The Jagged Frontier

Before diving into specific applications, it's important to understand AI's capabilities in analytics and in general. As Ethan Mollick notes, AI's effectiveness follows a "Jagged Frontier" - an uneven line between success and failure. While AI might excel at reviewing SQL queries, it will struggle with generating SQL based on text input.

The key is experimentation. Start with straightforward tasks like code review or design feedback, then gradually explore more complex scenarios. This approach helps you discover where AI can be a reliable partner versus where human expertise remains essential.

Best Practices for AI-Assisted Reviews

1. Provide Context: Don't just share the work—explain your goals, constraints, and audience. The more context you provide, the more relevant the feedback. Especially for more sophisticated tasks it is crucial to be detailed in the context and what you tried so far. Also, tell the AI what you want it to do and what you expect. Don't just say "review this SQL query", tell it "I need you to review this SQL query that I am running on BigQuery, please put an emphasis on readability and performance".

2. Ask Specific Questions: Instead of "What do you think?", ask targeted questions like "How could I make this more actionable for marketing managers?" As is the case with context, AI cannot read your mind and while some vague questions might lead to good results, typically you will fare better and get more profound responses when you are specific. Think of AI as an intern, who is smart and eager to help, but does not know how your business works or what your concrete expectations are.

3. Iterate Through Feedback: Use AI feedback as a starting point for improvement, then show the revised version for another round of review. Tell the AI to challenge you and act as a certain person. For a SQL query this could be a senior analyst, for a geo experiment it could be a statistician. You can also ask for feedback from different angles by asking to review your work from the position of a statistician, market researcher and brand manager.

4. Maintain Critical Thinking: Remember that AI is a thought partner, not an infallible authority. Always evaluate suggestions against your domain knowledge and requirements. When you see that an AI starts to hallucinate, it might be a good idea to try to start over the conversation in a new chat or to take a step back in what you are trying to get out of it.

Three Ways to Use AI as Your Analytics Coach

1. Dashboard Design Reviews

Upload a screenshot of your dashboard, and ask the AI to critique its design, information hierarchy, and effectiveness. For example, when I recently showed ChatGPT a marketing performance dashboard, it pointed out:

• Problems in the color palette: "The overall color palette is very neutral, which reduces clarity and makes it harder to differentiate between metrics and categories. Use contrasting colors for key metrics and category headers and consider using softer grid lines or removing them entirely for a cleaner design."

• Design issues: "The filter section takes up significant space, leaving less room for the data tables. Consolidate filters into a collapsible pane or sidebar to save space and ensure filter names are user-friendly."

• Confusing KPIs: "Some metrics are not self-explanatory. Add a legend, glossary, or hover-over explanations for ambiguous terms."

The prompt defines the role the AI should take, its task and gives instructions what to focus on:

You are a senior data analyst with 10+ years of experience in marketing reporting with Power BI. I will send you screenshots of reports and want to get your honest assessment of the report. Focus on things like intuitiveness, completeness, clarity, overall look & feel. Also take into account if there are confusing elements, could the visual hierarchy be improved, what best practices are missing?

Simply drag&drop your screenshot in the chat and you get your evaluation.

2. SQL Query Optimization

Instead of just using AI to generate SQL, use it to review your existing queries. While AI is still not great at translating text to SQL, it is great in understanding queries you already have available and make suggestions on how to improve it or identify errors.

Finding Basic Issues

Getting good feedback from AI is easy. This is the prompt I used for reviewing queries:

You are a senior data analyst and a true expert in writing and improving SQL queries. Your job is to review queries I am going to send you and check for any mistakes, bad practices or typos in them and suggest improvements so that I can use the best query possible for my task.

Let’s start with a simple example:

select

  user_id,

  count(*) as num_orders,

  sum(num_prodcuts) as sum_products,

  sum(revenue) as sum_revenue

from orders

where sum(revenue) > 500

group by user_id;

You see any issues with that? While you probably spotted the aggregation function in the where clause, did you spot the typo? ChatGPT did:

1. SUM(revenue) in the WHERE clause: You cannot use aggregate functions like SUM() directly in the WHERE clause. Aggregates are calculated after the filtering stage. Instead, you should use the HAVING clause for conditions on aggregates.

2. num_prodcuts typo: The column num_prodcuts appears to be a typo. It should likely be num_products (assuming this is the intended column name).

3. Inefficient grouping: There is no technical issue with the GROUP BY, but you may want to ensure you’re grouping correctly based on your requirements.

Transforming Complex Queries

While catching typos is useful, AI really shines with complex queries: I asked it to review a highly complex query with nested subqueries that is a real challenge to read as a human:

SELECT CustomerName

FROM Customers

WHERE CustomerID IN (

    SELECT CustomerID

    FROM Orders

    WHERE TotalAmount > (

        SELECT AVG(TotalAmount)

        FROM Orders o2

        WHERE o2.CustomerID IN (

            SELECT CustomerID

            FROM Customers c2

            WHERE c2.Region = (

                SELECT Region

                FROM Customers c3

                WHERE c3.CustomerID = c2.CustomerID

            )

            AND EXISTS (

                SELECT 1

                FROM Orders o3

                WHERE o3.CustomerID = c2.CustomerID

                AND o3.TotalAmount = (

                    SELECT MAX(TotalAmount)

                    FROM Orders o4

                    WHERE o4.CustomerID = o3.CustomerID

                )

            )

        )

    )

    AND OrderID IN (

        SELECT OrderID

        FROM OrderDetails

        WHERE ProductID IN (

            SELECT ProductID

            FROM Products

            WHERE Category = 'Electronics'

            AND ProductName LIKE '%Pro%'

            AND LENGTH(ProductName) > (

                SELECT AVG(LENGTH(ProductName))

                FROM Products p2

                WHERE p2.Category = Products.Category

            )

        )

    )

);

Good luck making sense of this! Gladly, ChatGPT took over the tedious task of identifying the myriad of problems with the original query and rewrote it in a concise and readable way:

-- CTE for average product name length in the 'Electronics' category

WITH AvgProductNameLength AS (

    SELECT 

        Category,

        AVG(LENGTH(ProductName)) AS AvgNameLength

    FROM Products

    WHERE Category = 'Electronics'

    GROUP BY Category

),

-- CTE for high-value orders by customers in the same region

HighValueOrders AS (

    SELECT 

        o.CustomerID,

        o.TotalAmount,

        MAX(o.TotalAmount) OVER (PARTITION BY o.CustomerID) AS MaxTotalAmount

    FROM Orders o

    WHERE o.TotalAmount > (SELECT AVG(TotalAmount) FROM Orders)

),

-- CTE for products meeting the criteria

FilteredProducts AS (

    SELECT 

        ProductID

    FROM Products p

    WHERE p.Category = 'Electronics'

      AND p.ProductName LIKE '%Pro%'

      AND LENGTH(p.ProductName) > (

          SELECT AvgNameLength

          FROM AvgProductNameLength

      )

)

-- Main query

SELECT DISTINCT 

    c.CustomerName

FROM Customers c

JOIN Orders o ON c.CustomerID = o.CustomerID

WHERE o.TotalAmount IN (

    SELECT TotalAmount

    FROM HighValueOrders

    WHERE CustomerID = c.CustomerID

      AND TotalAmount = MaxTotalAmount

)

AND o.OrderID IN (

    SELECT OrderID

    FROM OrderDetails od

    WHERE od.ProductID IN (

        SELECT ProductID

        FROM FilteredProducts

    )

);

Key Takeaways:

• AI excels at identifying both syntax issues (typos) and structural problems (aggregation misuse)

• For complex queries, AI can suggest modern SQL patterns like CTEs to improve readability

• AI helps decompose nested subqueries into logical building blocks

• Reviews can reveal performance optimization opportunities while maintaining query intent

3. Stakeholder Communication Review

One aspect of GenAI usage that curiously gets overlooked is communication review. While many use AI to draft emails, fewer leverage it to analyze and improve their stakeholder interactions.

Let me share a recent example: One of my team members was struggling with a challenging stakeholder situation. He asked ChatGPT to review their email exchange and suggest improvements. While the overall communication was professional, the AI identified key areas for improvement:

• Not enough emphasis on alternative solutions

• Technical explanations needed more context

• Missed opportunities to align on project goals early

The prompt used was simple but effective:

You are an experienced data analyst with excellent communication skills. Your task is to help me with my stakeholder communication. I will send you an example and want to get your candid feedback.

Use this approach to:

• Resolve sticky situations when dealing with stakeholders

• Identify blind spots in your communication style

• Get ideas for streamlining processes while keeping all parties engaged

• Improve how you present technical concepts to non-technical audiences

Key Takeaways:

• AI can spot communication patterns you might miss

• Regular reviews help develop better stakeholder management skills

• Getting an objective perspective helps prevent miscommunication

• Use feedback to build templates for similar situations

Conclusion

Ready to leverage AI for better analytics? Start with these steps:

1. Pick a recent dashboard or query for review

2. Frame your request using the prompts provided

3. Implement AI's suggestions iteratively

4. Document which types of reviews yield the most value

Key to success: Treat AI as a thought partner, not a replacement for human expertise. Use it to catch issues early, validate approaches, and strengthen your analysis before stakeholder review.

What review tasks will you try first? Share your experiences and effective uses of AI in analytics QA in the comments below.

Leave a comment

But that perception is shifting thanks to the AI's ability to write code on their own to interact with data. The latest tools are starting to develop capabilities to make them useful for data analysis, opening new doors for innovation. One such tool is Claude with its Artifacts feature, which brings generative AI capabilities into the realm of visualization and exploratory data analysis. By simplifying the creation of custom visualizations and solving niche problems, tools like this hint at the broader potential of AI in analytics.

In this post, we’ll explore how Claude Artifacts fit into this evolving landscape, showcase practical use cases, and discuss its limitations.

What Are Claude Artifacts?

While I used Claude rather extensively, I figure there is an ultimate authority on this topic. So here is Claude itself explaining what Artifacts are:

Claude Artifacts are interactive components that transform data and ideas into polished outputs - from visualizations and code to documents and diagrams. They're unique because they're created and modified through natural conversation, with no setup required beyond your browser. Whether analyzing data, prototyping visualizations, or building interactive tools, Artifacts serve as a collaborative workspace where ideas can be quickly tested and refined.

How Claude Artifacts Simplify Data Visualization

Claude Artifacts eliminate the traditional barriers to creating visualizations. Analysts can upload a CSV file, a PDF, or a screenshot, and prompt the AI to generate visualizations within seconds. The process is intuitive, requiring no additional setup or coding - everything is happening in the same browser tab (or mobile app). Whether you’re visualizing a single metric or exploring a statistical concept, Claude delivers interactive visuals in a matter of seconds, making it a powerful ally for quick data exploration and communication.

Instead of spending hours coding in Python or configuring dashboards in Power BI, analysts can use Claude Artifacts to create proof-of-concept visualizations and evaluate ideas quickly.

Real-World Scenarios for Claude Artifacts

How can Artifacts help you in your day job in analytics? Here are three real-world use cases that give you an impression of why Claude can be a game-changer.

Scenario 1: Create proof-of-concept for new visuals

Every so often, you have a new idea for a dashboard visual and want to test its utility before committing time to implementation. Claude makes this process effortless. For instance, if you want to plot a cohort retention matrix, you can simply ask, “Can you create a sample visualization for cohort analysis?” and receive a useful example:

While you could achieve the same result using tools like Power BI or Tableau, the process often involves significant setup; preparing the data in your data warehouse, loading it into Power BI, and creating the visual. In many cases, it’s more about communicating the concept than having it fully built out. This is where Claude shines—providing a rapid and effective way to share and refine ideas.

Scenario 2: Quick A/B test evaluation

You’ve just wrapped up an A/B test and need actionable insights immediately. With Claude, you can input the key metrics from your test, and the AI will generate an Artifact summarizing the results in an accessible format.

For example, imagine you’re comparing conversion rates across two groups and want to highlight statistical significance. By inputting the data into Claude, you get clear visualizations illustrating performance differences and the overall impact of your test:

Beyond just speed, the flexibility to iterate on the output—by adding notes or tweaking the visual style—makes Claude an invaluable tool for turning raw test results into actionable presentations. Let's say, you are not a fan of frequentist significance testing, no problem, just ask Claude to switch to a Bayesian approach.

Scenario 3: Draw flow chart diagrams

When introducing new features or integrating data sources, understanding how systems interact is essential. A clear diagram can ensure alignment among all stakeholders. Claude can help here, too. By asking, “Can you create a quick diagram of how a customer data platform (CDP) integrates with BigQuery, Salesforce, Google Analytics, and ad platforms like Google Ads and Meta?” you’ll receive a visual representation in the easy-to-use and easy to customize Mermaid format.

While the output might need refinement, starting with a ready-made draft saves time and facilitates collaboration, especially given Mermaid’s extensibility for further customization.

You’ll notice that working with Claude often requires minimal prompting. Simply state what you need, and the AI delivers results without requiring extensive context or detailed instructions—a level of simplicity that stands out in a busy work environment.

Understanding What Claude Artifacts Can and Cannot Do

While Claude Artifacts are a powerful tool, it’s essential to recognize their limitations:

• Not a Replacement for Advanced Visualization Tools: Claude Artifacts are best suited for small-scale, one-off visualizations. They don’t replace tools like PowerBI or Tableau, which support automated data refreshes and production-level dashboards. In my experience, they work best when the alternative is to dump the data into Excel or Google Sheets for quick transformation.

• No Automation: Every visualization requires manual input of data via a file or screenshot. There’s no functionality for automatic data updates or integrations, making it less suitable for recurring reports.

• Potential for AI Errors: As with any generative AI, the code and insights produced by Claude may contain errors or hallucinations. For complex datasets or advanced statistical methods, it’s crucial to double-check outputs and rely on specialized tools when necessary. When the AI-generated code gets too complex, it can be easier to write the whole thing from scratch instead of error-checking the generated code (especially since Claude generates all code in Javascript).

• Sweet Spot for Use: Claude Artifacts excel in scenarios where speed and simplicity are prioritized over depth and automation. They’re ideal for rapid prototyping, proof-of-concept visualizations, and exploratory analysis.

Why Claude Artifacts Are a Game-Changer

Despite their limitations, Claude Artifacts changed how analysts interact with data. By integrating data visualization directly into an AI-driven workflow, the tool allows analysts to focus on insights rather than technical execution. It’s an invaluable playground for exploring ideas and quickly generating compelling visuals that aid decision-making.

And if you look outside of analytics the use cases are endless. You can create fully functional games right within the browser, you can generate React apps that run in the browser and can simply be copied to run on their own, acting as an interactive playground. Visually summarizing shareholder reports, building soundboards, ... the options are endless.