I Can't Really Code. I Built an Indexing Monitor With Claude Anyway.

Three weeks ago a page that had been pulling steady search traffic for over a year disappeared from Google. Not deranked, just gone. I only noticed by accident, about ten days later, while poking around Search Console for something unrelated. Ten days of a page earning nothing because nobody, including me, was watching.

Some background: I’m a marketer. I run a small agency, I publish a lot of pages across a few sites, and my technical ceiling for the last decade has been editing HTML that someone else wrote. Our actual developers are busy with actual work, and “can you build me a thing that watches Google” is exactly the kind of request that dies in a backlog.

Search Console does show you indexing problems. It shows them to people who log in and go looking. I have around 400 URLs I care about across three properties, and I was never going to check them by hand on any schedule more honest than “when something feels off.”

I’d been reading Claude Code posts on here for months as a spectator. The genre is usually a developer using it to move faster. I wanted to know what happens when someone who can’t write the code at all uses it to start from zero. So I paid for a month and typed what I wanted in plain English.

Version one lasted twenty minutes

My first prompt was something like: check if these URLs are indexed in Google and tell me when one falls out. Claude cheerfully produced a script that ran a site: search for every URL and scraped the results page. It worked. For about twenty minutes. Then Google decided I was a robot, which was technically correct, and started serving captchas.

Nobody warned me about this part of vibe coding: the model will build exactly what you asked for, including when what you asked for is against the rules and dies on contact with reality. It only mentioned that scraping Google results is a bad idea after I pasted the captcha error and asked why everything was broken. Then it apologized and told me what it could have said at the start: there is an official way to do this.

Version two, the legitimate one

The official way is the URL Inspection API, part of Search Console. You send it a URL and it returns the same verdict you would see in the interface: indexed, crawled but currently not indexed, discovered but not indexed, and a few sadder ones. Quota is 2,000 inspections per day per property, which sounds tight until you remember I only have a few hundred URLs.

Getting access took one evening and most of my patience. The API wants a service account, which is a robot email address with a JSON key file. You then have to add that robot email as a user on your own Search Console property, like introducing a new coworker. Every guide assumes you already know this. I found it in a forum thread from 2022, after Claude and I had spent forty minutes convinced the key file was corrupted.

The part that does the work is short:

python
from google.oauth2 import service_account
from googleapiclient.discovery import build

SCOPES = [“https://www.googleapis.com/auth/webmasters”]

creds = service_account.Credentials.from_service_account_file(
“service-account.json”, scopes=SCOPES
)
gsc = build(“searchconsole”, “v1”, credentials=creds)

def coverage(url, prop):
body = {“inspectionUrl”: url, “siteUrl”: prop}
res = gsc.urlInspection().index().inspect(body=body).execute()
return res[“inspectionResult”][“indexStatusResult”][“coverageState”]

The rest is bookkeeping. Yesterday’s results live in a JSON file, today’s results get compared against them, and any URL that changed state goes into a Telegram message to my phone. Claude described the JSON file as “a lightweight persistence layer.” It’s a file.

python
old = json.loads(Path(“state.json”).read_text())
changes = []

for url in URLS:
state = coverage(url, PROP)
if url in old and old[url] != state:
changes.append(f”{url}\n{old[url]} -> {state}”)
old[url] = state
time.sleep(2)

Path(“state.json”).write_text(json.dumps(old, indent=2))

if changes:
telegram(“\n\n”.join(changes))

The sleep(2) is in there because Claude insisted, and I’ve learned not to argue with it about things I can’t verify.

Three weeks in

It runs on a cron job on the same five dollar server that hosts other things I’m afraid to touch. Every morning at seven I either get silence, which means everything is fine, or a short message naming a URL and what happened to it.

So far it has caught two pages sliding from indexed to “Crawled – currently not indexed.” Both times I resubmitted them the same day and they came back within the week. Before this, my realistic detection time was whenever I next felt paranoid, which historical evidence puts at about a month.

It has also woken me up once. An API error came back for one URL and my script, which treated anything unexpected as catastrophe, reported the page as deindexed at 3am. The page was fine. The script now knows the difference between “Google removed this” and “Google didn’t answer,” which took one more conversation with Claude and taught me more about error handling than I expected to learn this year.

What I actually think about vibe coding now

I have mixed feelings about the term. What I did wasn’t magic, and it wasn’t really coding either. It was describing, pasting errors, asking why, and slowly noticing that the answers repeat. I still can’t write Python from a blank file. I can now read it a little, the way you can read a menu in a language you don’t speak after two weeks in the country.

The uncomfortable part: I understand maybe seventy percent of what runs on my server, and that number is my ceiling, not my floor. If the auth breaks in some new way, I’m back to pasting errors and hoping. A real developer would find that unacceptable. For a marketer with 400 URLs and zero backlog priority, it beats the alternative, which was nothing.

So, a question for the people here who do this properly. Where is the line where a script like this deserves real engineering? Tests, retries, an actual database. Or is duct tape the right amount of engineering for something with one user who is also the author? I genuinely can’t tell, and I’d rather hear it from you than from the model that wrote the duct tape.