I Built a Complete Data Analysis Agent Suite in One Evening (Without Writing Code)

Five specialized agents. 627 tests. One evening. Zero lines of code written by me.

The secret wasn’t coding skill. It was a 713-line specification document I built with another AI agent two days earlier.

I’ve wanted to automate my entire data analysis workflow for years. Friday night, I finally did it.

---

The Problem I’ve Been Circling for Years

Every data analyst knows this workflow:

1. Get messy data (duplicates, missing values, inconsistent formats)

2. Clean it manually

3. Run exploratory analysis

4. Build visualizations

5. Write up findings

6. Summarize for executives who won’t read the full report

Each step is tedious. Each step is repetitive. Each step follows patterns I’ve executed hundreds of times across 30 years as a data analyst.

I’ve wanted to automate this forever. But “automate” always meant “learn to code properly” or “hire a developer” or “wait for someone to build exactly what I need.”

None of those happened.

Then I started using Claude Code seriously over the past few months. And I realized: I don’t need to code this. I need to specify this.

---

The Spec-First Breakthrough

Here’s what changed my approach: I used an AI agent to help me plan an AI agent suite.

I found a simple “app idea generator” agent online, basically a conversational tool that asks questions to flesh out project ideas. I pointed it at my vague notion of “automated data analysis” and let it interrogate me.

What’s the actual problem? Who’s the user? What are the discrete steps? What inputs and outputs for each stage? How should they connect?

One evening of conversation later, I had a 713-line specification document. Not code. Not pseudocode. A detailed blueprint:

• Five specialized agents, each with clear responsibilities

• Input/output contracts between them

• A pipeline orchestrator to chain them together

• Test requirements for each component

I sat on the spec for two days. Not because I was nervous. Life. Work week. Bad timing.

Then Friday hit. Winter storm rolling in. Work week done. Weather-aided energy. I opened Claude Code and said: let’s build this.

---

Five Hours of Watching an AI Build Software

Here’s what the build actually looked like:

7:00 PM: Pointed Claude Code at the specification. “Build this.”

7:15 PM: First agent (@data-cleaner) taking shape. Claude Code running into errors, retrying, figuring things out. I’m watching, not intervening.

7:45 PM: Data cleaner complete. 74 tests passing. I didn’t write the tests. I didn’t debug the failures. I approved permissions when asked.

9:45 PM: Three more agents done. @data-analyzer (108 tests), @data-visualizer (78 tests), @report-writer (121 tests).

11:00 PM: Final agent (@exec-summarizer, 167 tests) and the pipeline orchestrator (79 tests) complete.

Total: ~5 hours. 627 tests. Six agents. One specification document.

The wildest part? I never felt the urge to jump in and “help.” I wasn’t debugging. I wasn’t fixing errors. Claude Code hit problems, tried different approaches, ran tests, fixed what failed. All autonomously.

I approved permissions maybe 20 times total. That was my contribution during the build phase.

---

What Actually Got Built

The suite works like this:

Individual agents for specific tasks:

• @data-cleaner: Handles duplicates, missing values, date normalization, outliers

• @data-analyzer: Runs statistical analysis, finds correlations, detects trends

• @data-visualizer: Generates interactive Plotly charts and dashboards

• @report-writer: Creates reports in technical, business, or executive styles

• @exec-summarizer: Distills everything into 1-2 page executive summaries

Pipeline orchestrator for end-to-end automation:

• @full-analysis: Runs all five agents in sequence, handles file passing between them

You can run the full pipeline on a messy CSV:

@full-analysis ./data/sales_q4.csv

Or use individual agents for specific tasks:

@data-cleaner ./data/raw_sales.csv
@data-visualizer ./output/raw_sales_cleaned.csv

The output is real: cleaned datasets, statistical analysis in JSON, interactive HTML dashboards, markdown reports, executive summaries.

---

The $35 Build

I had a cost tracker running during the build. Even though my Claude Max plan covers usage, the tracker estimated the entire project cost approximately $35 in API calls.

$35 to build a complete data analysis automation suite.

Context: I recently upgraded from Claude Pro ($20/month) to Claude Max ($100/month). Not because I needed it for this project. You can absolutely build this on Pro. But I was hitting usage limits within 30 minutes of starting work sessions, and the constant pauses were breaking my flow.

Max gives 5x the usage. I haven’t come close to hitting the limit yet, even with heavy Claude Code usage over the past few days.

Was the upgrade necessary? No. Did it remove friction that was slowing me down? Yes. Your mileage may vary.

---

What I Actually Learned

1. The spec document is the product.

The build took 5 hours. The specification took one evening of focused conversation with an AI planning tool. But that spec document was the hard work.

713 lines. Every agent defined. Every input/output specified. Every test requirement listed. When the spec is solid, the build is almost mechanical.

Claude Code has a built-in Plan mode for this. You can have a conversation about what you want, and it builds a plan before writing code. There’s an AskUserQuestionTool that lets it interrogate you about requirements. Use these. The upfront investment pays off massively.

2. Agentic coding means watching, not doing.

I genuinely watched Claude Code work. It hit errors. It retried. It ran tests. It fixed failures. I felt zero urge to intervene.

This is a mindset shift. Analysts are conditioned to debug manually. But when you have a solid spec and let the agent work autonomously, your job becomes reviewer, not implementer.

3. The “Code” in Claude Code is misleading people.

I’ve written about this before, but it bears repeating: Claude Code is arguably the most powerful tool for knowledge work, not coding alone.

I’m a data analyst. I haven’t written production code in years. I built a six-agent automation suite with 627 tests in one evening. The barrier isn’t coding skill. It’s willingness to specify clearly what you want.

4. This would have been impossible six months ago.

Not because Claude Code didn’t exist. Because I didn’t have the mental models for how to use it.

Dan Shipper’s course in November. Extensive practice over the holiday break. Building my Work OS system. Each project built confidence and revealed patterns. Six months ago, I wouldn’t have known where to start. Now I know: start with the specification.

---

The Time Math

Let’s be conservative about the value here.

A data analyst manually doing this workflow (cleaning messy data, running analysis, building visualizations, writing a report, creating an executive summary) might spend 8-10 hours on a moderately complex dataset.

This agent suite does it autonomously. You point it at a file and walk away.

Even if you spend an hour reviewing and tweaking the outputs, that’s 7-9 hours saved per analysis cycle.

If you run this workflow twice a month, that’s 14-18 hours back. Per month.

And because these are autonomous agents, they’re working while you do something else. The time isn’t saved. It’s parallelized.

---

Try It Yourself

The complete project is on GitHub: github.com/bronsonelliott/data-analysis-agent-suite

Everything’s there:

• The specification document (see how detailed planning enables autonomous building)

• All six agent definitions

• The Python utility modules

• Sample data to test with

• The full test suite

Fork it. Point it at your own messy data. See what happens.

---

The Skeptic’s Corner

“But I’m not a coder.”

Neither am I. Not anymore. I built this without writing a single line of code.

“$100/month is expensive.”

You don’t need the Max plan. Build on Pro. The limits will slow you down, but the capability is identical. I upgraded for workflow convenience, not capability.

“How do I know the outputs are good?”

You don’t, until you review them. These agents don’t replace analyst judgment. They replace analyst grunt work. You still need to verify the cleaned data makes sense, the statistics are interpreted correctly, the visualizations tell the right story.

The difference: you’re reviewing finished work, not doing the work yourself.

---

What’s Next

I haven’t used this on production work data yet. That’s next.

I’m also thinking about extensions: database connections, API data fetching, custom themes for branded reports. The foundation is solid enough to build on.

But mostly, I’m going to use it. Every time I have data to analyze, I’ll run it through the suite and see what happens. Document what works. Fix what doesn’t.

That’s the pattern now. Build tools that make the work easier. Use the tools. Iterate.

The specification document took one evening. The build took five hours. The agents work.

This is what Claude Code enables when you stop thinking of it as a “coding tool” and start thinking of it as a “specification executor.”

You don’t need to write code. You need to write requirements.

— Bronson