When Your Personal AI Consultant Helps You Think Bigger: From a crazy Water Bill to a Learning Opportunity

The Unexpected Benefit of Having a Personal AI System

In my previous post about building a Personal Consultant AI System, I described the architecture and philosophy behind creating a multi-agent AI infrastructure for managing various aspects of my life. What I didn't fully anticipate was how having this system in place would fundamentally change how I approach problems.

Once you have a capable AI assistant that understands your context, goals, and preferences, you start seeing opportunities everywhere. Problems that would previously sit on a to-do list gathering dust suddenly become tractable. And more importantly, you start thinking bigger about what's possible.

My latest attempt to solve a problem became a little more than a simple investigation.

Confession: I'm Terrible at Administrative Follow-Up

Being complertely honest I'm notoriously bad at following up on administrative household tasks (a fact not lost on other unamed members of our household). You know the type—letters that arrive, require some investigation, and then sit in a pile because "I'll get to it later."

In late November 2025, one such letter arrived from Thames Water. My new payment plan: £173 per month. Total amount due: £1,125.49. The usage graph showed my daily water consumption had jumped from 514 litres to 872 litres per day—a 70% increase.

I cam home to find some choice letters scrawled across the bill in red marker: "WTF?!" (again the culprit for this shall remain nameless)

In the past, this letter would have joined The Pile. I'd have worried about it occasionally, maybe called Thames Water once to complain, gotten frustrated, and eventually just paid it while grumbling.

But this time was different. I had my Personal Consultant.

The Quick Fix vs. Thinking Bigger

Here's where I need to share something about how I approach problems when AI is involved.

I could have simply asked my AI assistant: "Help me investigate this water bill. Pull data from Thames Water, analyse it, and tell me what's going on." It would have done exactly that—logged into the website, extracted some data, identified patterns, and given me an answer. Problem solved in an afternoon.

But I've always had a tendency to think bigger. Not because it's always practical, but because I genuinely enjoy building things. The question isn't just "can I solve this problem?" but "what could I build that would solve this problem and provide ongoing value?"

The difference now is that AI gives me the superpowers to actually fulfill these grander ambitions.

Previously, building a full monitoring system with automated data collection, REST API, visual dashboard, cost tracking, and email alerts would have been a multi-week side project requiring significant time investment. The gap between "good idea" and "working system" was too large for most ideas to survive.

With my Personal Consultant, that gap has shrunk dramatically. Suddenly, "thinking bigger" becomes practical rather than aspirational.

So instead of a quick investigation, I envisioned:

Automated daily data collection from Thames Water
REST API for programmatic access
Visual dashboard accessible from anywhere
Spike alerts when usage exceeds thresholds
Cost tracking using actual Thames Water rates
Data verification to ensure accuracy

And crucially, I wanted to understand what we built—not just use it.

Keeping the Robots Out of the Gym

Around this time, I read an article by the brilliant Daniel Miessler called "Keep the Robots Out of the Gym". It crystallised something I'd been thinking about but hadn't articulated clearly.

He distinguishes between two types of work:

"Job" tasks — where the output matters most. Delegating these to AI is appropriate because you just need the result.

"Gym" tasks — activities centred on skill development and personal growth. Delegating these undermines the entire point.

The insight that struck me: as AI improves, we risk outsourcing our most essential mental capacities. We might achieve more while learning less.

This project was clearly in the "Gym" category for me. Yes, I wanted the dashboard and the alerts. But I also wanted to learn how to build a production-grade data pipeline, understand web scraping with Selenium, work with FastAPI, and deploy services on my home server.

The question became: how do I leverage AI's superpowers while ensuring I'm still the one doing the mental reps?

Building the Thames Water Monitoring Service

The Collaboration Model

Rather than having AI generate code while I watched, it was a collaborative effort. I would describe what I wanted, AI would explain the approach, I would ask questions, and we'd iterate. When something didn't work, I didn't just ask "fix it"—I asked "why didn't that work?" and "teach me what went wrong."

The technical implementation emerged:

FastAPI for the REST API
Selenium with headless Chrome for web scraping (unfortunately Thames Water does not havean official API)
SQLite for data storage
APScheduler for automated daily collection
Chart.js for dashboard visualisations
Docker for deployment on my Raspberry Pi 5 home server

The Scraper Challenge

Thames Water's website isn't designed for automation. We needed to navigate JavaScript-heavy pages, handle quirky date formats (DD-MM-YYYY), and capture data from network responses. Each challenge became a learning opportunity.

I now understand Chrome DevTools Protocol for network log capture. I understand why Selenium's explicit waits are preferable to arbitrary sleeps. I understand the difference between extracting data from the DOM versus intercepting API responses.

The Dashboard

The result: a dashboard at water.gavinslater.co.uk showing usage cards, cost calculations (based on actual December 2025 Thames Water rates), and interactive charts for daily, hourly, and monthly views.

The Tutorial: Where Learning Becomes Explicit

Here's where "keeping robots out of the gym" became concrete.

After the system was working, I asked my AI assistant to create a comprehensive tutorial walking through every aspect of the codebase. Not documentation for future developers, a learning resource for me.

The result was a detailed tutorial covering:

The Big Picture — what the system does and why
Architecture Overview — how the pieces fit together
How the Application Starts — FastAPI lifecycle and initialization
Configuration — Pydantic settings and environment variables
Data Models — Pydantic schemas and type safety
The Database Layer — async SQLite patterns
The Scraper — Selenium automation and network capture
Scheduled Jobs — APScheduler configuration
The API — FastAPI endpoints and schemas
The Dashboard — Chart.js integration and styling
Putting It All Together — Docker deployment and verification

Each lesson includes the actual code, explanations of why decisions were made, and the reasoning behind the patterns used.

This tutorial represents the "gym" component of the project. The AI helped build the system (job task), but the tutorial ensures I understand it deeply (gym task). I can now maintain, extend, and debug this system because I've internalised how it works.

The Revelation: Finding the Gardener

Oh, and the original mystery? With weeks of hourly data now available, the pattern was clear:

Bi-weekly spikes of 800-1000+ litres, always during daytime hours (10am-4pm), occurring like clockwork.

The culprit: our gardener, who comes fortnightly and uses significant water for plants, patios, and general garden maintenance.

The 70% increase wasn't a leak or faulty meter—it was legitimate garden watering we'd authorised but hadn't realised was so water-intensive.

Mystery solved. Bill explained. No fraud, no error—just better visibility into our own consumption. But the other great thing about getting your AI to do some of the heavly lifting is that their research is pretty thorough (a lot more than mine would be)...one small insight also revealed that part of the charge is for waste water drainage and since this water had gone into the garden rather than the drainage system I am entitled to claim back some of the charges. A nice bonus!

What I Really Learned

1. AI Superpowers Enable "Thinking Bigger"

The gap between ambition and implementation has shrunk. Ideas that would have remained on the "someday maybe" list now become weekend projects. This changes how you approach problems—you start looking for opportunities to build lasting solutions rather than quick fixes.

2. Intentionality About Learning Matters

Without deliberate effort, it's easy to let AI do all the thinking. The tutorial approach—having AI teach me what we built after building it—creates a forcing function for genuine understanding. I now apply this to other projects: build first, then insist on understanding.

3. Personal Data is Valuable When Liberated

Thames Water has been collecting my hourly water usage since 2024. Until I built a tool to extract it, that data was locked away. The same is true for many services. AI makes building these "data liberation" tools far more accessible. Even without an official API the data extraction can be done!

4. Home Servers are Underrated

My Raspberry Pi 5 now runs water monitoring, health data aggregation, location tracking, and various other personal automations. Total cost: ~£80. It's always on, completely under my control, and growing more useful with each new service.

The Ongoing Investigation

As a postscript: while finalising this post, I noticed the service wasn't capturing data for certain dates. Investigation revealed that Thames Water's data publication schedule is inconsistent—weekends seem to have longer delays.

Rather than just fixing it and moving on, I've set up a temporary hourly monitoring regime to understand their update patterns. In a week, I'll have data showing exactly when Thames Water publishes new readings.

This is what happens when you have infrastructure in place: problems become experiments, and experiments generate insights.

Conclusion

This project started with a crazy water bill and a tendency to procrastinate on admin tasks. It could have ended with a quick investigation and a shrug.

Instead, because I had a Personal Consultant system in place, and because I've learned to "think bigger" knowing AI can help me execute, it became:

A fully automated monitoring service
A learning opportunity in production Python development
A case study in balancing AI leverage with personal growth
An ongoing infrastructure investment that will pay dividends for years

The question isn't just "what can AI do for you?" It's "what can you become capable of with AI as your co-conspirator?"

And crucially: are you using AI to avoid the gym, or are you bringing it along as a training partner?

The Thames Water Monitoring Service is running at water.gavinslater.co.uk. Built with FastAPI, Selenium, Chart.js, and deployed on a Raspberry Pi 5 home server.

Interested in trying it yourself? The complete codebase, including the tutorial, is available on my GitHub: github.com/gavraq/thames-water-service

This is Part 2 of my Personal AI Infrastructure series. Read Part 1: Building a Personal Consultant AI System for the architectural foundation.

Questions or feedback? Connect with me on LinkedIn or follow my journey transitioning from risk management leadership to AI engineering.