I Automated My Job Search. Then I Made the Automation Maintain Itself.

This is a follow-up to Automated Job Search Monitoring System, the step-by-step guide to building the whole thing from scratch. If you haven't built the system yet, start there. If you have, this post is your upgrade path. Everything in the original still stands. These are enhancements, not replacements.

The 30-second recap, for anyone who missed the first article

The original system does one thing: it stops you from manually checking job boards.

You build a target company list (company names, career page URLs, and which applicant tracking system each one uses). You build a job log spreadsheet. You set up Gmail job alerts. Then Claude Cowork runs a scheduled sweep: it scans the alerts, pulls live roles from every company on your list, deduplicates against everything it's already seen, scores each new role against your criteria, and hands you a short report.

The full guide walks through every piece: the CSV structure, the ATS URL patterns, the scoring framework, the pipeline tracking. It's long because it's complete.

And here's the thing I want to say clearly before I get into the changes: it works. It has worked for months. I get a scored digest of new roles without opening a single job board. The time it saves me is real and I'd build it again tomorrow.

But running a system daily teaches you things that building it can't. Two things kept snagging. Both are now fixed, and both fixes made the system meaningfully better. Here they are.

Upgrade 1: The task was too long. So I built a relay.

The original design asked one scheduled task to do everything: sweep the alerts, hit every career page on the target list, pull every new role, then open every single job description and score it.

That last part is the problem. Finding jobs is fast. Reading them isn't. Pulling the full description for every new posting, one page at a time, is a long slog, and a single scheduled run would sometimes hit its limits before finishing. The sweep would find a batch of new roles and fully resolve most of them, and the rest sat in the log as titles with no descriptions. No description means no score, which means I still had to look at them myself.

That's the silent failure mode of any AI automation: the task doesn't error, it just doesn't finish, and you don't notice what's missing.

The fix was to stop asking one task to run a marathon and set up a relay instead. Three scheduled tasks. Each one starts fresh, each one has one job, and they hand off through the job log itself, because every task reads and writes the same spreadsheet. No task needs to remember what another task did. The log is the memory.

Here are all three, ready to copy. Paste each one into a new scheduled task in Claude Cowork, fill in the [BRACKETS] with your own file names and criteria, and space them out so each has room to finish (for example: sweep in the morning, Resolver an hour later, Safety an hour after that).

Task 1 of 3: The sweep. If you followed the original guide, this is the same morning sweep you built in the "Running the Morning Sweep" section and put on a schedule in "Automating the Sweep with Claude Cowork." Same job, one change: replace that task's prompt with this one. Its only job now is finding jobs. It's allowed to leave descriptions unresolved, because the next task exists.

Run my job search sweep. Check my Gmail job alerts, then check the career page of every company in [YOUR TARGET COMPANY FILE, e.g. Target_Companies.csv] for new postings matching [YOUR TITLES, e.g. "Director or Senior Director of Marketing"]. Compare everything you find against [YOUR JOB LOG FILE, e.g. Job_Log.xlsx] and skip anything already logged. Log every new role with the company, title, location, posting URL, and date found. Do NOT stop to open and read full job descriptions. If you have time left after logging everything, begin pulling full descriptions and scoring roles against [YOUR CRITERIA DOC OR SKILL]. If you run out of room, leave them unscored. A separate task finishes that job. End by telling me how many new roles you logged and how many still need descriptions.

Task 2 of 3: JD Resolver. This one is new; it doesn't exist in the original guide. It starts fresh, so it has a full run's worth of capacity for exactly the work the sweep left behind.

Open [YOUR JOB LOG FILE]. Find every role that has no job description or no score. For each one, visit the posting URL, pull the full job description, and score the role against [YOUR CRITERIA DOC OR SKILL]. Write the description summary and the score back into the log. Work through the list oldest first. If a posting URL is dead, mark the role "posting removed" instead of leaving it blank. End by telling me how many roles you resolved and how many remain unresolved, if any.

Task 3 of 3: JD Resolver Safety. Also new. Identical job to Task 2, later start. Its entire purpose is catching whatever the Resolver missed. Most days it finds nothing, and that's the point. It's the task that makes sure "the log is fully scored" is actually true instead of probably true.

Open [YOUR JOB LOG FILE]. This is a safety check: an earlier task should have already pulled and scored every job description. Verify that. If every logged role has a description and a score, end quietly and tell me the log is fully resolved. If any roles are still missing descriptions or scores, finish them now, exactly as the earlier task would: pull the full description from the posting URL, score it against [YOUR CRITERIA DOC OR SKILL], and write both into the log. End by telling me what you found and fixed.

The general principle, if you're building any version of this: don't give an AI agent one giant task. Give it a relay, and make the last runner a safety check.

Upgrade 2: The instructions went stale. So the system now updates its own.

This one matters more, and it's the upgrade I'd tell you to steal even if you never build the job search part.

First, a structural point I glossed over in the original guide: this whole system runs on skills.

The system's judgment lives in the instructions you give Claude: your scoring criteria, your must-haves, your deal-breakers, which kinds of roles you actually win. In the original guide that's your criteria doc ("The 5-Dimension Job Scoring Framework" section). A skill is the same content, promoted: an instruction file Claude automatically loads every time it does the job, instead of a doc you have to remember to hand it.

Why that matters: skills are just easier to update. Your criteria live in exactly one place, every task reads from that same place, and changing the file changes the behavior of every task at once. When your criteria live inside each task's prompt, or in a doc you paste in sometimes, you end up with three tasks running three slightly different versions of your strategy and no way to notice. If your criteria doc isn't a skill yet, that's the first move of this upgrade: tell Claude "turn my criteria doc into a skill," check what it produces, save it, and point your tasks at it. The task prompts above work either way (that's why the bracket says "criteria doc or skill"), but the skill version is the one that stays in sync, and it's the version the rest of this upgrade needs.

But even a skill is still a document, and documents go stale. Every time your strategy shifts (a new type of role enters the mix, a location rule changes, a salary requirement moves), the skill quietly falls behind, and the automation keeps confidently applying last month's strategy. I was maintaining the instructions by hand, which meant sometimes I wasn't.

The fix: a scheduled task whose entire job is updating the skill.

Once a week, a task wakes up, reads your current strategy documents, and compares them against what the skill currently says. If nothing meaningful changed, it goes back to sleep. If something did change, it rebuilds the skill file and sends you the updated version with a summary of what moved. You save it, and every future sweep runs on current strategy.

Here's the task, ready to copy. Paste it into a new weekly scheduled task and fill in the [BRACKETS].

Do a weekly sync check on my [YOUR SKILL NAME, e.g. job-search-criteria] skill. Steps:
1. Read the current version of the skill and note the date written inside it.
2. Read my current strategy documents: [LIST YOUR DOCS, e.g. My_Search_Criteria.md, Target_Titles.md, notes from this project]. Identify anything created or updated since the skill's date.
3. Decide: did anything meaningful change? Meaningful means my target titles, must-haves, deal-breakers, salary requirements, location rules, or scoring criteria. Routine activity (new jobs logged, minor edits) does NOT count.
4. If nothing meaningful changed: end quietly with a one-line note that the skill is still current. Don't send me anything else.
5. If something meaningful changed: rebuild the skill file with the updates, keeping its existing structure. Update the date inside it. Send me the new file with a short summary of exactly what changed, so I can review and save it.

That last line matters: the task doesn't silently overwrite your instructions, it hands you the new version with a changelog. You stay the editor. The system does the noticing, the comparing, and the rewriting, which is the part you were always going to forget to do.

Which closes the loop. You've probably heard people talk about "agentic loops," AI that improves itself. Most of that talk is hype. This is the small, boring, real version:

• Scheduled tasks do the work (sweep, resolve, score)
• A skill defines how the work gets done
• And a scheduled task keeps the skill current, with you approving every change

The automation and its instruction manual are now part of the same machine. That's the difference between an automation you run and a system that runs.

What this looks like now, all together

• Daily-ish: Sweep finds and logs new roles → JD Resolver pulls and scores the descriptions → JD Resolver Safety catches anything missed
• Weekly: The skill-refresh task checks whether my strategy moved and updates the instructions if it did
• Me: I read a scored digest and make decisions. That's the whole job now.

Nothing from the original article got thrown away. The target list, the job log, the scoring framework, the Gmail alerts, the pipeline stages: all still exactly as written there. If you built the original, both upgrades bolt straight on: replace your sweep task's prompt with Task 1 above, add Tasks 2 and 3 behind it, schedule the weekly refresh, and you're done. Nothing to rebuild.

If you haven't built it yet, the original guide is still the place to start. Build the system first. Then come back here and make it maintain itself.

Want to know if recruiters can actually find you before you automate anything? Run my free findability check at JobSearchDx.