Two skills do the work: one runs the analysis, one builds the page. Here is how to run both yourself and sign them off.
Read this first. Both skills stop at a draft. You review the numbers and sign off before anything reaches a client. Nothing here posts itself.
The GA4 website report is two skills, not one. ga4-website-maa does the analysis. ga4-client-view turns that analysis into the client-facing page. You run them in that order, and you can do the whole thing on your own machine.
You don’t need to know how the analysis works inside to run it. You do need to review what it produces before it goes near a client. The skill does the pulling and the math. You do the judgment and the sign-off.
Here is the whole loop, start to finish:
Meet the two skills
The first skill, ga4-website-maa, is the analysis. It connects to a client’s GA4 property, pulls the data, and works out what counts as a lead for that business. It checks how much of the data it can trust, then writes the report. It’s read-only: it never changes anything in GA4, and every tracking fix it finds gets written as an action for a person.
The second skill, ga4-client-view, is the display layer. It takes the finished analysis and builds the client one-pager: the four KPI pills, the revenue strip when there is one, the two charts, the stoplight colors, the prepared-by name, and the “what to do next” list. It derives everything from the analysis and invents nothing. If a number isn’t in the report, it doesn’t show up on the page.
It’s the same discipline behind how we work: diagnose first, act second, and let a human check the read before the client sees it.
Get four things in place
Check these once and you’re set for every run after.
Claude with skills, on your machine. Either Cowork in the Claude desktop app or Claude Code in your terminal. That’s where the skills run.
The Google Analytics MCP. The analysis reads GA4 through it. The next section covers getting connected.
Access to the client’s GA4 property. You, or the account the connection runs under, need at least Viewer on the property. Getting that access clean is part of the tracking and conversion work that sits under everything else we do.
The two skills installed. Clone the repo and put the two skill folders where your Claude looks for skills. In Claude Code that’s your skills directory; in Cowork you add them as skills. The repo is Local-Service-Spotlight/ga4-reporting-skills, and both skills live under skills/ there. Copy ga4-website-maa and ga4-client-view across as a pair, because the second one expects the first one’s output.
If any of the four is missing, fix that first. None of the rest works without all four.
Connect to the Google Analytics MCP
The analysis reads GA4 through the Google Analytics MCP. There are two ways to get one connected, and most team members will want the second.
Set up your own. In Claude Code, add the Google Analytics MCP from your terminal:
claude mcp add ga4 -- npx -y @anthropic-ai/google-analytics-mcp
In Cowork, add the Google Analytics connector from the desktop app’s connector settings instead. Either way, it needs a Google Cloud project with the Google Analytics Data API turned on, and a Google account that has access to the property. The credentials step lives with Google, so follow their guide for it: Google’s Analytics MCP setup.
Use ours instead. We already run a shared Google Analytics MCP for the team, so you don’t have to stand up your own. This is the quicker path. To get connected to it, reach out to Daniel in Basecamp, and he’ll set you up.
Either way, two things have to be true before the MCP can pull a client’s data: you’re connected to an MCP, and you have at least Viewer on the client’s GA4 property. Once you’re set, run a quick check that it can see the property before you start a report. No connection means the run can’t start, and that’s an access step, not a failure of the analysis.
Run the analysis
Ask for the report in plain language. Any of these will trigger it:
- “Run the GA4 agent for [client]”
- “Website MAA for [client]”
- “Analyze [client]’s GA4”
The skill takes it from there. It figures out what kind of business the client is, because a plumber and an online store get read differently. It pulls the current four weeks and the prior four weeks so every number has a comparison, sorts out which events are real leads and which are noise, and grades how trustworthy the picture is before it writes anything. If the headline moved a lot, it digs into why instead of guessing.
What comes back is a written report: the business pulse, the numbers with their trend and channel breakdown, what it means, and a short list of what to do next. It’s a draft. It isn’t finished until you’ve read it.
One thing worth knowing. If the property has no usable data, or the tag stopped firing, the skill doesn’t pretend. It says the tracking is broken, explains what it checked, and hands you the one next step.
Review it before anyone sees it
This is the part that isn’t optional. The skill produces a draft; a human signs it off. That human is you.
Read the report as if you were the client. The test is simple: does the story hang together, and does anything in it fight what you already know about the account? Check the reds you can already explain and the greens you’d want a second look at. If a lead count looks off, check it against what the client actually gets.
The skill is careful, but it’s working from GA4 alone. GA4 only ever sees the online action, not the booked job or the collected revenue. Fix or flag anything that’s wrong, then move on. If it reads right, you’re clear to render the client view.
Render the client view
Run the second skill on the report you just approved:
- “Render the GA4 client view for [client]”
- “One-pager for [client]”
It reads the finished analysis and pulls the headline numbers, the trend, the channels, and the actions straight out of it. You get a self-contained HTML page and a print-ready PDF. Hand it the full analysis as a PDF too and it can staple the one-pager on the front, keeping the detail behind it.
The render step needs Python on your machine, and for the PDF it uses the copy of Chromium that’s already set up. You don’t install anything extra. The scripts that do the drawing live in the skill’s scripts/ folder, so you never hand-build the page.
Check the one-pager the same way you checked the report. Every number on the page should match the report it came from, nothing red should have quietly gone green, and the voice should read as “we.” Then it’s ready to send. Like the analysis, it’s a draft for review and never posts itself.
Follow the three rules that keep this safe
Everything above rests on three rules the skills won’t break, and you shouldn’t either.
Draft only. Neither skill posts anything. Both stop at a draft so a person can check it. Nothing reaches a client without that check.
Derive, don’t invent. The one-pager can only show what the analysis found. If you want something on the page, it has to be in the report first. That’s what keeps the pretty version honest.
Read-only on the client’s data. The analysis looks; it never touches. Every tracking fix it turns up gets written as an action for a person to go do, with the owner named.
Fix what doesn’t work
The run can’t start, or no data comes back. Almost always the MCP connection or property access. Confirm you can see the property in GA4 yourself, then confirm you’re connected to the MCP.
The numbers look wrong for the account. That’s exactly what the review step is for. Trust what you know about the client over the raw pull, check the lead count against reality, and correct the report before it goes out. GA4 sees the click, not the closed job.
The PDF won’t render. Check that Python is available and that you’re using the Chromium already set up on the machine. Don’t install a separate browser for it.
You’re not sure who the prepared-by should be. That’s in the ownership map that ships with the repo. Each client has a named owner on our side. Use that.
Find the standard in the repo
The repo carries its own documentation. The README explains the pair and how they chain, OWNERSHIP.md is the ownership map (who owns the skills, who reviews, and the prepared-by owner for each client), and each skill’s own references/ folder holds the standards it follows. If you want to know why the report is shaped the way it is, that’s where it’s written down.
Run the analysis, read it, render the view, sign it off. That’s the whole loop.
Daniel Goodrich builds and operates the analytics and tracking systems behind Local Service Spotlight’s reporting. He has spent twelve years in digital marketing on the digital-plumbing side of the work: GA4, call tracking, and conversion setup.
Drafted with an agent, from the GA4 reporting skills and the team MCP reference. Facts verified and published by Daniel Goodrich on August 20th, 2026.